Logger.h

#ifndef _RDA_LOGGER_H_
#define _RDA_LOGGER_H_

#include <iostream>
//
// 12 Sep 2002, N.Trofimov
// 29 Nov 2002 NNT
//    - added logger destroy()
//    - doc comments
//    - added undocumented vararg calls
//  1 Apr 2004 NNT
//    - added factory destroy()
//  3 Apr 2007 WPG
//    - added << operator
class rdaLogger;

class LoggerBuffer;

class rdaLoggerFactory
{
   public:

      virtual rdaLogger* createLogger(const char* name) = 0;

      virtual rdaLogger* createAuditLogger( const char* name )
      {
         return createLogger( name );
      }

      virtual const char* getType() = 0;

      virtual void destroy() {}

      virtual ~rdaLoggerFactory() {}

   protected:

      rdaLoggerFactory() {}

   private:

      // hide
      rdaLoggerFactory(const rdaLoggerFactory&);
      void operator=(const rdaLoggerFactory&);
};

class rdaSet;
class rdaLogger
{
   //
   // Remote control of the logger
   //
   friend class rdaLoggerControl;
   
   public:

   enum LogLevel
   {
      LOG_OFF     = 0,
      LOG_ERROR   = 10,
         LOG_WARNING = 20,
         LOG_INFO    = 30,
         LOG_TRACE   = 40,
         LOG_DEBUG   = 90,
         LOG_ALL     = 100
   };

      static bool stringToLevel(LogLevel& level, const char* levelString);
      static const char* levelToString(LogLevel level);

      static void printInfo();

      static void init(rdaLoggerFactory& factory);
      static void init();
      static bool initialized();

      static void destroy();

      static rdaLogger* getLogger(const char* name);

      static rdaLogger* getAuditLogger( const char* name );
      const char* getName()
      {
         return name_;
      }

      void error(const char* message)
      {
         log(LOG_ERROR, message);
      }
      void verror(const char* fmt, ...);
      void warning(const char* message)
      {
         log(LOG_WARNING, message);
      }
      void vwarning(const char* fmt, ...);
      void info(const char* message)
      {
         log(LOG_INFO, message);
      }
      void vinfo(const char* fmt, ...);
      void trace(const char* message)
      {
         log(LOG_TRACE, message);
      }
      void vtrace(const char* fmt, ...);
      void debug(const char* message)
      {
         log(LOG_DEBUG, message);
      }
      void vdebug(const char* fmt, ...);
      LogLevel getLevel()
      {
         return level_;
      }
      void setLevel(LogLevel level)
      {
         level_ = level;
      }
      bool isLoggable(LogLevel level)
      {
         return level_ >= level;
      }
      static LogLevel getDefaultLevel()
      {
         return defaultLevel_;
      }
      std::ostream& getErrorStream()
      {
         return *errorStream;
      }
      std::ostream& getWarningStream()
      {
         return *warningStream;
      }
      std::ostream& getInfoStream()
      {
         return *infoStream;
      }
      std::ostream& getTraceStream()
      {
         return *traceStream;
      }
      std::ostream& getDebugStream()
      {
         return *debugStream;
      }


      static void setDefaultLevel(LogLevel level)
      {
         defaultLevel_ = level;
      }
      static void setLevels(LogLevel level);

      virtual ~rdaLogger();

   protected:

      virtual void log(LogLevel level, const char* message) = 0;

      rdaLogger(const char* name);

   private:

      char* name_;
      LogLevel level_;
      static LogLevel defaultLevel_;
      static rdaLoggerFactory* factory_;
      static rdaSet loggers_;
      // hide
      rdaLogger(const rdaLogger&);
      void operator=(const rdaLogger&);
      LoggerBuffer* errorBuffer, *warningBuffer, *infoBuffer, *traceBuffer, *debugBuffer;
      std::ostream* errorStream, *warningStream, *infoStream, *traceStream, *debugStream;

      static rdaLogger* find(const char* name);
};

#endif

---