00001
00002
00003
00004
00005
00015
00016 #ifndef GX_LOG_INCL
00017 #define GX_LOG_INCL
00018
00019 #include <assert.h>
00020 #if defined(WIN32) && !defined(GX_DOTNET)
00021 #include <windows.h>
00022 #endif
00023 #ifdef LINUX
00024 #include <pthread.h>
00025 #endif
00026 #include <stdarg.h>
00027 #include <stdlib.h>
00028 #include <errno.h>
00029 #include "gxsd.h"
00030
00031 #ifdef GX_NAMESPACES
00032 namespace gx {
00033 #endif
00034
00035 #ifdef GX_DOTNET
00036 #pragma managed
00037 #endif
00038
00040 GX_ENUM GX_LOGLEVELS {
00041 GX_NONE = 0,
00042 GX_EMERG,
00043 GX_FATAL,
00044 GX_ERROR,
00045 GX_WARN,
00046 GX_INFO,
00047 GX_INFO2,
00048 GX_INFO3,
00049 GX_DEBUG,
00050 GX_DEBUG2
00051 };
00052
00053 #ifdef GX_DOTNET
00054 #pragma unmanaged
00055 #endif
00056
00057 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL)
00058
00060 enum {
00061 GX_CALL_WRITELOG = GX_CALL_GROUP_GX_LOG,
00062 GX_CALL_WRITELOGA
00063 };
00064
00066 struct GX_PARM_WRITELOG {
00067 gxi32 level;
00068 const char *file;
00069 gxi32 line;
00070 const char *function;
00071 const wchar_t *string;
00072 va_list args;
00073 };
00074
00076 struct GX_PARM_WRITELOGA {
00077 gxi32 level;
00078 const char *file;
00079 gxi32 line;
00080 const char *function;
00081 const char *string;
00082 va_list args;
00083 };
00084 #endif
00085
00086
00087 #if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF)
00088
00089
00090
00094
00095
00096
00107 inline gxi32 gx_writelogv(gxHANDLE handle, gxi32 level,
00108 const char *file, gxi32 line, const char *function,
00109 const wchar_t *str, va_list args) {
00110 struct GX_PARM_WRITELOG wl;
00111 gxi32 st;
00112 wl.level = level;
00113 wl.file = file;
00114 wl.line = line;
00115 wl.function = function;
00116 wl.string = str;
00117 va_copy(wl.args, args);
00118 st = gx_call(handle, GX_CALL_WRITELOG, &wl);
00119 va_end(wl.args);
00120 return st;
00121 }
00122
00123 #ifdef __cplusplus
00124
00132 inline gxi32 gx_writelogv(gxHANDLE handle, gxi32 level, const wchar_t *str, va_list args) {
00133 return gx_writelogv(handle, level,
00134 (const char *)0, 0, (const char *)0, str, args);
00135 }
00136 #endif
00137
00138
00149 inline gxi32 gx_writelogva(gxHANDLE handle, gxi32 level,
00150 const char *file, gxi32 line, const char *function,
00151 const char *str, va_list args) {
00152 struct GX_PARM_WRITELOGA wl;
00153 gxi32 st;
00154 wl.level = level;
00155 wl.file = file;
00156 wl.line = line;
00157 wl.function = function;
00158 wl.string = str;
00159 va_copy(wl.args, args);
00160 st = gx_call(handle, GX_CALL_WRITELOGA, &wl);
00161 va_end(wl.args);
00162 return st;
00163 }
00164
00165 #ifdef __cplusplus
00166
00174 inline gxi32 gx_writelogv(gxHANDLE handle, gxi32 level,
00175 const char *str, va_list args) {
00176 return gx_writelogva(handle, level,
00177 (const char *)0, 0, (const char *)0, str, args);
00178 }
00179
00180
00191 inline gxi32 gx_writelogv(gxHANDLE handle, gxi32 level,
00192 const char *file, gxi32 line, const char *function,
00193 const char *str, va_list args) {
00194 return gx_writelogva(handle, level, file, line, function, str, args);
00195 }
00196 #endif
00197
00208 inline gxi32 gx_writelog(gxHANDLE handle, gxi32 level,
00209 const char *file, gxi32 line, const char *function,
00210 const wchar_t *str, ...) {
00211 gxi32 st;
00212 va_list args;
00213 va_start(args, str);
00214 st = gx_writelogv(handle, level, file, line, function, str, args);
00215 va_end(args);
00216 return st;
00217 }
00218
00219 #ifdef __cplusplus
00220
00228 inline gxi32 gx_writelog(gxHANDLE handle, gxi32 level, const wchar_t *str, ...) {
00229 va_list args;
00230 va_start(args, str);
00231 gxi32 st = gx_writelogv(handle, level, str, args);
00232 va_end(args);
00233 return st;
00234 }
00235 #endif
00236
00237
00248 inline gxi32 gx_writeloga(gxHANDLE handle, gxi32 level,
00249 const char *file, gxi32 line, const char *function,
00250 const char *str, ...) {
00251 gxi32 st;
00252 va_list args;
00253 va_start(args, str);
00254 st = gx_writelogva(handle, level, file, line, function, str, args);
00255 va_end(args);
00256 return st;
00257 }
00258
00259 #ifdef __cplusplus
00260
00268 inline gxi32 gx_writelog(gxHANDLE handle, gxi32 level, const char *str, ...) {
00269 va_list args;
00270 va_start(args, str);
00271 int st = gx_writelogv(handle, level, str, args);
00272 va_end(args);
00273 return st;
00274 }
00275
00276
00287 inline gxi32 gx_writelog(gxHANDLE handle, gxi32 level,
00288 const char *file, gxi32 line, const char *function,
00289 const char *str, ...) {
00290 gxi32 st;
00291 va_list args;
00292 va_start(args, str);
00293 st = gx_writelogv(handle, level, file, line, function, str, args);
00294 va_end(args);
00295 return st;
00296 }
00297 #endif
00298
00299 #ifdef __cplusplus
00300
00310 inline gxi32 gx_writelogv(gxi32 level,
00311 const char *file, gxi32 line, const char *function,
00312 const wchar_t *str, va_list args) {
00313 return gx_writelogv(gx_direct(GX_CALL_GROUP_GX_LOG), level,
00314 file, line, function, str, args);
00315 }
00316
00317
00324 inline gxi32 gx_writelogv(gxi32 level, const wchar_t *str, va_list args) {
00325 return gx_writelogv(level, (const char *)0, 0, (const char *)0, str, args);
00326 }
00327
00328
00338 inline gxi32 gx_writelogv(gxi32 level,
00339 const char *file, gxi32 line, const char *function,
00340 const char *str, va_list args) {
00341 return gx_writelogv(gx_direct(GX_CALL_GROUP_GX_LOG), level,
00342 file, line, function, str, args);
00343 }
00344
00345
00352 inline gxi32 gx_writelogv(gxi32 level, const char *str, va_list args) {
00353 return gx_writelogv(level, (const char *)0, 0, (const char *)0, str, args);
00354 }
00355
00356
00366 inline gxi32 gx_writelog(gxi32 level,
00367 const char *file, gxi32 line, const char *function,
00368 const wchar_t *str, ...) {
00369 va_list args;
00370 va_start(args, str);
00371 gxi32 st = gx_writelogv(gx_direct(GX_CALL_GROUP_GX_LOG), level,
00372 file, line, function, str, args);
00373 va_end(args);
00374 return st;
00375 }
00376
00383 inline gxi32 gx_writelog(gxi32 level, const wchar_t *str, ...) {
00384 va_list args;
00385 va_start(args, str);
00386 gxi32 st = gx_writelogv(level, str, args);
00387 va_end(args);
00388 return st;
00389 }
00390
00391
00401 inline gxi32 gx_writelog(gxi32 level,
00402 const char *file, gxi32 line, const char *function,
00403 const char *str, ...) {
00404 va_list args;
00405 va_start(args, str);
00406 gxi32 st = gx_writelogv(gx_direct(GX_CALL_GROUP_GX_LOG), level,
00407 file, line, function, str, args);
00408 va_end(args);
00409 return st;
00410 }
00411
00412
00419 inline gxi32 gx_writelog(gxi32 level, const char *str, ...) {
00420 va_list args;
00421 va_start(args, str);
00422 int st = gx_writelogv(level, str, args);
00423 va_end(args);
00424 return st;
00425 }
00426 #endif
00427
00428
00430
00431
00432 #endif // !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF)
00433
00434 #ifdef GX_DOTNET
00435 #pragma managed
00436 #endif
00437
00438
00439
00440 #ifndef NO_GX_CLASSES
00441
00442
00444 GX_CLASS gxLog : public gxHandle
00445 #ifdef GX_DOTNET
00446 , public System::IDisposable
00447 #endif
00448 {
00449 #if (!defined(NDEBUG) || defined(DEBUG)) && !defined(GX_SWIGIF) && !defined(GX_DOTNET)
00450 private:
00451 #ifdef LINUX
00452 pthread_mutex_t mutex;
00455 inline void _mutex_init(void) {
00456 pthread_mutex_init(&mutex, 0);
00457 }
00459 inline void _mutex_destroy(void) {
00460 pthread_mutex_destroy(&mutex);
00461 }
00463 inline void _mutex_lock(void) {
00464 pthread_mutex_lock(&mutex);
00465 }
00467 inline void _mutex_unlock(void) {
00468 pthread_mutex_unlock(&mutex);
00469 }
00470 #endif
00471
00472 #ifdef WIN32
00473 HANDLE mutex;
00476 inline void _mutex_init(void) {
00477 mutex = CreateSemaphore(0, 1, 1, 0);
00478 }
00480 inline void _mutex_destroy(void) {
00481 CloseHandle(mutex);
00482 }
00484 inline void _mutex_lock(void) {
00485 WaitForSingleObject(mutex, INFINITE);
00486 }
00488 inline void _mutex_unlock(void) {
00489 ReleaseSemaphore(mutex, 1, 0);
00490 }
00491 #endif
00492
00493 gxi32 _level;
00494 const char *_file;
00495 gxi32 _line;
00496 const char *_pretty_function;
00498 public:
00504 inline void _Set(gxi32 level, const char *file, gxi32 line, const char *pretty_function) {
00505 _mutex_lock();
00506 _level = level;
00507 _file = file;
00508 _line = line;
00509 _pretty_function = pretty_function;
00510 }
00511
00515 inline void _WriteLog(const wchar_t *str, ...) gxFuncThrowsError {
00516 va_list args;
00517 va_start(args, str);
00518 int st;
00519 st = gx_writelogv(*this, _level, _file, _line, _pretty_function, str, args);
00520 va_end(args);
00521 _mutex_unlock();
00522 gxcondthrow(!st);
00523 }
00524
00528 inline void _WriteLog(const char *str, ...) gxFuncThrowsError {
00529 va_list args;
00530 va_start(args, str);
00531 int st;
00532 st = gx_writelogv(*this, _level, _file, _line, _pretty_function, str, args);
00533 va_end(args);
00534 _mutex_unlock();
00535 gxcondthrow(!st);
00536 }
00537 #endif
00538
00539 public:
00541 inline gxLog() gxFuncThrowsError : gxHandle() {
00542 #if (!defined(NDEBUG) || defined(DEBUG)) && !defined(GX_DOTNET)
00543 _mutex_init();
00544 #endif
00545 #ifndef GX_DOTNET
00546 if(!gx_openmodule(this, L"gxlog", L"default")) gxthrow;
00547 #else
00548 GX_GETHANDLE(h);
00549 if(!gx_openmodule(&h, L"gxlog", L"default")) gxthrow;
00550 _set_handle(h.handle);
00551 #endif
00552 }
00553
00554 #if !defined(GX_DOTNET) && !defined(GX_SWIG)
00555
00558 inline gxLog(const wchar_t *propname,
00559 const wchar_t *modname = (const wchar_t *)0) gxFuncThrowsError : gxHandle() {
00560
00561 #if !defined(NDEBUG) || defined(DEBUG)
00562 _mutex_init();
00563 #endif
00564 if(!gx_openmodule(this, modname ? modname : L"gxlog", propname)) gxthrow;
00565 }
00566
00570 inline gxLog(const char *propname,
00571 const char *modname = (const char *)0) gxFuncThrowsError : gxHandle() {
00572
00573 #if !defined(NDEBUG) || defined(DEBUG)
00574 _mutex_init();
00575 #endif
00576 if(!gx_openmodule(this, modname ? modname : "gxlog", propname)) gxthrow;
00577 }
00578 #endif
00579
00580 #ifdef GX_UNICODE
00581
00584 inline gxLog(gxInStr propname, gxInStr modname) gxFuncThrowsError : gxHandle() {
00585 GX_GETSTRING(_propname, propname);
00586 GX_GETSTRING(_modname, modname);
00587 #if (!defined(NDEBUG) || defined(DEBUG)) && !defined(GX_DOTNET)
00588 _mutex_init();
00589 #endif
00590 #ifndef GX_DOTNET
00591 if(!gx_openmodule(this, _modname, _propname)) gxthrow;
00592 #else
00593 GX_GETHANDLE(h);
00594 if(!gx_openmodule(&h, _modname, _propname)) gxthrow;
00595 _set_handle(h.handle);
00596 #endif
00597 }
00598
00601 inline gxLog(gxInStr propname) gxFuncThrowsError {
00602 GX_GETSTRING(_propname, propname);
00603 #if (!defined(NDEBUG) || defined(DEBUG)) && !defined(GX_DOTNET)
00604 _mutex_init();
00605 #endif
00606 #ifndef GX_DOTNET
00607 if(!gx_openmodule(this, L"gxlog", _propname)) gxthrow;
00608 #else
00609 GX_GETHANDLE(h);
00610 if(!gx_openmodule(&h, L"gxlog", _propname)) gxthrow;
00611 _set_handle(h.handle);
00612 #endif
00613 }
00614 #endif
00615
00616 #ifdef GX_ASCII
00617
00620 inline gxLog(gxInAStr propname, gxInAStr modname) gxFuncThrowsError {
00621 GX_GETASTRING(_propname, propname);
00622 GX_GETASTRING(_modname, modname);
00623 #if !defined(NDEBUG) || defined(DEBUG)
00624 _mutex_init();
00625 #endif
00626 if(!gx_openmodule(this, _modname, _propname)) gxthrow;
00627 }
00630 inline gxLog(gxInAStr propname) gxFuncThrowsError {
00631 GX_GETASTRING(_propname, propname);
00632 #if !defined(NDEBUG) || defined(DEBUG)
00633 _mutex_init();
00634 #endif
00635 if(!gx_openmodule(this, "gxlog", _propname)) gxthrow;
00636 }
00637 #endif
00638
00640 inline ~gxLog() {
00641 _Dispose();
00642 }
00643
00644 #ifdef GX_DOTNET_20
00645 inline !gxLog() {
00646 _Dispose();
00647 }
00648 #else
00649
00650 inline void Dispose(void) {
00651 #ifdef GX_DOTNET
00652 System::GC::SuppressFinalize(this);
00653 #endif
00654 _Dispose();
00656 gxHandle::Dispose();
00657 }
00658 #endif
00659
00660 private:
00662 inline void _Dispose(void) {
00663 #if (!defined(NDEBUG) || defined(DEBUG)) && !defined(GX_DOTNET)
00664 _mutex_destroy();
00665 #endif
00666 }
00667
00668 public:
00669
00670 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
00671
00679 inline bool WriteLogv(gxi32 level, const char *file, gxi32 line, const char *function,
00680 const wchar_t *str, va_list args) gxFuncThrowsError {
00681 bool st = gx_writelogv(*this, level, file, line, function, str, args) ? true : false;
00682 gxcondthrow(!st);
00683 return st;
00684 }
00685
00691 inline bool WriteLogv(gxi32 level, const wchar_t *str, va_list args) gxFuncThrowsError {
00692 bool st = gx_writelogv(*this, level, str, args) ? true : false;
00693 gxcondthrow(!st);
00694 return st;
00695 }
00696
00705 inline bool WriteLogv(gxi32 level, const char *file, gxi32 line, const char *function,
00706 const char *str, va_list args) gxFuncThrowsError {
00707 bool st = gx_writelogv(*this, level, file, line, function, str, args) ? true : false;
00708 gxcondthrow(!st);
00709 return st;
00710 }
00711
00717 inline bool WriteLogv(gxi32 level, const char *str, va_list args) gxFuncThrowsError {
00718 bool st = gx_writelogv(*this, level, str, args) ? true : false;
00719 gxcondthrow(!st);
00720 return st;
00721 }
00722
00731 inline bool WriteLog(gxi32 level, const char *file, gxi32 line, const char *function,
00732 const wchar_t *str, ...) gxFuncThrowsError {
00733 va_list args;
00734 va_start(args, str);
00735 bool st = gx_writelogv(*this, level, file, line, function, str, args) ? true : false;
00736 va_end(args);
00737 gxcondthrow(!st);
00738 return st;
00739 }
00740
00746 inline bool WriteLog(gxi32 level, const wchar_t *str, ...) gxFuncThrowsError {
00747 va_list args;
00748 va_start(args, str);
00749 bool st = gx_writelogv(*this, level, str, args) ? true : false;
00750 va_end(args);
00751 gxcondthrow(!st);
00752 return st;
00753 }
00754
00763 inline bool WriteLog(gxi32 level, const char *file, gxi32 line, const char *function,
00764 const char *str, ...) gxFuncThrowsError {
00765 va_list args;
00766 va_start(args, str);
00767 bool st = gx_writelogv(*this, level, file, line, function, str, args) ? true : false;
00768 va_end(args);
00769 gxcondthrow(!st);
00770 return st;
00771 }
00772
00778 inline bool WriteLog(gxi32 level, const char *str, ...) gxFuncThrowsError {
00779 va_list args;
00780 va_start(args, str);
00781 bool st = gx_writelogv(*this, level, str, args) ? true : false;
00782 va_end(args);
00783 gxcondthrow(!st);
00784 return st;
00785 }
00786
00791 inline bool WriteEmergency(const wchar_t *str, ...) gxFuncThrowsError {
00792 va_list args;
00793 va_start(args, str);
00794 bool st = WriteLogv(GX_EMERG, str, args);
00795 va_end(args);
00796 gxcondthrow(!st);
00797 return st;
00798 }
00803 inline bool WriteEmergency(const char *str, ...) gxFuncThrowsError {
00804 va_list args;
00805 va_start(args, str);
00806 bool st = WriteLogv(GX_EMERG, str, args);
00807 va_end(args);
00808 gxcondthrow(!st);
00809 return st;
00810 }
00811
00816 inline bool WriteFatal(const wchar_t *str, ...) gxFuncThrowsError {
00817 va_list args;
00818 va_start(args, str);
00819 bool st = WriteLogv(GX_FATAL, str, args);
00820 va_end(args);
00821 gxcondthrow(!st);
00822 return st;
00823 }
00828 inline bool WriteFatal(const char *str, ...) gxFuncThrowsError {
00829 va_list args;
00830 va_start(args, str);
00831 bool st = WriteLogv(GX_FATAL, str, args);
00832 va_end(args);
00833 gxcondthrow(!st);
00834 return st;
00835 }
00836
00841 inline bool WriteError(const wchar_t *str, ...) gxFuncThrowsError {
00842 va_list args;
00843 va_start(args, str);
00844 bool st = WriteLogv(GX_ERROR, str, args);
00845 va_end(args);
00846 gxcondthrow(!st);
00847 return st;
00848 }
00853 inline bool WriteError(const char *str, ...) gxFuncThrowsError {
00854 va_list args;
00855 va_start(args, str);
00856 bool st = WriteLogv(GX_ERROR, str, args);
00857 va_end(args);
00858 gxcondthrow(!st);
00859 return st;
00860 }
00861
00866 inline bool WriteWarning(const wchar_t *str, ...) gxFuncThrowsError {
00867 va_list args;
00868 va_start(args, str);
00869 bool st = WriteLogv(GX_WARN, str, args);
00870 va_end(args);
00871 gxcondthrow(!st);
00872 return st;
00873 }
00878 inline bool WriteWarning(const char *str, ...) gxFuncThrowsError {
00879 va_list args;
00880 va_start(args, str);
00881 bool st = WriteLogv(GX_WARN, str, args);
00882 va_end(args);
00883 gxcondthrow(!st);
00884 return st;
00885 }
00886
00891 inline bool WriteInfo(const wchar_t *str, ...) gxFuncThrowsError {
00892 va_list args;
00893 va_start(args, str);
00894 bool st = WriteLogv(GX_INFO, str, args);
00895 va_end(args);
00896 gxcondthrow(!st);
00897 return st;
00898 }
00903 inline bool WriteInfo(const char *str, ...) gxFuncThrowsError {
00904 va_list args;
00905 va_start(args, str);
00906 bool st = WriteLogv(GX_INFO, str, args);
00907 va_end(args);
00908 gxcondthrow(!st);
00909 return st;
00910 }
00911
00916 inline bool WriteInfo2(const wchar_t *str, ...) gxFuncThrowsError {
00917 va_list args;
00918 va_start(args, str);
00919 bool st = WriteLogv(GX_INFO2, str, args);
00920 va_end(args);
00921 gxcondthrow(!st);
00922 return st;
00923 }
00928 inline bool WriteInfo2(const char *str, ...) gxFuncThrowsError {
00929 va_list args;
00930 va_start(args, str);
00931 bool st = WriteLogv(GX_INFO2, str, args);
00932 va_end(args);
00933 gxcondthrow(!st);
00934 return st;
00935 }
00936
00941 inline bool WriteInfo3(const wchar_t *str, ...) gxFuncThrowsError {
00942 va_list args;
00943 va_start(args, str);
00944 bool st = WriteLogv(GX_INFO3, str, args);
00945 va_end(args);
00946 gxcondthrow(!st);
00947 return st;
00948 }
00953 inline bool WriteInfo3(const char *str, ...) gxFuncThrowsError {
00954 va_list args;
00955 va_start(args, str);
00956 bool st = WriteLogv(GX_INFO3, str, args);
00957 va_end(args);
00958 gxcondthrow(!st);
00959 return st;
00960 }
00961 #endif
00962
00963 #ifdef GX_UNICODE
00964
00971 inline bool WriteLog(gxi32 level, gxInStr file, gxi32 line, gxInStr function,
00972 gxInStr str) gxFuncThrowsError {
00973 GX_GETSTRING(_file, file);
00974 GX_GETSTRING(_function, function);
00975 GX_GETSTRING(_str, str);
00976 char __file[1024];
00977 char __function[1024];
00978 gx_snprintf(__file,1024,"%ls",_file);
00979 gx_snprintf(__function,1024,"%ls",_function);
00980 GX_GETHANDLE(h);
00981 bool st = gx_writelog(h, level, __file, line, __function, L"%ls", _str) ? true : false;
00982 gxcondthrow(!st);
00983 return st;
00984 }
00985
00990 inline bool WriteLog(gxi32 level, gxInStr str) gxFuncThrowsError {
00991 GX_GETSTRING(_str, str);
00992 GX_GETHANDLE(h);
00993 bool st = gx_writelog(h, level, L"%ls", _str) ? true : false;
00994 gxcondthrow(!st);
00995 return st;
00996 }
00997
01001 inline bool WriteEmergency(gxInStr str) gxFuncThrowsError {
01002 GX_GETSTRING(_str, str);
01003 GX_GETHANDLE(h);
01004 bool st = gx_writelog(h, (int)GX_ENUM_PATH(GX_LOGLEVELS) GX_EMERG, L"%ls", _str) ? true : false;
01005 gxcondthrow(!st);
01006 return st;
01007 }
01011 inline bool WriteFatal(gxInStr str) gxFuncThrowsError {
01012 GX_GETSTRING(_str, str);
01013 GX_GETHANDLE(h);
01014 bool st = gx_writelog(h, (int)GX_ENUM_PATH(GX_LOGLEVELS) GX_FATAL, L"%ls", _str) ? true : false;
01015 gxcondthrow(!st);
01016 return st;
01017 }
01021 inline bool WriteError(gxInStr str) gxFuncThrowsError {
01022 GX_GETSTRING(_str, str);
01023 GX_GETHANDLE(h);
01024 bool st = gx_writelog(h, (int)GX_ENUM_PATH(GX_LOGLEVELS) GX_ERROR, L"%ls", _str) ? true : false;
01025 gxcondthrow(!st);
01026 return st;
01027 }
01031 inline bool WriteWarning(gxInStr str) gxFuncThrowsError {
01032 GX_GETSTRING(_str, str);
01033 GX_GETHANDLE(h);
01034 bool st = gx_writelog(h, (int)GX_ENUM_PATH(GX_LOGLEVELS) GX_WARN, L"%ls", _str) ? true : false;
01035 gxcondthrow(!st);
01036 return st;
01037 }
01041 inline bool WriteInfo(gxInStr str) gxFuncThrowsError {
01042 GX_GETSTRING(_str, str);
01043 GX_GETHANDLE(h);
01044 bool st = gx_writelog(h, (int)GX_ENUM_PATH(GX_LOGLEVELS) GX_INFO, L"%ls", _str) ? true : false;
01045 gxcondthrow(!st);
01046 return st;
01047 }
01051 inline bool WriteInfo2(gxInStr str) gxFuncThrowsError {
01052 GX_GETSTRING(_str, str);
01053 GX_GETHANDLE(h);
01054 bool st = gx_writelog(h, (int)GX_ENUM_PATH(GX_LOGLEVELS) GX_INFO2, L"%ls", _str) ? true : false;
01055 gxcondthrow(!st);
01056 return st;
01057 }
01061 inline bool WriteInfo3(gxInStr str) gxFuncThrowsError {
01062 GX_GETSTRING(_str, str);
01063 GX_GETHANDLE(h);
01064 bool st = gx_writelog(h, (int)GX_ENUM_PATH(GX_LOGLEVELS) GX_INFO3, L"%ls", _str) ? true : false;
01065 gxcondthrow(!st);
01066 return st;
01067 }
01068 #endif
01069 #ifdef GX_ASCII
01070
01077 inline bool WriteLog(gxi32 level, gxInAStr file, gxi32 line, gxInAStr function,
01078 gxInAStr str) gxFuncThrowsError {
01079 GX_GETASTRING(_file, file);
01080 GX_GETASTRING(_function, function);
01081 GX_GETASTRING(_str, str);
01082 bool st = gx_writelog(*this, level, _file, line, _function, "%hs", _str) ? true : false;
01083 gxcondthrow(!st);
01084 return st;
01085 }
01090 inline bool WriteLog(gxi32 level, gxInAStr str) gxFuncThrowsError {
01091 GX_GETASTRING(_str, str);
01092 bool st = gx_writelog(*this, level, "%hs", _str) ? true : false;
01093 gxcondthrow(!st);
01094 return st;
01095 }
01096
01100 inline bool WriteEmergency(gxInAStr str) gxFuncThrowsError {
01101 GX_GETASTRING(_str, str);
01102 bool st = gx_writelog(*this, GX_EMERG, "%hs", _str) ? true : false;
01103 gxcondthrow(!st);
01104 return st;
01105 }
01109 inline bool WriteFatal(gxInAStr str) gxFuncThrowsError {
01110 GX_GETASTRING(_str, str);
01111 bool st = gx_writelog(*this, GX_FATAL, "%hs", _str) ? true : false;
01112 gxcondthrow(!st);
01113 return st;
01114 }
01118 inline bool WriteError(gxInAStr str) gxFuncThrowsError {
01119 GX_GETASTRING(_str, str);
01120 bool st = gx_writelog(*this, GX_ERROR, "%hs", _str) ? true : false;
01121 gxcondthrow(!st);
01122 return st;
01123 }
01127 inline bool WriteWarning(gxInAStr str) gxFuncThrowsError {
01128 GX_GETASTRING(_str, str);
01129 bool st = gx_writelog(*this, GX_WARN, "%hs", _str) ? true : false;
01130 gxcondthrow(!st);
01131 return st;
01132 }
01136 inline bool WriteInfo(gxInAStr str) gxFuncThrowsError {
01137 GX_GETASTRING(_str, str);
01138 bool st = gx_writelog(*this, GX_INFO, "%hs", _str) ? true : false;
01139 gxcondthrow(!st);
01140 return st;
01141 }
01145 inline bool WriteInfo2(gxInAStr str) gxFuncThrowsError {
01146 GX_GETASTRING(_str, str);
01147 bool st = gx_writelog(*this, GX_INFO2, "%hs", _str) ? true : false;
01148 gxcondthrow(!st);
01149 return st;
01150 }
01154 inline bool WriteInfo3(gxInAStr str) gxFuncThrowsError {
01155 GX_GETASTRING(_str, str);
01156 bool st = gx_writelog(*this, GX_INFO3, "%hs", _str) ? true : false;
01157 gxcondthrow(!st);
01158 return st;
01159 }
01160 #endif
01161 };
01162
01163 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01164
01165 #if !defined(NDEBUG) || defined(DEBUG)
01166
01169 #define gx_emerg \
01170 gxlog._Set(GX_EMERG, __FILE__, __LINE__, _GX_FUNCTION_), \
01171 gxlog._WriteLog
01172
01175 #define gx_emergency gx_emerg
01176
01179 #define gx_fatal \
01180 gxlog._Set(GX_FATAL, __FILE__, __LINE__, _GX_FUNCTION_), \
01181 gxlog._WriteLog
01182
01185 #define gx_error \
01186 gxlog._Set(GX_ERROR, __FILE__, __LINE__, _GX_FUNCTION_), \
01187 gxlog._WriteLog
01188
01191 #define gx_warn \
01192 gxlog._Set(GX_WARN, __FILE__, __LINE__, _GX_FUNCTION_), \
01193 gxlog._WriteLog
01194
01197 #define gx_warning gx_warn
01198
01201 #define gx_info \
01202 gxlog._Set(GX_INFO, __FILE__, __LINE__, _GX_FUNCTION_), \
01203 gxlog._WriteLog
01204
01207 #define gx_info2 \
01208 gxlog._Set(GX_INFO2, __FILE__, __LINE__, _GX_FUNCTION_), \
01209 gxlog._WriteLog
01210
01213 #define gx_info3 \
01214 gxlog._Set(GX_INFO3, __FILE__, __LINE__, _GX_FUNCTION_), \
01215 gxlog._WriteLog
01216
01219 #define gx_debug \
01220 gxlog._Set(GX_DEBUG, __FILE__, __LINE__, _GX_FUNCTION_), \
01221 gxlog._WriteLog
01222
01225 #define gx_debug2 \
01226 gxlog._Set(GX_DEBUG2, __FILE__, __LINE__, _GX_FUNCTION_), \
01227 gxlog._WriteLog
01228
01229 #else
01230
01231
01232
01233 #define gx_emerg gxlog.WriteEmergency
01234 #define gx_emergency gxlog.WriteEmergency
01235
01236 #define gx_fatal gxlog.WriteFatal
01237
01238 #define gx_error gxlog.WriteError
01239
01240 #define gx_warn gxlog.WriteWarning
01241 #define gx_warning gxlog.WriteWarning
01242
01243 #define gx_info gxlog.WriteInfo
01244 #define gx_info2 gxlog.WriteInfo2
01245 #define gx_info3 gxlog.WriteInfo3
01246
01247 inline void __gx_no_write(const char *str, ...) { }
01248 inline void __gx_no_write(const wchar_t *str, ...) { }
01249
01250 #define gx_debug if(0) __gx_no_write
01251
01252 #define gx_debug2 if(0) __gx_no_write
01253
01254 #endif // !defined(NDEBUG) || defined(DEBUG)
01255
01256 #endif // !defined(GX_SWIGIF) && !defined(GX_DOTNET)
01257
01258
01259 #endif//NO_GX_CLASSES
01260
01261 #ifdef GX_NAMESPACES
01262 }
01263 #endif
01264
01265 #endif//GX_LOG_INCL
01266
