kcenon::thread::service_container Class Reference

Modern service container for dependency injection. More...

#include <service_container.h>

Collaboration diagram for kcenon::thread::service_container:

Classes
struct	service_entry

Public Types
enum class	lifetime { singleton , transient }
	Service lifetime scope. More...

Public Member Functions
template<typename Interface , typename Implementation >
void	register_singleton (std::shared_ptr< Implementation > instance)
	Register a service with singleton lifetime.
template<typename Interface >
void	register_factory (std::function< std::shared_ptr< Interface >()> factory, lifetime lt=lifetime::transient)
	Register a service with factory function.
template<typename Interface , typename Implementation , typename... Args>
void	register_transient ()
	Register a transient service.
template<typename Interface >
std::shared_ptr< Interface >	resolve ()
	Resolve a service.
template<typename Interface >
bool	is_registered () const
	Check if a service is registered.
void	clear ()
	Clear all registered services.

Static Public Member Functions
static service_container &	global ()
	Get the global service container instance.

Private Attributes
std::mutex	mutex_
std::unordered_map< std::type_index, service_entry >	services_

Detailed Description

Modern service container for dependency injection.

This container supports:

• Registration of interfaces with concrete implementations
• Factory functions for lazy instantiation
• Singleton and transient lifetime management
• Thread-safe operations

Definition at line 30 of file service_container.h.

Member Enumeration Documentation

lifetime

enum class kcenon::thread::service_container::lifetime

strong

Service lifetime scope.

Enumerator
singleton
transient

Definition at line 35 of file service_container.h.

                        {
        singleton,  // Single instance shared across all requests
        transient   // New instance for each request
    };

Member Function Documentation

clear()

void kcenon::thread::service_container::clear ( )

inline

Clear all registered services.

Definition at line 139 of file service_container.h.

                 {
        std::lock_guard<std::mutex> lock(mutex_);
        services_.clear();
    }

References mutex_, and services_.

Referenced by complete_integration_example(), demonstrate_minimal_usage(), dynamic_service_example(), main(), thread_pool_with_logger_example(), and thread_pool_with_monitoring_example().

Here is the caller graph for this function:

global()

static service_container & kcenon::thread::service_container::global ( )

inlinestatic

Get the global service container instance.

Returns

Reference to the global container

Definition at line 148 of file service_container.h.

                                       {
        static service_container instance;
        return instance;
    }

Referenced by complete_integration_example(), demonstrate_composition(), demonstrate_minimal_usage(), dynamic_service_example(), kcenon::thread::thread_context_builder::from_global_registry(), main(), kcenon::thread::scoped_service< Interface >::scoped_service(), thread_pool_with_logger_example(), and thread_pool_with_monitoring_example().

Here is the caller graph for this function:

is_registered()

template<typename Interface >

bool kcenon::thread::service_container::is_registered ( ) const

inline

Check if a service is registered.

Template Parameters

Interface

The interface type to check

Returns

true if the service is registered

Definition at line 131 of file service_container.h.

                               {
        std::lock_guard<std::mutex> lock(mutex_);
        return services_.find(std::type_index(typeid(Interface))) != services_.end();
    }

References mutex_, and services_.

register_factory()

template<typename Interface >

void kcenon::thread::service_container::register_factory ( std::function< std::shared_ptr< Interface >()> factory, lifetime lt = lifetime::transient )

inline

Register a service with factory function.

Template Parameters

Interface

The interface type

Parameters

factory	Factory function that creates the service
lt	Service lifetime (default: transient)

Definition at line 63 of file service_container.h.

                                                          {
        std::lock_guard<std::mutex> lock(mutex_);
        services_[std::type_index(typeid(Interface))] = 
            service_entry{lt, nullptr, 
                [factory]() -> std::shared_ptr<void> { 
                    return factory(); 
                }};
    }

References mutex_, and services_.

Referenced by register_transient().

Here is the caller graph for this function:

register_singleton()

template<typename Interface , typename Implementation >

void kcenon::thread::service_container::register_singleton ( std::shared_ptr< Implementation > instance )

inline

Register a service with singleton lifetime.

Template Parameters

Interface	The interface type
Implementation	The concrete implementation type

Parameters

instance

Shared pointer to the implementation

Definition at line 47 of file service_container.h.

                                                                    {
        static_assert(std::is_base_of_v<Interface, Implementation>,
                      "Implementation must derive from Interface");
        
        std::lock_guard<std::mutex> lock(mutex_);
        services_[std::type_index(typeid(Interface))] = 
            service_entry{lifetime::singleton, instance, nullptr};
    }

References mutex_, services_, and singleton.

Referenced by complete_integration_example(), dynamic_service_example(), kcenon::thread::scoped_service< Interface >::scoped_service(), thread_pool_with_logger_example(), and thread_pool_with_monitoring_example().

Here is the caller graph for this function:

register_transient()

template<typename Interface , typename Implementation , typename... Args>

void kcenon::thread::service_container::register_transient ( )

inline

Register a transient service.

Template Parameters

Interface	The interface type
Implementation	The concrete implementation type
Args	Constructor argument types

Definition at line 80 of file service_container.h.

                              {
        static_assert(std::is_base_of_v<Interface, Implementation>,
                      "Implementation must derive from Interface");
        
        register_factory<Interface>(
            []() { return std::make_shared<Implementation>(); },
            lifetime::transient);
    }

References register_factory(), and transient.

Here is the call graph for this function:

resolve()

template<typename Interface >

std::shared_ptr< Interface > kcenon::thread::service_container::resolve ( )

inline

Resolve a service.

Template Parameters

Interface

The interface type to resolve

Returns

Shared pointer to the service, or nullptr if not found

Definition at line 95 of file service_container.h.

                                       {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = services_.find(std::type_index(typeid(Interface)));
        if (it == services_.end()) {
            return nullptr;
        }
 
        auto& entry = it->second;
        
        // For singletons with existing instance
        if (entry.lifetime_scope == lifetime::singleton && entry.instance) {
            return std::static_pointer_cast<Interface>(entry.instance);
        }
        
        // Create new instance using factory
        if (entry.factory) {
            auto instance = entry.factory();
            
            // Store singleton instances
            if (entry.lifetime_scope == lifetime::singleton) {
                entry.instance = instance;
            }
            
            return std::static_pointer_cast<Interface>(instance);
        }
        
        return nullptr;
    }

References mutex_, services_, and singleton.

Referenced by kcenon::thread::thread_context_builder::from_global_registry().

Here is the caller graph for this function:

Member Data Documentation

mutex_

std::mutex kcenon::thread::service_container::mutex_

mutableprivate

Definition at line 160 of file service_container.h.

Referenced by clear(), is_registered(), register_factory(), register_singleton(), and resolve().

services_

std::unordered_map<std::type_index, service_entry> kcenon::thread::service_container::services_

private

Definition at line 161 of file service_container.h.

Referenced by clear(), is_registered(), register_factory(), register_singleton(), and resolve().

---

The documentation for this class was generated from the following file:

• include/kcenon/thread/interfaces/service_container.h