enums.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_ENUMS_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_ENUMS_HPP_INCLUDED
 
 
#include <array>
#include <string>
 
namespace logit {
 
    enum class LogLevel {
        LOG_LVL_TRACE,      
        LOG_LVL_DEBUG,      
        LOG_LVL_INFO,       
        LOG_LVL_WARN,       
        LOG_LVL_ERROR,      
        LOG_LVL_FATAL       
    };
 
    enum class TextColor {
        Black,
        DarkRed,
        DarkGreen,
        DarkYellow,
        DarkBlue,
        DarkMagenta,
        DarkCyan,
        LightGray,
        DarkGray,
        Red,
        Green,
        Yellow,
        Blue,
        Magenta,
        Cyan,
        White,
    };
 
    enum class LoggerParam {
        LastFileName,          
        LastFilePath,          
        LastLogTimestamp,      
        TimeSinceLastLog,      
        DroppedLogCount,       
        FailedExportCount      
    };
 
    enum class CompressType {
        NONE,        
        GZIP,        
        ZSTD,        
        EXTERNAL_CMD 
    };
 
    enum class RotationNaming {
        Sequence,    
        Timestamp,   
        TimestampMs  
    };
 
    inline const char* to_c_str(LogLevel level, int mode = 0) {
        static const std::array<const char*, 6> data_str_0 = {
            "TRACE",
            "DEBUG",
            "INFO",
            "WARN",
            "ERROR",
            "FATAL"
        };
        static const std::array<const char*, 6> data_str_1 = {
            "T",
            "D",
            "I",
            "W",
            "E",
            "F"
        };
        switch (mode) {
        case 0:
            return data_str_0[static_cast<size_t>(level)];
        case 1:
            return data_str_1[static_cast<size_t>(level)];
        default:
            break;
        };
        return data_str_0[static_cast<size_t>(level)];
    }
 
    inline std::string to_string(LogLevel level, int mode = 0) {
        return std::string(to_c_str(level, mode));
    }
 
    inline const char* to_c_str(TextColor color) {
        static const std::array<const char*, 16> ansi_codes = {
            "\033[30m",   // Black
            "\033[31m",   // DarkRed
            "\033[32m",   // DarkGreen
            "\033[33m",   // DarkYellow
            "\033[34m",   // DarkBlue
            "\033[35m",   // DarkMagenta
            "\033[36m",   // DarkCyan
            "\033[37m",   // LightGray
            "\033[90m",   // DarkGray
            "\033[91m",   // Red
            "\033[92m",   // Green
            "\033[93m",   // Yellow
            "\033[94m",   // Blue
            "\033[95m",   // Magenta
            "\033[96m",   // Cyan
            "\033[97m"    // White
        };
 
        // Convert TextColor to a string with an ANSI code
        return ansi_codes[static_cast<int>(color)];
    }
 
    inline std::string to_string(TextColor color) {
        return std::string(to_c_str(color));
    }
 
    inline std::string get_log_level_color(LogLevel log_level) {
        switch (log_level) {
            case LogLevel::LOG_LVL_TRACE:
                return to_string(LOGIT_COLOR_TRACE);
            case LogLevel::LOG_LVL_DEBUG:
                return to_string(LOGIT_COLOR_DEBUG);
            case LogLevel::LOG_LVL_INFO:
                return to_string(LOGIT_COLOR_INFO);
            case LogLevel::LOG_LVL_WARN:
                return to_string(LOGIT_COLOR_WARN);
            case LogLevel::LOG_LVL_ERROR:
                return to_string(LOGIT_COLOR_ERROR);
            case LogLevel::LOG_LVL_FATAL:
                return to_string(LOGIT_COLOR_FATAL);
            default:
                break;
        }
        return to_string(LOGIT_COLOR_DEFAULT);
    }
 
}; // namespace logit
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_ENUMS_HPP_INCLUDED