GNU CommonC++
|
00001 // Copyright (C) 2005-2010 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 General Public License 00013 // along with this program; if not, write to the Free Software 00014 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 00015 // 00016 // As a special exception, you may use this file as part of a free software 00017 // library without restriction. Specifically, if other files instantiate 00018 // templates or use macros or inline functions from this file, or you compile 00019 // this file and link it with other files to produce an executable, this 00020 // file does not by itself cause the resulting executable to be covered by 00021 // the GNU General Public License. This exception does not however 00022 // invalidate any other reasons why the executable file might be covered by 00023 // the GNU General Public License. 00024 // 00025 // This exception applies only to the code released under the name GNU 00026 // Common C++. If you copy code from other releases into a copy of GNU 00027 // Common C++, as the General Public License permits, the exception does 00028 // not apply to the code that you add in this way. To avoid misleading 00029 // anyone as to the status of such modified files, you must delete 00030 // this exception notice from them. 00031 // 00032 // If you write modifications of your own for GNU Common C++, it is your choice 00033 // whether to permit this exception to apply to your modifications. 00034 // If you do not wish that, delete this exception notice. 00035 // 00036 00043 #ifndef ___APPLOG_H___ 00044 #define ___APPLOG_H___ 00045 00046 #ifndef CCXX_SLOG_H_ 00047 #include <cc++/slog.h> 00048 #endif 00049 00050 #include <cc++/exception.h> 00051 00052 #include <string> 00053 #include <sstream> 00054 #include <iostream> 00055 #include <map> 00056 00057 #ifdef CCXX_NAMESPACES 00058 using namespace std; 00059 00060 namespace ost 00061 { 00062 #endif 00063 00071 class __EXPORT HEXdump 00072 { 00073 protected: 00077 std::string _str; 00078 00079 public: 00080 // max_len: max number of bytes to be printed. 0 prints all. 00089 HEXdump(const unsigned char *buffer, int buff_len, int max_len = 200); 00090 00094 virtual ~HEXdump() { _str = string();} 00095 00100 const char * c_str() const 00101 { 00102 return _str.c_str(); 00103 } 00104 00108 std::string str() 00109 { 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 std::string &what_arg) : ost::Exception(what_arg) {}; 00139 00140 }; 00141 #endif 00142 00143 class 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 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() {return _ident.c_str();} 00230 }; 00231 00232 #ifndef WIN32 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 WIN32 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 00332 #ifdef HAVE_SNPRINTF 00333 00338 void emerg(const char *format, ...); 00339 00344 void alert(const char *format, ...); 00345 00350 void critical(const char *format, ...); 00351 00356 void error(const char *format, ...); 00357 00362 void warn(const char *format, ...); 00363 00368 void notice(const char *format, ...); 00369 00374 void info(const char *format, ...); 00375 00380 void debug(const char *format, ...); 00381 #endif 00382 00389 AppLog &operator()(const char *ident, Slog::Level level = Slog::levelError); 00390 00396 inline AppLog& operator()(Ident &ident) 00397 { 00398 open(ident.c_str()); 00399 return *this; 00400 } 00401 00407 AppLog &operator()(Slog::Level level); 00408 00414 AppLog& operator<< (AppLog& (*pfManipulator)(AppLog&)); 00415 00421 AppLog& operator<< (ostream& (*pfManipulator)(ostream&)); 00422 00423 friend ostream& operator << (ostream &out, AppLog & al) 00424 { 00425 return al; 00426 } 00427 00433 inline AppLog& operator<< (Ident &ident) 00434 { 00435 open(ident.c_str()); 00436 return *this; 00437 } 00438 00439 00444 inline AppLog &warn(void) 00445 {return operator()(Slog::levelWarning);} 00446 00451 AppLog &error(void) 00452 { return operator()(Slog::levelError);} 00453 00458 inline AppLog &debug(void) 00459 {return operator()(Slog::levelDebug);} 00460 00465 inline AppLog &emerg(void) 00466 {return operator()(Slog::levelEmergency);} 00467 00472 inline AppLog &alert(void) 00473 {return operator()(Slog::levelAlert);} 00474 00479 inline AppLog &critical(void) 00480 {return operator()(Slog::levelCritical);} 00481 00486 inline AppLog ¬ice(void) 00487 {return operator()(Slog::levelNotice);} 00488 00493 inline AppLog &info(void) 00494 {return operator()(Slog::levelInfo);} 00495 00511 static Slog::Level levelTranslate(string name) 00512 { 00513 map<string, Slog::Level>::iterator it = assoc->find(name); 00514 00515 return (it != assoc->end()) ? it->second : Slog::levelEmergency; 00516 } 00517 00518 }; 00519 00525 __EXPORT inline AppLog &debug(AppLog& sl) 00526 {return sl.operator()(Slog::levelDebug);} 00527 00533 __EXPORT inline AppLog &warn(AppLog& sl) 00534 {return sl.operator()(Slog::levelWarning);} 00535 00541 __EXPORT inline AppLog &error(AppLog& sl) 00542 { return sl.operator()(Slog::levelError);} 00543 00549 __EXPORT inline AppLog &emerg(AppLog& sl) 00550 {return sl.operator()(Slog::levelEmergency);} 00551 00557 __EXPORT inline AppLog &alert(AppLog& sl) 00558 {return sl.operator()(Slog::levelAlert);} 00559 00565 __EXPORT inline AppLog &critical(AppLog& sl) 00566 {return sl.operator()(Slog::levelCritical);} 00567 00573 __EXPORT inline AppLog ¬ice(AppLog& sl) 00574 {return sl.operator()(Slog::levelNotice);} 00575 00581 __EXPORT inline AppLog &info(AppLog& sl) 00582 {return sl.operator()(Slog::levelInfo);} 00583 00587 __EXPORT extern AppLog alog; 00588 00589 #ifdef CCXX_NAMESPACES 00590 } //namespace 00591 #endif 00592 00593 #endif //___APPLOG_H___