util/Log.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------
Name:      Log.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
Comment:   Handling the Client data
-----------------------------------------------------------------------------*/

#ifndef _UTIL_LOG_H
#define _UTIL_LOG_H

#include <util/xmlBlasterDef.h>
#include <util/PropertyDef.h>
#include <util/Property.h>
#include <util/I_Log.h>

namespace org { namespace xmlBlaster { namespace util {
   
   class Dll_Export Log : public I_Log {
      
   private:

      Log(const Log& entry);

      Log& operator =(const Log& entry);

      bool withXtermColor_;
      
      enum {L_NOLOG= 0x0,   // No logs at all
            L_PANIC= 0x1,   // Do exit on error
            L_ERROR= 0x2,   // Internal error occured
            L_WARN = 0x4,   // Warning about user actions
            L_INFO = 0x8,   // Important informational logs only
            L_CALL = 0x10,    // Trace entry of methods
            L_TIME = 0x20,    // Show elapsed milliseconds
            L_TRACE= 0x40,   // Trace application flow
            L_DUMP = 0x80,    // Dump internal state
            L_EXIT = 0x100,    // Do a normal exit
            L_PLAIN= 0x200  // Marker for plain output
            };
//      static int lookAndFeelTime = LC_TIME;
      static const char* const ESC          ;
      static const char* const BOLD         ;
      static const char* const RED_BLACK    ;
      static const char* const GREEN_BLACK  ;
      static const char* const YELLOW_BLACK ;
      static const char* const BLUE_BLACK   ;
      static const char* const PINK_BLACK   ;
      static const char* const LTGREEN_BLACK;
      static const char* const WHITE_BLACK  ;
      static const char* const WHITE_RED    ;
      static const char* const BLACK_RED    ;
      static const char* const BLACK_GREEN  ;
      static const char* const BLACK_PINK   ;
      static const char* const BLACK_LTGREEN;

      Property&     properties_;
      int           logLevel_;

      int    numWarnInvocations;
      int    numErrorInvocations;
      std::string currentLogFormat;
      bool   logFormatPropertyRead;

      std::string   ME;
      std::string   name_;

      std::string timeE, callE, traceE, plainE, infoE;
      std::string warnE, errorE, panicE, exitE;

      std::string timeX, callX, traceX, plainX, infoX;
      std::string warnX, errorX, panicX, exitX;

   private:
      int logLevelToBit(const std::string &logLevel) {
         if (logLevel == "PANIC")      return L_PANIC;
         else if (logLevel == "ERROR") return L_ERROR;
         else if (logLevel == "WARN" ) return L_WARN;
         else if (logLevel == "INFO" ) return L_INFO;
         else if (logLevel == "CALL") return L_CALL;
         else if (logLevel == "TIME" ) return L_TIME;
         else if (logLevel == "TRACE") return L_TRACE;
         else if (logLevel == "DUMP" ) return L_DUMP;
         return L_NOLOG;
      }

      void initSpecificTrace(const std::string& trace, const std::string& traceId);
      
      
      void exitLow(int val);
      
     public:
      inline std::string getName() { return name_; }
      
      Log(Property& properties, int args=0, const char * const argc[]=0, const std::string& name="default");


      ~Log();

      void setWithXtermColor(bool val=true);

      void setDefaultLogLevel();


      void setLogLevel(int level);

      
      void setLogLevel(int argc, const char * const args[]);


      void removeLogLevel(std::string logLevel);


      void addLogLevel(std::string logLevel);
            

      void setPreLogLevelCheck();

      
      std::string bitToLogLevel(int level) const;      

      std::string getLogLevelStr() const { return bitToLogLevel(logLevel_); }

      int getLogLevel() const {
         return logLevel_;
      }
      

      void setLogFormat(const std::string &format) {
         currentLogFormat = format;
      }


      void panic(const std::string &instance, const std::string &text);


      void exit(const std::string &instance, const std::string &text);


      void info(const std::string &instance, const std::string &text);
      

      void warn(const std::string &instance, const std::string &text);
      
      
      void error(const std::string &instance, const std::string &text);


      /*
       * Log without time/date/instance
       * @param instance (not currently used)
       * @param text the std::string to log
       */
      void plain(const std::string &instance, const std::string &text);


      /*
       * Log without time/date
       */
      void dump(const std::string &instance, const std::string &text);


      void trace(const std::string &instance, const std::string &text);


      void call(const std::string &instance, const std::string &text);

      
      void time(const std::string &instance, const std::string &text);


      virtual std::string usage() const;

      void displayStatistics();


      void printStack();
  

      void initialize();       


      std::string getTime();

 
      void log(const std::string &levelStr, int level, const std::string &instance, 
               const std::string &text);


      Property& getProperties() {
         return properties_;
      }

   }; // end of class Log



}}} // end of namespace util

#endif // _UTIL_LOG_H