LogCategory.h

Go to the documentation of this file.

#pragma once

 
#include <atomic>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace EngineCore
{

enum class LogVerbosity : uint8_t
{
    Fatal = 0,    
    Error = 1,    
    Warning = 2,  
    Info = 3,     
    Debug = 4,    
    Verbose = 5,  
 
    // Aliases for compatibility
    All = Verbose,
    Off = Fatal
};

constexpr const char* verbosityToString(LogVerbosity v)
{
    switch (v) {
        case LogVerbosity::Fatal:   return "Fatal";
        case LogVerbosity::Error:   return "Error";
        case LogVerbosity::Warning: return "Warning";
        case LogVerbosity::Info:    return "Info";
        case LogVerbosity::Debug:   return "Debug";
        case LogVerbosity::Verbose: return "Verbose";
        default:                    return "Unknown";
    }
}

LogVerbosity verbosityFromString(const std::string& str);

constexpr int verbosityToPlogSeverity(LogVerbosity v)
{
    // plog::Severity: none=0, fatal=1, error=2, warning=3, info=4, debug=5, verbose=6
    switch (v) {
        case LogVerbosity::Fatal:   return 1;
        case LogVerbosity::Error:   return 2;
        case LogVerbosity::Warning: return 3;
        case LogVerbosity::Info:    return 4;
        case LogVerbosity::Debug:   return 5;
        case LogVerbosity::Verbose: return 6;
        default:                    return 4;
    }
}

class LogCategory
{
public:
    LogCategory(const char* name, LogVerbosity defaultVerbosity, LogVerbosity compileTimeVerbosity);

    [[nodiscard]] const char* getName() const { return name_; }

    [[nodiscard]] LogVerbosity getVerbosity() const { return runtimeVerbosity_.load(std::memory_order_relaxed); }

    [[nodiscard]] constexpr LogVerbosity getCompileTimeVerbosity() const { return compileTimeVerbosity_; }

    void setVerbosity(LogVerbosity verbosity) { runtimeVerbosity_.store(verbosity, std::memory_order_relaxed); }

    [[nodiscard]] bool isSuppressed(LogVerbosity messageVerbosity) const
    {
        return static_cast<uint8_t>(messageVerbosity) > static_cast<uint8_t>(runtimeVerbosity_.load(std::memory_order_relaxed));
    }
 
private:
    const char* name_;
    std::atomic<LogVerbosity> runtimeVerbosity_;
    const LogVerbosity compileTimeVerbosity_;
};

class LogCategoryManager
{
public:
    static LogCategoryManager& get();

    void registerCategory(LogCategory* category);

    [[nodiscard]] LogCategory* findCategory(const std::string& name);

    bool setVerbosity(const std::string& categoryName, LogVerbosity verbosity);

    void setAllVerbosity(LogVerbosity verbosity);

    [[nodiscard]] std::vector<LogCategory*> getAllCategories() const;

    bool loadConfig(const std::string& configPath);

    bool saveConfig(const std::string& configPath) const;
 
private:
    LogCategoryManager() = default;
    ~LogCategoryManager() = default;
 
    // Non-copyable
    LogCategoryManager(const LogCategoryManager&) = delete;
    LogCategoryManager& operator=(const LogCategoryManager&) = delete;
 
    mutable std::mutex mutex_;
    std::unordered_map<std::string, LogCategory*> categories_;
    LogVerbosity defaultVerbosity_ = LogVerbosity::Info;
};
 
}  // namespace EngineCore
 
// ============================================================================
// Category Declaration Macros
// ============================================================================

#define DECLARE_LOG_CATEGORY_EXTERN(CategoryName, DefaultVerbosity, CompileTimeVerbosity) \
    extern ::EngineCore::LogCategory CategoryName;

#define DEFINE_LOG_CATEGORY(CategoryName, DefaultVerbosity, CompileTimeVerbosity) \
    ::EngineCore::LogCategory CategoryName(#CategoryName, \
        ::EngineCore::LogVerbosity::DefaultVerbosity, \
        ::EngineCore::LogVerbosity::CompileTimeVerbosity);

#define DEFINE_LOG_CATEGORY_STATIC(CategoryName, DefaultVerbosity, CompileTimeVerbosity) \
    static ::EngineCore::LogCategory CategoryName##_Instance(#CategoryName, \
        ::EngineCore::LogVerbosity::DefaultVerbosity, \
        ::EngineCore::LogVerbosity::CompileTimeVerbosity); \
    static ::EngineCore::LogCategory& CategoryName = CategoryName##_Instance;