herrlog.hh

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <fstream>
#include <mutex>
#include <ostream>
#include <sstream>
#include <string_view>
 
static_assert(__cplusplus >= 202002L,
              "This library requires at least C++20 to compile");
 
namespace ascii_colors {
inline constexpr std::string_view reset_color{"\033[0m"};
inline constexpr std::string_view bold_red_color{"\033[1;31m"};
inline constexpr std::string_view bold_green_color{"\033[1;32m"};
inline constexpr std::string_view bold_yellow_color{"\033[1;33m"};
inline constexpr std::string_view bold_blue_color{"\033[1;34m"};
inline constexpr std::string_view background_red_color{"\033[41m"};
inline constexpr std::string_view bold_white_color{"\033[1;37m"};
}  // namespace ascii_colors
 
class LogType {
   private:
    std::uint8_t bitflag;
 
   public:
    enum : std::uint8_t {
        Trace = 0b000001,  // For specific details
        Debug = 0b000010,  // Temporary debug printing
        Info = 0b000100,  // General purpose details, e.g. "Program has started"
        Error = 0b001000,  // For errors, exits the program
        Warn = 0b010000,   // For reporting warning, the program keeps working
        Fatal = 0b100000,  // Program exits and produces core dump
 
        All = 0b111111,
        None = 0b000000,
    };
 
    LogType(std::uint8_t initial_flag) : bitflag(initial_flag) {}
 
    LogType operator|(const LogType other) const {
        return LogType((static_cast<std::uint8_t>(bitflag) |
                        static_cast<std::uint8_t>(other.bitflag)));
    }
 
    bool operator&(const LogType other) const {
        return static_cast<bool>(static_cast<std::uint8_t>(bitflag) &
                                 static_cast<std::uint8_t>(other.bitflag));
    }
};
 
class Logger {
   private:
    static LogType log_type;
    static std::string output_file_name;
    static std::ostream* output_buffer;
    static bool is_color_output;
    static const char* datetime_format;
    static std::mutex log_mutex;
    static std::ofstream output_file;
 
    template <typename T, typename... Rest>
    static void print_to_stream(std::ostream& stream, const char* format, T arg,
                                Rest... rest) {
        for (size_t index = 0; format[index] != '\0'; index++) {
            if (format[index] == '{' && format[index + 1] == '}') {
                stream << arg;
                return print_to_stream(stream, format + index + 2, rest...);
            }
            stream << format[index];
        }
    }
 
    static void print_to_stream(std::ostream& stream, const char* format) {
        for (size_t index = 0; format[index] != '\0'; index++) {
            stream << format[index];
        }
    }
 
    template <typename... Args>
    static void log(const char* name, const std::string_view& color,
                    const char* format, Args... args) {
        std::time_t current_time = std::chrono::system_clock::to_time_t(
            std::chrono::system_clock::now());
        char time_string[100];
        std::strftime(time_string, sizeof(time_string), datetime_format,
                      std::localtime(&current_time));
 
        std::stringstream ss;
        ss << (is_color_output ? color : std::string_view()) << "[" << name
           << " " << time_string << "]"
           << (is_color_output ? ascii_colors::reset_color : std::string_view())
           << " ";
 
        print_to_stream(ss, format, args...);
 
        std::lock_guard<std::mutex> lock(Logger::log_mutex);
        *output_buffer << ss.str() << '\n';
        output_buffer->flush();
    }
 
    Logger() = delete;
 
   public:
    static void set_type(LogType log_type) { Logger::log_type = log_type; }
 
    static void set_output_file_name(std::string output_file_name) {
        Logger::output_file_name = output_file_name;
        Logger::output_file = std::ofstream(Logger::output_file_name);
        if (Logger::output_file.is_open()) {
            Logger::output_file.close();
        }
        Logger::output_file.open(Logger::output_file_name);
        if (!Logger::output_file.is_open()) {
            Logger::error(
                "Failed to open {}",
                Logger::output_file_name);  // Peak efficiency ᕦ(ò_óˇ)ᕤ
            return;
        }
 
        output_buffer = &Logger::output_file;
        is_color_output = false;
    }
 
    static void set_datetime_format(const char* datetime_format) {
        Logger::datetime_format = datetime_format;
    }
 
    static void set_output_buffer(std::ostream& output_buffer) {
        Logger::output_buffer = &output_buffer;
    }
 
    static void set_is_color_output(bool is_color_output) {
        Logger::is_color_output = is_color_output;
    }
 
    template <typename... Args>
    static void trace(const char* format, Args... args) {
        if (log_type & LogType::Trace) {
            log("TRACE", ascii_colors::bold_white_color, format, args...);
        }
    }
 
    template <typename... Args>
    static void debug(const char* format, Args... args) {
        if (log_type & LogType::Debug) {
            log("DEBUG", ascii_colors::bold_blue_color, format, args...);
        }
    }
 
    template <typename... Args>
    static void info(const char* format, Args... args) {
        if (log_type & LogType::Info) {
            log(" INFO", ascii_colors::bold_green_color, format, args...);
        }
    }
 
    template <typename... Args>
    static void error(const char* format, Args... args) {
        if (log_type & LogType::Error) {
            log("ERROR", ascii_colors::bold_red_color, format, args...);
            exit(EXIT_FAILURE);
        }
    }
 
    template <typename... Args>
    static void warn(const char* format, Args... args) {
        if (log_type & LogType::Warn) {
            log(" WARN", ascii_colors::bold_yellow_color, format, args...);
        }
    }
 
    template <typename... Args>
    static void fatal(const char* format, Args... args) {
        if (log_type & LogType::Fatal) {
            log("FATAL", ascii_colors::background_red_color, format, args...);
            abort();
        }
    }
};
 
LogType Logger::log_type = LogType::All;
std::string Logger::output_file_name = std::string();
std::ostream* Logger::output_buffer = &std::cout;
bool Logger::is_color_output = true;
const char* Logger::datetime_format = "%Y-%m-%d %H:%M:%S";
std::mutex Logger::log_mutex;
std::ofstream Logger::output_file = std::ofstream();