![]() |
![]() |
00001 /******************************************************************************* 00002 * GX LOG header file - V7.2.12 00003 * 00004 * 2004-2015 (c) Adaptive Recognition (https://adaptiverecognition.com) 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 /* GX_SWIGIF GX_MANUAL )*/ 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 // In the release mode does not write debug items. (file, line, pretty_function) 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 /******************************************************************************/