Logging.hh

Go to the documentation of this file.

#ifndef AGILE_LOGGING_HH
#define AGILE_LOGGING_HH

#include "AGILe/AGILe.hh"

namespace AGILe {


  class Log {
  public:

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

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

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

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

  private:
    static LogMap existingLogs;

    static LevelMap defaultLevels;

    static ColorCodes colorCodes;

    static std::string endColorCode;

    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(LevelMap& logLevels);

    static void setShowTimestamp(const bool showTime=true) {
      showTimestamp = showTime;
    }

    static void setShowLevel(const bool showLevel=true) {
      showLogLevel = showLevel;
    }

    static void setShowLoggerName(const bool showName=true) {
      showLoggerName = showName;
    }

    static void setUseColors(const bool useColors=true) {
      useShellColors = useColors;
    }

  protected:


    Log(const std::string& name);

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

    //Log(const Log&);

    //Log& operator=(const Log&);

    static std::string getColorCode(int level);

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

  public:
    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 always(const std::string& message) { log(ALWAYS, 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:

    std::ostream* const _nostream;

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

  };

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

}


#endif