Logger.h

#pragma once
 
// workaround https://github.com/fmtlib/fmt/issues/4133
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshift-overflow"
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-overflow"
#endif
#include <fmt/color.h>
#include <fmt/format.h>
#include <fmt/ranges.h>
#ifdef __clang__
#pragma clang diagnostic pop
#else
#pragma GCC diagnostic pop
#endif
 
#include <functional>
#include <unordered_map>
 
namespace iguana {
 
  class Logger
  {
 
      friend class Object;
 
    public:
 
      enum Level {
        trace,
        debug,
        info,
        quiet,
        warn,
        error,
        silent
      };
 
      static Level const DEFAULT_LEVEL = info;
 
      Logger(std::string_view name = "log", Level const lev = DEFAULT_LEVEL, bool const enable_style = true);
      ~Logger() {}
 
      void SetLevel(std::string_view lev);
 
      void SetLevel(Level const lev);
 
      Level GetLevel();
 
      void EnableStyle();
 
      void DisableStyle();
 
      static std::string Header(std::string_view message, int const width = 50);
 
      template <typename... VALUES>
      void Trace(std::string_view message, const VALUES... vals) const { Print(trace, message, vals...); }
      template <typename... VALUES>
      void Debug(std::string_view message, const VALUES... vals) const { Print(debug, message, vals...); }
      template <typename... VALUES>
      void Info(std::string_view message, const VALUES... vals) const { Print(info, message, vals...); }
      template <typename... VALUES>
      void Warn(std::string_view message, const VALUES... vals) const { Print(warn, message, vals...); }
      template <typename... VALUES>
      void Error(std::string_view message, const VALUES... vals) const { Print(error, message, vals...); }
 
      template <typename... VALUES>
      void Print(Level const lev, std::string_view message, const VALUES... vals) const
      {
        if(lev >= m_level) {
          if(auto it{m_level_names.find(lev)}; it != m_level_names.end()) {
            std::function<std::string(std::string)> style = [](std::string s)
            { return fmt::format("[{}]", s); };
            if(m_enable_style) {
              switch(lev) {
              case warn:
                style = [](std::string s)
                { return fmt::format("[{}]", fmt::styled(s, fmt::emphasis::bold | fmt::fg(fmt::terminal_color::magenta))); };
                break;
              case error:
                style = [](std::string s)
                { return fmt::format("[{}]", fmt::styled(s, fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red))); };
                break;
              default:
                style = [](std::string s)
                { return fmt::format("[{}]", fmt::styled(s, fmt::emphasis::bold)); };
              }
            }
            fmt::print(
                lev >= warn ? stderr : stdout,
                fmt::runtime(fmt::format("{} {} {}\n", style(it->second), style(m_name), message)),
                vals...);
          }
          else {
            Warn("Logger::Print called with unknown log level '{}'; printing as error instead", static_cast<int>(lev)); // FIXME: static_cast -> fmt::underlying, but needs new version of fmt
            Error(message, vals...);
          }
        }
      }
 
    private:
 
      std::string m_name;
 
      Level m_level;
 
      std::unordered_map<Level, std::string> m_level_names;
 
      bool m_enable_style;
  };
}