logging.h

Go to the documentation of this file.

#ifndef SOPT_LOGGING_H
#define SOPT_LOGGING_H
 
#include "sopt/config.h"
#include "sopt/exception.h"
 
#include <map>
#include <memory>
#include <cstring>
 
namespace sopt::logging {
 
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}; 
 
 
  using LogMap = std::map<std::string, Log>;
 
  using LevelMap = std::map<std::string, int>;
 
  using ColorCodes = std::map<int, std::string>;
 
 
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);
  }
 
 
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);
 
inline Log& getLog() { return Log::getLog("sopt::"); }
 
inline void set_level(const std::string &level) {
  getLog().setLevel(Log::getLevelFromName(level));
}
 
 
template <typename Arg>
void applyFormat(std::stringstream& ss, char*& pos, Arg&& arg) {
  char* delim = strstr(pos, "{}");
  if (delim != NULL) {
    ss << std::string(pos, delim-pos) << std::forward<Arg>(arg);
    pos = delim + 2;
  }
  else {
    SOPT_THROW("Insufficient placeholders for number of arguments!");
  }
}
 
template <typename... Args>
inline std::string mkFormattedString(const char* txt, Args&& ... args) {
  std::string mys = txt;
  std::stringstream rtn;
  char* pos = (char*)txt;
  ((void)applyFormat(rtn, pos, std::forward<Args>(args)), ...);
  rtn << std::string(pos);
  return rtn.str();
}
 
inline const std::string& mkFormattedString(const std::string& txt) { return txt; }
 
 
#define SOPT_MSG_LVL(lvl, ...) \
  do { \
    if (sopt::logging::getLog().isActive(lvl)) { \
      sopt::logging::getLog() << lvl << sopt::logging::mkFormattedString(__VA_ARGS__) << '\n'; \
    } \
  } while (0)
 
#define SOPT_LOG_(TYPE, ...) \
  SOPT_MSG_LVL(sopt::logging::Log::TYPE, __VA_ARGS__)
 
 
 
}
 
#define SOPT_NOTICE(...) SOPT_LOG_(critical, __VA_ARGS__)
#define SOPT_ERROR(...) SOPT_LOG_(error, __VA_ARGS__)
#define SOPT_WARN(...) SOPT_LOG_(warn, __VA_ARGS__)
#define SOPT_INFO(...) SOPT_LOG_(info, __VA_ARGS__)
#define SOPT_DEBUG(...) SOPT_LOG_(debug, __VA_ARGS__)
#define SOPT_TRACE(...) SOPT_LOG_(trace, __VA_ARGS__)
 
#define SOPT_HIGH_LOG(...) SOPT_LOG_(critical, __VA_ARGS__)
#define SOPT_MEDIUM_LOG(...) SOPT_LOG_(info, __VA_ARGS__)
#define SOPT_LOW_LOG(...) SOPT_LOG_(debug, __VA_ARGS__)
 
#endif