logging.h

Go to the documentation of this file.

#ifndef PURIFY_LOGGING_H
#define PURIFY_LOGGING_H
 
#include "purify/config.h"
#include <cstring>
#include <exception>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <tuple>
 
namespace purify::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("purify::"); }
 
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 {
    throw std::runtime_error("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 std::string mkFormattedString(const std::string& txt) {
  return mkFormattedString(txt.data());
}
 
 
#define PURIFY_MSG_LVL(lvl, ...)                                                                   \
  do {                                                                                             \
    if (purify::logging::getLog().isActive(lvl)) {                                                 \
      purify::logging::getLog() << lvl << purify::logging::mkFormattedString(__VA_ARGS__) << '\n'; \
    }                                                                                              \
  } while (0)
 
#define PURIFY_LOG_(TYPE, ...) PURIFY_MSG_LVL(purify::logging::Log::TYPE, __VA_ARGS__)
 
 
}  // namespace purify::logging
 
#define PURIFY_CRITICAL(...) PURIFY_LOG_(critical, __VA_ARGS__)
#define PURIFY_ERROR(...) PURIFY_LOG_(error, __VA_ARGS__)
#define PURIFY_WARN(...) PURIFY_LOG_(warn, __VA_ARGS__)
#define PURIFY_INFO(...) PURIFY_LOG_(info, __VA_ARGS__)
#define PURIFY_DEBUG(...) PURIFY_LOG_(debug, __VA_ARGS__)
#define PURIFY_TRACE(...) PURIFY_LOG_(trace, __VA_ARGS__)
 
#define PURIFY_HIGH_LOG(...) PURIFY_LOG_(critical, __VA_ARGS__)
#define PURIFY_MEDIUM_LOG(...) PURIFY_LOG_(info, __VA_ARGS__)
#define PURIFY_LOW_LOG(...) PURIFY_LOG_(debug, __VA_ARGS__)
 
#endif