log.h

Go to the documentation of this file.

#pragma once
#include <fstream>
#include <mutex>
#include <ostream>
#include <sstream>
#include <string>
 
namespace ncorr {
namespace log {
 
enum class Level { Trace = 0, Debug = 1, Info = 2, Warn = 3, Error = 4, Off = 5 };
 
Level level_from_string(const std::string& s, Level fallback = Level::Info);
 
const char* level_name(Level l);
 
class Logger {
  public:
    static Logger& instance();
 
    void set_console_level(Level l);
    void set_file_level(Level l);
    Level console_level() const;
    Level file_level() const;
 
    bool set_file(const std::string& path);
 
    void set_console_enabled(bool on);
 
    void set_verbose_format(bool on);
 
    void configure_from_env();
 
    bool enabled(Level l);
 
    void write(Level l, const char* file, int line, const std::string& msg);
 
  private:
    Logger();
    void ensure_env();
 
    mutable std::mutex mtx_;
    Level console_level_ = Level::Info;
    Level file_level_ = Level::Debug;
    bool console_enabled_ = true;
    bool verbose_format_ = false;
    bool color_ = false;
    bool env_done_ = false;
    std::ofstream file_;
};
 
void set_level(Level l);
 
void set_debug(bool on);
 
bool set_file(const std::string& path);
 
inline bool enabled(Level l) {
    return Logger::instance().enabled(l);
}
 
class Stream {
  public:
    Stream(Level level, const char* file, int line) : level_(level), file_(file), line_(line) {}
    ~Stream() { Logger::instance().write(level_, file_, line_, oss_.str()); }
 
    Stream(const Stream&) = delete;
    Stream& operator=(const Stream&) = delete;
 
    template <typename T>
    Stream& operator<<(const T& v) {
        oss_ << v;
        return *this;
    }
    Stream& operator<<(std::ostream& (*manip)(std::ostream&)) {
        oss_ << manip;
        return *this;
    }
 
  private:
    Level level_;
    const char* file_;
    int line_;
    std::ostringstream oss_;
};
 
class Voidify {
  public:
    Voidify() = default;
    void operator&(Stream&) {}
};
 
}  // namespace log
}  // namespace ncorr
 
// Stream-style logging macros. When the level is disabled, the right-hand side
// (message construction) is never evaluated.
#define NLOG_AT(lvl)            \
    !::ncorr::log::enabled(lvl) \
        ? (void)0               \
        : ::ncorr::log::Voidify() & ::ncorr::log::Stream((lvl), __FILE__, __LINE__)
 
#define NLOG_TRACE NLOG_AT(::ncorr::log::Level::Trace)
#define NLOG_DEBUG NLOG_AT(::ncorr::log::Level::Debug)
#define NLOG_INFO NLOG_AT(::ncorr::log::Level::Info)
#define NLOG_WARN NLOG_AT(::ncorr::log::Level::Warn)
#define NLOG_ERROR NLOG_AT(::ncorr::log::Level::Error)