UCommon
|
00001 // Copyright (C) 2005-2015 Angelo Naselli, Penta Engineering s.r.l. 00002 // 00003 // This program is free software; you can redistribute it and/or modify 00004 // it under the terms of the GNU General Public License as published by 00005 // the Free Software Foundation; either version 2 of the License, or 00006 // (at your option) any later version. 00007 // 00008 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00009 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00010 // GNU General Public License for more details. 00011 // 00012 // You should have received a copy of the GNU Lesser General Public License 00013 // along with this program. If not, see <http://www.gnu.org/licenses/>. 00014 // 00015 // As a special exception, you may use this file as part of a free software 00016 // library without restriction. Specifically, if other files instantiate 00017 // templates or use macros or inline functions from this file, or you compile 00018 // this file and link it with other files to produce an executable, this 00019 // file does not by itself cause the resulting executable to be covered by 00020 // the GNU General Public License. This exception does not however 00021 // invalidate any other reasons why the executable file might be covered by 00022 // the GNU General Public License. 00023 // 00024 // This exception applies only to the code released under the name GNU 00025 // Common C++. If you copy code from other releases into a copy of GNU 00026 // Common C++, as the General Public License permits, the exception does 00027 // not apply to the code that you add in this way. To avoid misleading 00028 // anyone as to the status of such modified files, you must delete 00029 // this exception notice from them. 00030 // 00031 // If you write modifications of your own for GNU Common C++, it is your choice 00032 // whether to permit this exception to apply to your modifications. 00033 // If you do not wish that, delete this exception notice. 00034 // 00035 00042 #ifndef COMMONCPP_APPLOG_H_ 00043 #define COMMONCPP_APPLOG_H_ 00044 00045 #ifndef COMMONCPP_CONFIG_H_ 00046 #include <commoncpp/config.h> 00047 #endif 00048 00049 #ifndef COMMONCPP_SLOG_H_ 00050 #include <commoncpp/slog.h> 00051 #endif 00052 00053 #ifndef COMMONCPP_EXCEPTION_H_ 00054 #include <commoncpp/exception.h> 00055 #endif 00056 00057 #include <string> 00058 #include <sstream> 00059 #include <iostream> 00060 #include <map> 00061 00062 namespace ost { 00063 using namespace std; 00064 00073 class __EXPORT HEXdump 00074 { 00075 protected: 00079 std::string _str; 00080 00081 public: 00082 // max_len: max number of bytes to be printed. 0 prints all. 00091 HEXdump(const unsigned char *buffer, int buff_len, int max_len = 200); 00092 00096 virtual ~HEXdump() { _str = string();} 00097 00102 const char * c_str() const { 00103 return _str.c_str(); 00104 } 00105 00109 std::string str() { 00110 return _str; 00111 } 00112 00118 friend std::ostream& operator<< (std::ostream& out, const HEXdump &hd) 00119 { 00120 out << hd.c_str(); 00121 return out; 00122 } 00123 00124 }; 00125 00126 #ifdef CCXX_EXCEPTIONS 00127 00131 class __EXPORT AppLogException : public ost::Exception 00132 { 00133 public: 00138 AppLogException(const char *what_arg) : ost::Exception(what_arg) {} 00139 00140 }; 00141 #endif 00142 00143 class __LOCAL AppLogPrivate; 00144 00173 class __EXPORT AppLog : protected streambuf, public ostream 00174 { 00175 protected: 00176 // d pointer 00177 AppLogPrivate *d; 00178 void writeLog(bool endOfLine = true); 00179 static std::map<string, Slog::Level> *assoc; 00180 00181 public: 00185 class __EXPORT Ident 00186 { 00187 private: 00188 std::string _ident; 00189 public: 00190 00194 Ident() {} 00195 00199 ~Ident() {} 00200 00204 Ident(Ident& id) {_ident = id._ident;} 00205 00209 Ident(const char *str) : _ident(str) {} 00210 00214 std::string& str() {return _ident;} 00215 00219 Ident& operator= (std::string &st) {_ident = st; return *this;} 00220 00224 Ident& operator= (const char str[]) {_ident = str; return *this;} 00225 00229 const char* c_str() const {return _ident.c_str();} 00230 }; 00231 00232 #ifndef _MSWINDOWS_ 00233 00240 AppLog(const char* logFileName = NULL, bool logDirectly = false , bool usePipe = false); 00241 #else 00242 00248 AppLog(const char* logFileName = NULL, bool logDirectly = false); 00249 #endif 00250 00253 virtual ~AppLog(); 00254 00259 void subscribe(); 00260 00264 void unsubscribe(); 00265 00266 #ifndef _MSWINDOWS_ 00267 00274 void logFileName(const char* FileName, bool logDirectly = false, bool usePipe = false); 00275 #else 00276 00282 void logFileName(const char* FileName, bool logDirectly = false); 00283 #endif 00284 00287 void close(void); 00288 00293 void level(Slog::Level enable); 00294 00299 void clogEnable(bool en = true); 00300 00305 void slogEnable(bool en = true); 00306 00312 void identLevel(const char *ident, Slog::Level level); 00313 00318 void open(const char *ident); 00319 00325 virtual int overflow(int c); 00326 00330 virtual int sync(); 00331 00336 void emerg(const char *format, ...); 00337 00342 void alert(const char *format, ...); 00343 00348 void critical(const char *format, ...); 00349 00354 void error(const char *format, ...); 00355 00360 void warn(const char *format, ...); 00361 00366 void notice(const char *format, ...); 00367 00372 void info(const char *format, ...); 00373 00378 void debug(const char *format, ...); 00379 00386 AppLog &operator()(const char *ident, Slog::Level level = Slog::levelError); 00387 00393 inline AppLog& operator()(const Ident &ident) { 00394 open(ident.c_str()); 00395 return *this; 00396 } 00397 00403 AppLog &operator()(Slog::Level level); 00404 00410 AppLog& operator<< (AppLog& (*pfManipulator)(AppLog&)); 00411 00417 AppLog& operator<< (ostream& (*pfManipulator)(ostream&)); 00418 00419 friend ostream& operator << (ostream &os, AppLog & al) 00420 { 00421 return al; 00422 } 00423 00429 inline AppLog& operator<< (Ident &ident) 00430 { 00431 open(ident.c_str()); 00432 return *this; 00433 } 00434 00435 00440 inline AppLog &warn(void) 00441 {return operator()(Slog::levelWarning);} 00442 00447 AppLog &error(void) 00448 { return operator()(Slog::levelError);} 00449 00454 inline AppLog &debug(void) 00455 {return operator()(Slog::levelDebug);} 00456 00461 inline AppLog &emerg(void) 00462 {return operator()(Slog::levelEmergency);} 00463 00468 inline AppLog &alert(void) 00469 {return operator()(Slog::levelAlert);} 00470 00475 inline AppLog &critical(void) 00476 {return operator()(Slog::levelCritical);} 00477 00482 inline AppLog ¬ice(void) 00483 {return operator()(Slog::levelNotice);} 00484 00489 inline AppLog &info(void) 00490 {return operator()(Slog::levelInfo);} 00491 00507 static Slog::Level levelTranslate(string name) 00508 { 00509 std::map<string, Slog::Level>::iterator it = assoc->find(name); 00510 return (it != assoc->end()) ? it->second : Slog::levelEmergency; 00511 } 00512 00513 }; 00514 00520 __EXPORT inline AppLog &debug(AppLog& sl) 00521 {return sl.operator()(Slog::levelDebug);} 00522 00528 __EXPORT inline AppLog &warn(AppLog& sl) 00529 {return sl.operator()(Slog::levelWarning);} 00530 00536 __EXPORT inline AppLog &error(AppLog& sl) 00537 { return sl.operator()(Slog::levelError);} 00538 00544 __EXPORT inline AppLog &emerg(AppLog& sl) 00545 {return sl.operator()(Slog::levelEmergency);} 00546 00552 __EXPORT inline AppLog &alert(AppLog& sl) 00553 {return sl.operator()(Slog::levelAlert);} 00554 00560 __EXPORT inline AppLog &critical(AppLog& sl) 00561 {return sl.operator()(Slog::levelCritical);} 00562 00568 __EXPORT inline AppLog ¬ice(AppLog& sl) 00569 {return sl.operator()(Slog::levelNotice);} 00570 00576 __EXPORT inline AppLog &info(AppLog& sl) 00577 {return sl.operator()(Slog::levelInfo);} 00578 00582 __EXPORT extern AppLog alog; 00583 00584 } // namespace ost 00585 00586 #endif //___APPLOG_H___