LogCategory.cpp

Go to the documentation of this file.

 
#include "Engine/Logging/LogCategory.h"
#include <algorithm>
#include <cctype>
#include <fstream>
#include <nlohmann/json.hpp>
#include <plog/Log.h>
 
namespace EngineCore
{
 
// ============================================================================
// LogVerbosity helpers
// ============================================================================
 
LogVerbosity verbosityFromString(const std::string& str)
{
    // Convert to lowercase for case-insensitive comparison
    std::string lower = str;
    std::transform(lower.begin(), lower.end(), lower.begin(),
                   [](unsigned char c) { return std::tolower(c); });
 
    if (lower == "fatal" || lower == "off")     return LogVerbosity::Fatal;
    if (lower == "error")                        return LogVerbosity::Error;
    if (lower == "warning" || lower == "warn")   return LogVerbosity::Warning;
    if (lower == "info")                         return LogVerbosity::Info;
    if (lower == "debug")                        return LogVerbosity::Debug;
    if (lower == "verbose" || lower == "all")    return LogVerbosity::Verbose;
 
    // Default to Info if not recognized
    return LogVerbosity::Info;
}
 
// ============================================================================
// LogCategory
// ============================================================================
 
LogCategory::LogCategory(const char* name, LogVerbosity defaultVerbosity, LogVerbosity compileTimeVerbosity)
    : name_(name)
    , runtimeVerbosity_(defaultVerbosity)
    , compileTimeVerbosity_(compileTimeVerbosity)
{
    // Auto-register with the manager
    LogCategoryManager::get().registerCategory(this);
}
 
// ============================================================================
// LogCategoryManager
// ============================================================================
 
LogCategoryManager& LogCategoryManager::get()
{
    static LogCategoryManager instance;
    return instance;
}
 
void LogCategoryManager::registerCategory(LogCategory* category)
{
    std::lock_guard<std::mutex> lock(mutex_);
    categories_[category->getName()] = category;
}
 
LogCategory* LogCategoryManager::findCategory(const std::string& name)
{
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = categories_.find(name);
    return (it != categories_.end()) ? it->second : nullptr;
}
 
bool LogCategoryManager::setVerbosity(const std::string& categoryName, LogVerbosity verbosity)
{
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = categories_.find(categoryName);
    if (it != categories_.end()) {
        it->second->setVerbosity(verbosity);
        return true;
    }
    return false;
}
 
void LogCategoryManager::setAllVerbosity(LogVerbosity verbosity)
{
    std::lock_guard<std::mutex> lock(mutex_);
    defaultVerbosity_ = verbosity;
    for (auto& [name, category] : categories_) {
        category->setVerbosity(verbosity);
    }
}
 
std::vector<LogCategory*> LogCategoryManager::getAllCategories() const
{
    std::lock_guard<std::mutex> lock(mutex_);
    std::vector<LogCategory*> result;
    result.reserve(categories_.size());
    for (const auto& [name, category] : categories_) {
        result.push_back(category);
    }
    return result;
}
 
bool LogCategoryManager::loadConfig(const std::string& configPath)
{
    try {
        std::ifstream file(configPath);
        if (!file.is_open()) {
            PLOGW << "[LogCategoryManager] Could not open config file: " << configPath;
            return false;
        }
 
        nlohmann::json config;
        file >> config;
 
        if (!config.contains("LogCategories")) {
            PLOGW << "[LogCategoryManager] Config file missing 'LogCategories' section";
            return false;
        }
 
        const auto& categories = config["LogCategories"];
 
        // Check for default verbosity
        if (categories.contains("Default")) {
            std::string defaultStr = categories["Default"].get<std::string>();
            defaultVerbosity_ = verbosityFromString(defaultStr);
            PLOGI << "[LogCategoryManager] Default verbosity set to: " << defaultStr;
        }
 
        // Apply per-category settings
        std::lock_guard<std::mutex> lock(mutex_);
        for (auto& [name, category] : categories_) {
            if (categories.contains(name)) {
                std::string verbStr = categories[name].get<std::string>();
                LogVerbosity verbosity = verbosityFromString(verbStr);
                category->setVerbosity(verbosity);
                PLOGD << "[LogCategoryManager] " << name << " verbosity set to: " << verbStr;
            } else {
                // Apply default to categories not explicitly listed
                category->setVerbosity(defaultVerbosity_);
            }
        }
 
        PLOGI << "[LogCategoryManager] Loaded config from: " << configPath;
        return true;
    }
    catch (const std::exception& e) {
        PLOGE << "[LogCategoryManager] Failed to load config: " << e.what();
        return false;
    }
}
 
bool LogCategoryManager::saveConfig(const std::string& configPath) const
{
    try {
        nlohmann::json config;
        nlohmann::json& categories = config["LogCategories"];
 
        categories["Default"] = verbosityToString(defaultVerbosity_);
 
        {
            std::lock_guard<std::mutex> lock(mutex_);
            for (const auto& [name, category] : categories_) {
                categories[name] = verbosityToString(category->getVerbosity());
            }
        }
 
        std::ofstream file(configPath);
        if (!file.is_open()) {
            PLOGE << "[LogCategoryManager] Could not open config file for writing: " << configPath;
            return false;
        }
 
        file << config.dump(2);  // Pretty print with 2-space indent
        PLOGI << "[LogCategoryManager] Saved config to: " << configPath;
        return true;
    }
    catch (const std::exception& e) {
        PLOGE << "[LogCategoryManager] Failed to save config: " << e.what();
        return false;
    }
}
 
}  // namespace EngineCore