UCommon
/usr/src/RPM/BUILD/ucommon-6.3.3/inc/commoncpp/applog.h
Go to the documentation of this file.
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 &notice(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 &notice(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___