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 <kcenon/network/config/feature_flags.h>
 
#include <memory>
 
#if KCENON_WITH_COMMON_SYSTEM
 
#include <kcenon/common/di/service_container.h>
 
#include "../core/network_context.h"
 
namespace kcenon::network::di {
 
struct network_registration_config {
    size_t thread_count = 0;
 
    bool initialize_on_register = true;
 
    common::di::service_lifetime lifetime = common::di::service_lifetime::singleton;
};
 
 });
 * @endcode
 */
inline common::VoidResult register_network_services(
    common::di::IServiceContainer& container,
    const network_registration_config& config = {}) {
 
    // Check if already registered
    if (container.is_registered<kcenon::network::core::network_context>()) {
        return common::make_error<std::monostate>(
            common::di::di_error_codes::already_registered,
            "network_context is already registered",
            "kcenon::network::di"
        );
    }
 
    // Register network_context factory
    // Note: network_context is a singleton, so we return a reference wrapper
    return container.register_factory<kcenon::network::core::network_context>(
        [config](common::di::IServiceContainer&) -> std::shared_ptr<kcenon::network::core::network_context> {
            // Get the singleton instance
            auto& ctx = kcenon::network::core::network_context::instance();
 
            // Initialize if requested and not already initialized
            if (config.initialize_on_register && !ctx.is_initialized()) {
                ctx.initialize(config.thread_count);
            }
 
            // Return a non-owning shared_ptr (aliasing constructor)
            // This allows the context to be managed via DI without changing ownership
            return std::shared_ptr<kcenon::network::core::network_context>(
                std::shared_ptr<void>{}, &ctx);
        },
        config.lifetime
    );
}
 
inline common::VoidResult unregister_network_services(
    common::di::IServiceContainer& container) {
 
    return container.unregister<kcenon::network::core::network_context>();
}
 
inline common::VoidResult shutdown_network_services(
    common::di::IServiceContainer& container) {
 
    // Shutdown the singleton
    kcenon::network::core::network_context::instance().shutdown();
 
    // Unregister from container
    return unregister_network_services(container);
}
 
inline kcenon::network::core::network_context& get_network_context() {
    return kcenon::network::core::network_context::instance();
}
 
inline common::VoidResult register_all_network_services(
    common::di::IServiceContainer& container,
    const network_registration_config& config = {}) {
 
    // Register network_context
    auto result = register_network_services(container, config);
    if (result.is_err()) {
        return result;
    }
 
    return common::VoidResult::ok({});
}
 
} // namespace kcenon::network::di
 
#endif // KCENON_WITH_COMMON_SYSTEM