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>
#include <thread>
 
#ifdef BUILD_WITH_COMMON_SYSTEM
 
#include <kcenon/common/di/service_container.h>
#include <kcenon/common/interfaces/executor_interface.h>
#include <kcenon/common/interfaces/logger_interface.h>
 
#include "../adapters/common_executor_adapter.h"
#include "../core/thread_pool.h"
 
namespace kcenon::thread::di {
 
struct executor_registration_config {
    size_t worker_count = 0;
 
    common::di::service_lifetime lifetime = common::di::service_lifetime::singleton;
};
 
 });
 * @endcode
 */
inline common::VoidResult register_executor_services(
    common::di::IServiceContainer& container,
    const executor_registration_config& config = {}) {
 
    // Check if already registered
    if (container.is_registered<common::interfaces::IExecutor>()) {
        return common::make_error<std::monostate>(
            common::di::di_error_codes::already_registered,
            "IExecutor is already registered",
            "thread_system::di"
        );
    }
 
    // Determine worker count
    size_t workers = config.worker_count;
    if (workers == 0) {
        workers = std::thread::hardware_concurrency();
        if (workers == 0) {
            workers = 4;  // fallback default
        }
    }
 
    // Register executor factory
    return container.register_factory<common::interfaces::IExecutor>(
        [workers](common::di::IServiceContainer&) -> std::shared_ptr<common::interfaces::IExecutor> {
            auto pool = std::make_shared<thread_pool>(workers);
            return std::make_shared<adapters::thread_pool_executor_adapter>(pool);
        },
        config.lifetime
    );
}
 
inline common::VoidResult register_executor_instance(
    common::di::IServiceContainer& container,
    std::shared_ptr<thread_pool> pool) {
 
    if (!pool) {
        return common::make_error<std::monostate>(
            common::error_codes::INVALID_ARGUMENT,
            "Cannot register null thread pool instance",
            "thread_system::di"
        );
    }
 
    auto adapter = std::make_shared<adapters::thread_pool_executor_adapter>(pool);
    return container.register_instance<common::interfaces::IExecutor>(adapter);
}
 
inline common::VoidResult unregister_executor_services(
    common::di::IServiceContainer& container) {
 
    return container.unregister<common::interfaces::IExecutor>();
}
 
// ============================================================================
// ILogger Registration (Issue #336)
// ============================================================================
 
inline common::VoidResult register_logger_instance(
    common::di::IServiceContainer& container,
    std::shared_ptr<common::interfaces::ILogger> logger) {
 
    if (!logger) {
        return common::make_error<std::monostate>(
            common::error_codes::INVALID_ARGUMENT,
            "Cannot register null logger instance",
            "thread_system::di"
        );
    }
 
    return container.register_instance<common::interfaces::ILogger>(logger);
}
 
inline common::VoidResult register_logger_factory(
    common::di::IServiceContainer& container,
    std::function<std::shared_ptr<common::interfaces::ILogger>()> factory,
    common::di::service_lifetime lifetime = common::di::service_lifetime::singleton) {
 
    if (!factory) {
        return common::make_error<std::monostate>(
            common::error_codes::INVALID_ARGUMENT,
            "Cannot register null logger factory",
            "thread_system::di"
        );
    }
 
    return container.register_factory<common::interfaces::ILogger>(
        [factory = std::move(factory)](common::di::IServiceContainer&) {
            return factory();
        },
        lifetime
    );
}
 
inline bool is_logger_registered(
    const common::di::IServiceContainer& container) {
 
    return container.is_registered<common::interfaces::ILogger>();
}
 
inline common::VoidResult unregister_logger(
    common::di::IServiceContainer& container) {
 
    return container.unregister<common::interfaces::ILogger>();
}
 
inline common::VoidResult register_thread_services(
    common::di::IServiceContainer& container,
    const executor_registration_config& executor_config = {}) {
 
    // Register IExecutor
    auto result = register_executor_services(container, executor_config);
    if (result.is_err()) {
        return result;
    }
 
    return common::VoidResult::ok({});
}
 
} // namespace kcenon::thread::di
 
#endif // BUILD_WITH_COMMON_SYSTEM