Logging.hh

#ifndef RIVET_LOGGING_HH
#define RIVET_LOGGING_HH
 
#include "Rivet/Config/RivetCommon.hh"
 
namespace Rivet {
 

  class Log {
  public:

    enum Level {
      TRACE = 0,
      DEBUG = 10,
      INFO = 20,
      WARN = 30,
      WARNING = 30,
      ERROR = 40,
      CRITICAL = 50,
      ALWAYS = 50
    };
    static const int END_COLOR = -10; 
 

    typedef std::map<std::string, Log> LogMap;

    typedef std::map<std::string, int> LevelMap;

    typedef std::map<int, std::string> ColorCodes;
 
 
  private:

    thread_local static LogMap existingLogs;

    thread_local static LevelMap defaultLevels;

    static bool showTimestamp;

    static bool showLogLevel;

    static bool showLoggerName;

    static bool useShellColors;
 
 
  public:

    static void setLevel(const std::string& name, int level);
    static void setLevels(const LevelMap& logLevels);
 
  protected:


    Log(const std::string& name);

    Log(const std::string& name, int level);


    static std::string getColorCode(int level);
 
 
  public:

    static Log& getLog(const std::string& name);

    int getLevel() const {
      return _level;
    }

    Log& setLevel(int level) {
      _level = level;
      return *this;
    }

    static Level getLevelFromName(const std::string& level);

    static std::string getLevelName(int level);

    std::string getName() const {
      return _name;
    }

    Log& setName(const std::string& name) {
      _name = name;
      return *this;
    }

    bool isActive(int level) const {
      return (level >= _level);
    }

    void trace(const std::string& message) {
      log(TRACE, message);
    }
 
    void debug(const std::string& message) {
      log(DEBUG, message);
    }
 
    void info(const std::string& message) {
      log(INFO, message);
    }
 
    void warn(const std::string& message) {
      log(WARN, message);
    }
 
    void error(const std::string& message) {
      log(ERROR, message);
    }
 
    void critical(const std::string& message) {
      log(CRITICAL, message);
    }
 
 
  private:

    std::string _name;

    int _level;
 
  protected:

    void log(int level, const std::string& message);

    std::string formatMessage(int level, const std::string& message);
 
  public:

    friend std::ostream& operator<<(Log& log, int level);
  };
 

  std::ostream& operator<<(Log& log, int level);
 
 
}
 


#define MSG_LVL(lvl, x) \
  do { \
    if (getLog().isActive(lvl)) { \
      getLog() << lvl << x << '\n';   \
    } \
  } while (0)

#define MSG_TRACE(x)   MSG_LVL(Log::TRACE, x)
#define MSG_DEBUG(x)   MSG_LVL(Log::DEBUG, x)
#define MSG_INFO(x)    MSG_LVL(Log::INFO, x)
#define MSG_WARNING(x) MSG_LVL(Log::WARNING, x)
#define MSG_ERROR(x)   MSG_LVL(Log::ERROR, x)

 
 
#endif