service_registration.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <memory>
 
#ifdef BUILD_WITH_COMMON_SYSTEM
 
#include <kcenon/common/di/service_container.h>
#include <kcenon/common/interfaces/logger_interface.h>
 
#include "../core/logger_builder.h"
#include "../core/logger.h"
 
namespace kcenon::logger::di {
 
// Type alias for log_level
using log_level = common::interfaces::log_level;
 
namespace detail {
 
class ilogger_adapter : public common::interfaces::ILogger {
public:
    explicit ilogger_adapter(std::shared_ptr<logger> lgr)
        : logger_(std::move(lgr))
        , level_(common::interfaces::log_level::info) {}
 
    ~ilogger_adapter() override = default;
 
    common::VoidResult log(log_level level,
                           const std::string& message) override {
        if (!logger_) {
            return common::make_error<std::monostate>(
                1, "Logger not initialized", "logger_system");
        }
        logger_->log(level, message);
        return common::VoidResult::ok({});
    }
 
    common::VoidResult log(log_level level,
                           const std::string& message,
                           const std::string& file,
                           int line,
                           const std::string& function) override {
        if (!logger_) {
            return common::make_error<std::monostate>(
                1, "Logger not initialized", "logger_system");
        }
        // Format message with location info
        std::string formatted = "[" + file + ":" + std::to_string(line) + ":" + function + "] " + message;
        logger_->log(level, formatted);
        return common::VoidResult::ok({});
    }
 
    common::VoidResult log(const common::interfaces::log_entry& entry) override {
        if (!logger_) {
            return common::make_error<std::monostate>(
                1, "Logger not initialized", "logger_system");
        }
        if (!entry.file.empty()) {
            std::string formatted = "[" + entry.file + ":" + std::to_string(entry.line) +
                                    ":" + entry.function + "] " + entry.message;
            logger_->log(entry.level, formatted);
        } else {
            logger_->log(entry.level, entry.message);
        }
        return common::VoidResult::ok({});
    }
 
    bool is_enabled(log_level level) const override {
        return level >= level_;
    }
 
    common::VoidResult set_level(log_level level) override {
        level_ = level;
        if (logger_) {
            logger_->set_level(level);
        }
        return common::VoidResult::ok({});
    }
 
    log_level get_level() const override {
        return level_;
    }
 
    common::VoidResult flush() override {
        if (logger_) {
            logger_->flush();
        }
        return common::VoidResult::ok({});
    }
 
private:
    std::shared_ptr<logger> logger_;
    log_level level_;
};
 
} // namespace detail
 
struct logger_registration_config {
    std::string config_template = "default";
 
    log_level min_level = log_level::info;
 
    bool async = true;
 
    bool metrics = false;
 
    common::di::service_lifetime lifetime = common::di::service_lifetime::singleton;
};
 
inline common::VoidResult register_logger_services(
    common::di::IServiceContainer& container,
    const logger_registration_config& config = {}) {
 
    // Check if already registered
    if (container.is_registered<common::interfaces::ILogger>()) {
        return common::make_error<std::monostate>(
            common::di::di_error_codes::already_registered,
            "ILogger is already registered",
            "logger_system::di"
        );
    }
 
    // Register logger factory
    return container.register_factory<common::interfaces::ILogger>(
        [config](common::di::IServiceContainer&) -> std::shared_ptr<common::interfaces::ILogger> {
            // Build logger with configuration
            auto builder = logger_builder()
                .use_template(config.config_template)
                .with_min_level(config.min_level)
                .with_async(config.async)
                .with_metrics(config.metrics);
 
            auto result = builder.build();
            if (!result) {
                // Return a null logger on failure - the caller should check
                // This should rarely happen with default configuration
                return nullptr;
            }
 
            // Create adapter that implements ILogger
            return std::make_shared<detail::ilogger_adapter>(
                std::shared_ptr<logger>(result.value().release())
            );
        },
        config.lifetime
    );
}
 
inline common::VoidResult register_logger_instance(
    common::di::IServiceContainer& container,
    std::unique_ptr<logger> lgr) {
 
    if (!lgr) {
        return common::make_error<std::monostate>(
            common::error_codes::INVALID_ARGUMENT,
            "Cannot register null logger instance",
            "logger_system::di"
        );
    }
 
    auto adapter = std::make_shared<detail::ilogger_adapter>(
        std::shared_ptr<logger>(lgr.release())
    );
 
    return container.register_instance<common::interfaces::ILogger>(adapter);
}
 
inline common::VoidResult unregister_logger_services(
    common::di::IServiceContainer& container) {
 
    return container.unregister<common::interfaces::ILogger>();
}
 
} // namespace kcenon::logger::di
 
#endif // BUILD_WITH_COMMON_SYSTEM