logging.h

Go to the documentation of this file.

 
#ifndef CPPXDIC_LOGGING_H
#define CPPXDIC_LOGGING_H
 
#include <fstream>
#include <mutex>
#include <ostream>
#include <sstream>
#include <string>
 
namespace cppxdic {
namespace log {
 
enum class Level { Trace = 0, Debug = 1, Info = 2, Warn = 3, Error = 4, Off = 5 };
 
Level levelFromString(const std::string& s, Level fallback = Level::Info);
 
const char* levelName(Level l);
 
class Logger {
public:
    static Logger& instance();
 
    void setConsoleLevel(Level l);
    void setFileLevel(Level l);
    Level consoleLevel() const;
    Level fileLevel() const;
 
    bool setFile(const std::string& path);
 
    void setConsoleEnabled(bool on);
 
    void setVerboseFormat(bool on);
 
    void configureFromEnv();
 
    bool enabled(Level l);
 
    void write(Level l, const char* file, int line, const std::string& msg);
 
private:
    Logger();
    void ensureEnv();
 
    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_;
};
 
struct Options {
    Level console_level = Level::Info;
    bool console_level_set = false; 
    std::string log_file;           
    bool debug = false;             
    bool quiet = false;             
    int verbose = 0;                
};
 
void configureFromOptions(const Options& opts);
 
void setLevel(Level l);
bool setFile(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 cppxdic
 
// Stream-style logging macros. When the level is disabled, the right-hand side
// (message construction) is never evaluated.
#define LOG_AT(lvl)               \
    !::cppxdic::log::enabled(lvl) \
        ? (void)0                 \
        : ::cppxdic::log::Voidify() & ::cppxdic::log::Stream((lvl), __FILE__, __LINE__)
 
#define LOG_TRACE LOG_AT(::cppxdic::log::Level::Trace)
#define LOG_DEBUG LOG_AT(::cppxdic::log::Level::Debug)
#define LOG_INFO LOG_AT(::cppxdic::log::Level::Info)
#define LOG_WARN LOG_AT(::cppxdic::log::Level::Warn)
#define LOG_ERROR LOG_AT(::cppxdic::log::Level::Error)
 
#endif // CPPXDIC_LOGGING_H