Logger.h

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_LOGGER__
#define __ARC_LOGGER__

#include <string>
#include <list>
#include <map>
#include <iostream>
#include <fstream>

#include <arc/Thread.h>
#include <arc/IString.h>

namespace Arc {


  enum LogLevel {
    DEBUG = 1,   

    VERBOSE = 2, 

    INFO = 4,    

    WARNING = 8, 
    ERROR = 16,  

    FATAL = 32   

  };

  enum LogFormat {
    LongFormat,  
    ShortFormat, 
    DebugFormat, 


    EmptyFormat  
  };

  struct LoggerFormat {
    LoggerFormat(LogFormat format)
      : format(format) {};
    LogFormat format;
  };

  std::ostream& operator<<(std::ostream& os, const LoggerFormat& format);


  std::ostream& operator<<(std::ostream& os, LogLevel level);
  LogLevel string_to_level(const std::string& str);

  bool istring_to_level(const std::string& llStr, LogLevel& ll);
  bool string_to_level(const std::string& str, LogLevel& ll);
  std::string level_to_string(const LogLevel& level);
  LogLevel old_level_to_level(unsigned int old_level);




  class LogMessage {
  public:


    LogMessage(LogLevel level,
               const IString& message);


    LogMessage(LogLevel level,
               const IString& message,
               const std::string& identifier);


    LogLevel getLevel() const;

  protected:


    void setIdentifier(std::string identifier);

  private:


    static std::string getDefaultIdentifier();


    void setDomain(std::string domain);

    std::string time;

    LogLevel level;

    std::string domain;

    std::string identifier;

    IString message;


    friend std::ostream& operator<<(std::ostream& os,
                                    const LogMessage& message);


    friend class Logger;

  };




  class LogDestination {
  public:

    virtual void log(const LogMessage& message) = 0;

    virtual ~LogDestination() {}

    void setFormat(const LogFormat& newformat);

  protected:

    LogDestination();

  private:


    LogDestination(const LogDestination& unique);


    void operator=(const LogDestination& unique);

  protected:
    LogFormat format;
  };




  class LogStream
    : public LogDestination {
  public:


    LogStream(std::ostream& destination);


    virtual void log(const LogMessage& message);

  private:


    LogStream(const LogStream& unique);


    void operator=(const LogStream& unique);


    std::ostream& destination;


    Glib::Mutex mutex;

  };


  class LogFile
    : public LogDestination {
  public:


    LogFile(const std::string& path);


    void setMaxSize(int newsize);


    void setBackups(int newbackup);


    void setReopen(bool newreopen);

    operator bool(void);

    bool operator!(void);


    virtual void log(const LogMessage& message);
  private:
    LogFile(void);
    LogFile(const LogFile& unique);
    void operator=(const LogFile& unique);
    void backup(void);
    std::string path;
    std::ofstream destination;
    int maxsize;
    int backups;
    bool reopen;
    Glib::Mutex mutex;
  };

  class LoggerContextRef;

  class LoggerContext {
    friend class Logger;
    friend class LoggerContextRef;
    private:
      int usage_count;

      Glib::Mutex mutex;

      std::list<LogDestination*> destinations;

      LogLevel threshold;

      LoggerContext(LogLevel thr):usage_count(0),threshold(thr) { };

      LoggerContext(const LoggerContext& ctx):
             usage_count(0),destinations(ctx.destinations),threshold(ctx.threshold) { };

      ~LoggerContext(void);

      void Acquire(void);

      void Release(void);
  };


  class Logger {
  public:


    //static Logger rootLogger;
    static Logger& getRootLogger();


    Logger(Logger& parent,
           const std::string& subdomain);


    Logger(Logger& parent,
           const std::string& subdomain,
           LogLevel threshold);

    ~Logger();


    void addDestination(LogDestination& destination);


    void addDestinations(const std::list<LogDestination*>& destinations);


    void setDestinations(const std::list<LogDestination*>& destinations);


    const std::list<LogDestination*>& getDestinations(void) const;

    void removeDestinations(void);

    void deleteDestinations(void);


    void setThreshold(LogLevel threshold);


    static void setThresholdForDomain(LogLevel threshold,
                                      const std::list<std::string>& subdomains);


    static void setThresholdForDomain(LogLevel threshold,
                                      const std::string& domain);

    LogLevel getThreshold() const;


    void setThreadContext(void);


    void msg(LogMessage message);


    void msg(LogLevel level, const std::string& str) {
      msg(LogMessage(level, IString(str)));
    }

    template<class T0>
    void msg(LogLevel level, const std::string& str,
             const T0& t0) {
      msg(LogMessage(level, IString(str, t0)));
    }

    template<class T0, class T1>
    void msg(LogLevel level, const std::string& str,
             const T0& t0, const T1& t1) {
      msg(LogMessage(level, IString(str, t0, t1)));
    }

    template<class T0, class T1, class T2>
    void msg(LogLevel level, const std::string& str,
             const T0& t0, const T1& t1, const T2& t2) {
      msg(LogMessage(level, IString(str, t0, t1, t2)));
    }

    template<class T0, class T1, class T2, class T3>
    void msg(LogLevel level, const std::string& str,
             const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
      msg(LogMessage(level, IString(str, t0, t1, t2, t3)));
    }

    template<class T0, class T1, class T2, class T3, class T4>
    void msg(LogLevel level, const std::string& str,
             const T0& t0, const T1& t1, const T2& t2, const T3& t3,
             const T4& t4) {
      msg(LogMessage(level, IString(str, t0, t1, t2, t3, t4)));
    }

    template<class T0, class T1, class T2, class T3, class T4,
             class T5>
    void msg(LogLevel level, const std::string& str,
             const T0& t0, const T1& t1, const T2& t2, const T3& t3,
             const T4& t4, const T5& t5) {
      msg(LogMessage(level, IString(str, t0, t1, t2, t3, t4, t5)));
    }

    template<class T0, class T1, class T2, class T3, class T4,
             class T5, class T6>
    void msg(LogLevel level, const std::string& str,
             const T0& t0, const T1& t1, const T2& t2, const T3& t3,
             const T4& t4, const T5& t5, const T6& t6) {
      msg(LogMessage(level, IString(str, t0, t1, t2, t3, t4, t5, t6)));
    }

    template<class T0, class T1, class T2, class T3, class T4,
             class T5, class T6, class T7>
    void msg(LogLevel level, const std::string& str,
             const T0& t0, const T1& t1, const T2& t2, const T3& t3,
             const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
      msg(LogMessage(level, IString(str, t0, t1, t2, t3, t4, t5, t6, t7)));
    }

  private:


    Logger();


    Logger(const Logger& unique);


    void operator=(const Logger& unique);


    std::string getDomain();


    void log(const LogMessage& message);

    Logger *parent;

    std::string domain;

    std::string context_id;

    LoggerContext context;

    LoggerContext& getContext(void);

    Glib::Mutex mutex;

#define rootLoggerMagic (0xF6569201)
    static Logger *rootLogger;
    static std::map<std::string,LogLevel>* defaultThresholds;
    static unsigned int rootLoggerMark;
  };

} // namespace Arc

#define rootLogger getRootLogger()

#define LOG(LGR, THR, FSTR, ...) { if ((LGR).getThreshold() >= (THR)(LGR).msg((THR), (FSTR), ...); }

#endif // __ARC_LOGGER__