Concrete implementation of IServiceContainer. More...

#include <service_container.h>

Inheritance diagram for kcenon::common::di::service_container:

Collaboration diagram for kcenon::common::di::service_container:

Classes
struct	service_entry
	Internal service registration entry. More...

Public Member Functions
	service_container ()=default
	Default constructor.

	~service_container () override=default
	Destructor.

	service_container (const service_container &)=delete

service_container &	operator= (const service_container &)=delete

	service_container (service_container &&)=delete

service_container &	operator= (service_container &&)=delete

std::unique_ptr< IServiceScope >	create_scope () override
	Create a new service scope.

std::vector< service_descriptor >	registered_services () const override
	Get list of all registered service descriptors.

VoidResult	clear () override
	Clear all registrations.

void	freeze ()
	Freeze the container to prevent further registrations.

bool	is_frozen () const
	Check if the container is frozen.

Public Member Functions inherited from kcenon::common::di::IServiceContainer
virtual	~IServiceContainer ()=default

template<concepts::ServiceInterface TInterface, concepts::ServiceImplementation< TInterface > TImpl>
VoidResult	register_type (service_lifetime lifetime=service_lifetime::singleton)
	Register a service type with its implementation.

template<typename TInterface >
VoidResult	register_instance (std::shared_ptr< TInterface > instance)
	Register a pre-existing instance as a singleton.

template<concepts::ServiceInterface TInterface, concepts::ServiceFactory< TInterface > TFactory>
VoidResult	register_factory (TFactory &&factory, service_lifetime lifetime=service_lifetime::singleton)
	Register a factory function for creating service instances.

template<concepts::ServiceInterface TInterface, concepts::SimpleServiceFactory< TInterface > TFactory>
VoidResult	register_simple_factory (TFactory &&factory, service_lifetime lifetime=service_lifetime::singleton)
	Register a simple factory function without container access.

template<typename TInterface >
Result< std::shared_ptr< TInterface > >	resolve ()
	Resolve a service by its interface type.

template<typename TInterface >
std::shared_ptr< TInterface >	resolve_or_null ()
	Try to resolve a service, returning nullptr if not found.

template<typename TInterface >
bool	is_registered () const
	Check if a service type is registered.

template<typename TInterface >
VoidResult	unregister ()
	Unregister a service type.

virtual	~IServiceContainer ()=default

template<typename Interface , typename Factory >
void	register_factory (Factory &&factory)
	Register a service with a factory function.

template<typename Interface >
void	register_singleton (std::shared_ptr< Interface > instance)
	Register a singleton instance.

template<typename Interface >
std::shared_ptr< Interface >	resolve ()
	Resolve a service by interface type.

template<typename Interface >
bool	has () const
	Check if a service is registered.

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

Protected Member Functions
VoidResult	register_factory_internal (std::type_index interface_type, const std::string &type_name, std::function< std::shared_ptr< void >(IServiceContainer &)> factory, service_lifetime lifetime) override
	Internal factory registration (type-erased).

VoidResult	register_instance_internal (std::type_index interface_type, const std::string &type_name, std::shared_ptr< void > instance) override
	Internal instance registration (type-erased).

Result< std::shared_ptr< void > >	resolve_internal (std::type_index interface_type) override
	Internal service resolution (type-erased).

bool	is_registered_internal (std::type_index interface_type) const override
	Internal registration check (type-erased).

VoidResult	unregister_internal (std::type_index interface_type) override
	Internal unregistration (type-erased).

Protected Member Functions inherited from kcenon::common::di::IServiceContainer
virtual void	register_impl (std::type_index type, std::any factory)=0

virtual void	register_singleton_impl (std::type_index type, std::any instance)=0

virtual std::any	resolve_impl (std::type_index type)=0

virtual bool	has_impl (std::type_index type) const =0

Private Member Functions
Result< std::shared_ptr< void > >	resolve_with_detection (std::type_index interface_type, std::unordered_map< std::type_index, std::shared_ptr< void > > *scoped_instances=nullptr)
	Resolve a service with circular dependency detection.

bool	is_resolving (std::type_index interface_type) const
	Check if currently resolving this type (circular dependency check).

void	push_resolution (std::type_index interface_type)
	Push type onto resolution stack.

void	pop_resolution (std::type_index interface_type)
	Pop type from resolution stack.

std::string	get_resolution_stack_string () const
	Get current resolution stack as string for error messages.

VoidResult	check_frozen_for_registration (const std::string &type_name, interfaces::registry_action action, const std::string &error_message) const
	Check if container is frozen and log audit event if so.

VoidResult	check_already_registered (std::type_index interface_type, const std::string &type_name) const
	Check if a service is already registered and log audit event if so.

Result< std::shared_ptr< void > >	invoke_factory_safe (const std::function< std::shared_ptr< void >(IServiceContainer &)> &factory)
	Safely invoke a factory function with exception handling.

Private Attributes
std::shared_mutex	mutex_

std::unordered_map< std::type_index, service_entry >	services_

std::atomic< bool >	frozen_ {false}

Static Private Attributes
static thread_local std::unordered_set< std::type_index >	resolution_stack_

static thread_local std::vector< std::type_index >	resolution_order_

Friends
class	service_scope

Detailed Description

Concrete implementation of IServiceContainer.

Provides a thread-safe dependency injection container with support for:

Singleton, transient, and scoped service lifetimes
Factory-based lazy instantiation
Circular dependency detection
Scoped containers for request-level isolation

Usage Example:

auto& container = service_container::global();
 
// Register a singleton logger
container.register_factory<ILogger>(
    [](IServiceContainer&) { return std::make_shared<ConsoleLogger>(); },
    service_lifetime::singleton
);
 
// Register a transient service
container.register_type<IWorker, WorkerImpl>(service_lifetime::transient);
 
// Resolve services
auto logger = container.resolve<ILogger>().value();

Definition at line 66 of file service_container.h.

Constructor & Destructor Documentation

◆ service_container() [1/3]

kcenon::common::di::service_container::service_container ( )

default

Default constructor.

◆ ~service_container()

kcenon::common::di::service_container::~service_container ( )

overridedefault

Destructor.

◆ service_container() [2/3]

kcenon::common::di::service_container::service_container ( const service_container & )

delete

◆ service_container() [3/3]

kcenon::common::di::service_container::service_container ( service_container && )

delete

Member Function Documentation

◆ check_already_registered()

VoidResult kcenon::common::di::service_container::check_already_registered	(	std::type_index	interface_type,
		const std::string &	type_name ) const

inlineprivate

Check if a service is already registered and log audit event if so.

Note: Caller must hold the mutex lock before calling this method.

Parameters

interface_type	The type to check
type_name	The type name for audit logging

Returns: VoidResult - error if already registered, ok otherwise

Definition at line 435 of file service_container.h.

                                      {
 
    if (services_.find(interface_type) != services_.end()) {
        interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
            interfaces::registry_action::register_service, type_name,
            interfaces::source_location::current(), false,
            "Service already registered"));
        return make_error<std::monostate>(
            di_error_codes::already_registered,
            "Service already registered: " + type_name,
            "di::service_container"
        );
    }
 
    return VoidResult::ok({});
}

References kcenon::common::di::di_error_codes::already_registered, kcenon::common::source_location::current(), kcenon::common::interfaces::RegistryAuditLog::log_event(), kcenon::common::make_error(), kcenon::common::Result< T >::ok(), kcenon::common::interfaces::register_service, and services_.

Referenced by register_factory_internal(), and register_instance_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_frozen_for_registration()

VoidResult kcenon::common::di::service_container::check_frozen_for_registration	(	const std::string &	type_name,
		interfaces::registry_action	action,
		const std::string &	error_message ) const

inlineprivate

Check if container is frozen and log audit event if so.

Parameters

type_name	The type name for audit logging
action	The registry action being performed
error_message	The error message to use if frozen

Returns: VoidResult - error if frozen, ok otherwise

Definition at line 415 of file service_container.h.

                                          {
 
    if (is_frozen()) {
        interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
            action, type_name,
            interfaces::source_location::current(), false,
            "Container is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            error_message,
            "di::service_container"
        );
    }
 
    return VoidResult::ok({});
}

References kcenon::common::source_location::current(), is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), kcenon::common::make_error(), kcenon::common::Result< T >::ok(), and kcenon::common::error_codes::REGISTRY_FROZEN.

Referenced by register_factory_internal(), and register_instance_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

VoidResult kcenon::common::di::service_container::clear ( )

inlineoverridevirtual

Clear all registrations.

Returns: VoidResult - error if the container is frozen, ok otherwise

Implements kcenon::common::di::IServiceContainer.

Definition at line 376 of file service_container.h.

                                           {
    if (is_frozen()) {
        interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
            interfaces::registry_action::clear_services, "",
            interfaces::source_location::current(), false,
            "Container is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            "Cannot clear services: container is frozen",
            "di::service_container"
        );
    }
 
    std::unique_lock lock(mutex_);
    services_.clear();
 
    interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
        interfaces::registry_action::clear_services, "",
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}

References kcenon::common::interfaces::clear_services, kcenon::common::source_location::current(), is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), kcenon::common::make_error(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::error_codes::REGISTRY_FROZEN, and services_.

Referenced by kcenon::common::di::unified_bootstrapper::initialize(), and kcenon::common::di::unified_bootstrapper::shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_scope()

std::unique_ptr< IServiceScope > kcenon::common::di::service_container::create_scope ( )

inlineoverridevirtual

Create a new service scope.

Returns: Unique pointer to the new scope

Implements kcenon::common::di::IServiceContainer.

Definition at line 357 of file service_container.h.

                                                                    {
    return std::make_unique<service_scope>(*this);
}

◆ freeze()

void kcenon::common::di::service_container::freeze ( )

inline

Freeze the container to prevent further registrations.

Once frozen, no new services can be registered or unregistered. Existing services can still be resolved. This is a one-way operation and cannot be undone.

Note: This should be called after system initialization to prevent unauthorized service replacement which could be used to inject malicious implementations.; This is a security feature to prevent service hijacking.

See also: Issue #206 for security requirements.

Definition at line 399 of file service_container.h.

                                      {
    frozen_.store(true, std::memory_order_release);
 
    interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
        interfaces::registry_action::freeze_service_container, "",
        interfaces::source_location::current(), true));
}

References kcenon::common::source_location::current(), kcenon::common::interfaces::freeze_service_container, frozen_, and kcenon::common::interfaces::RegistryAuditLog::log_event().

Referenced by kcenon::common::bootstrap::SystemBootstrapper::initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_resolution_stack_string()

std::string kcenon::common::di::service_container::get_resolution_stack_string ( ) const

inlineprivate

Get current resolution stack as string for error messages.

Definition at line 730 of file service_container.h.

                                                                      {
    std::string result;
    for (size_t i = 0; i < resolution_order_.size(); ++i) {
        if (i > 0) {
            result += " -> ";
        }
        result += resolution_order_[i].name();
    }
    return result;
}

References resolution_order_.

Referenced by resolve_with_detection().

Here is the caller graph for this function:

◆ global()

service_container & kcenon::common::di::service_container::global ( )

inlinestatic

Get the global service container instance.

Returns a reference to the application-wide singleton container. Thread-safe for concurrent access.

Returns: Reference to the global service_container

Definition at line 352 of file service_container.h.

                                                    {
    static service_container instance;
    return instance;
}

Referenced by kcenon::common::bootstrap::SystemBootstrapper::initialize(), kcenon::common::di::unified_bootstrapper::initialize(), main(), kcenon::common::di::unified_bootstrapper::register_module(), kcenon::common::di::unified_bootstrapper::register_optional_services(), kcenon::common::di::unified_bootstrapper::services(), and kcenon::common::di::unified_bootstrapper::shutdown().

Here is the caller graph for this function:

◆ invoke_factory_safe()

Result< std::shared_ptr< void > > kcenon::common::di::service_container::invoke_factory_safe ( const std::function< std::shared_ptr< void >(IServiceContainer &)> & factory )

inlineprivate

Safely invoke a factory function with exception handling.

Parameters

factory The factory function to invoke

Returns: Result containing the created instance or a factory_error

Definition at line 454 of file service_container.h.

                                                                         {
 
    try {
        return Result<std::shared_ptr<void>>::ok(factory(*this));
    } catch (const std::exception& e) {
        return make_error<std::shared_ptr<void>>(
            di_error_codes::factory_error,
            std::string("Factory threw exception: ") + e.what(),
            "di::service_container"
        );
    }
}

References kcenon::common::di::di_error_codes::factory_error, kcenon::common::make_error(), and kcenon::common::ok().

Referenced by resolve_with_detection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_frozen()

bool kcenon::common::di::service_container::is_frozen ( ) const

inline

Check if the container is frozen.

Returns: true if the container is frozen and cannot be modified

Definition at line 407 of file service_container.h.

                                               {
    return frozen_.load(std::memory_order_acquire);
}

References frozen_.

Referenced by check_frozen_for_registration(), clear(), and unregister_internal().

Here is the caller graph for this function:

◆ is_registered_internal()

bool kcenon::common::di::service_container::is_registered_internal ( std::type_index interface_type ) const

inlineoverrideprotectedvirtual

Internal registration check (type-erased).

Implements kcenon::common::di::IServiceContainer.

Definition at line 670 of file service_container.h.

                                                                                        {
    std::shared_lock lock(mutex_);
    return services_.find(interface_type) != services_.end();
}

References mutex_, and services_.

Referenced by kcenon::common::di::service_scope::is_registered_internal().

Here is the caller graph for this function:

◆ is_resolving()

bool kcenon::common::di::service_container::is_resolving ( std::type_index interface_type ) const

inlineprivate

Check if currently resolving this type (circular dependency check).

Definition at line 714 of file service_container.h.

                                                                              {
    return resolution_stack_.find(interface_type) != resolution_stack_.end();
}

References resolution_stack_.

Referenced by resolve_with_detection().

Here is the caller graph for this function:

◆ operator=() [1/2]

service_container & kcenon::common::di::service_container::operator= ( const service_container & )

delete

◆ operator=() [2/2]

service_container & kcenon::common::di::service_container::operator= ( service_container && )

delete

◆ pop_resolution()

void kcenon::common::di::service_container::pop_resolution ( std::type_index interface_type )

inlineprivate

Pop type from resolution stack.

Definition at line 723 of file service_container.h.

                                                                          {
    resolution_stack_.erase(interface_type);
    if (!resolution_order_.empty() && resolution_order_.back() == interface_type) {
        resolution_order_.pop_back();
    }
}

References resolution_order_, and resolution_stack_.

Referenced by resolve_with_detection().

Here is the caller graph for this function:

◆ push_resolution()

void kcenon::common::di::service_container::push_resolution ( std::type_index interface_type )

inlineprivate

Push type onto resolution stack.

Definition at line 718 of file service_container.h.

                                                                           {
    resolution_stack_.insert(interface_type);
    resolution_order_.push_back(interface_type);
}

References resolution_order_, and resolution_stack_.

Referenced by resolve_with_detection().

Here is the caller graph for this function:

◆ register_factory_internal()

VoidResult kcenon::common::di::service_container::register_factory_internal	(	std::type_index	interface_type,
		const std::string &	type_name,
		std::function< std::shared_ptr< void >(IServiceContainer &)>	factory,
		service_lifetime	lifetime )

inlineoverrideprotectedvirtual

Internal factory registration (type-erased).

Implements kcenon::common::di::IServiceContainer.

Definition at line 468 of file service_container.h.

                               {
 
    // Check frozen state before acquiring lock
    auto frozen_check = check_frozen_for_registration(
        type_name,
        interfaces::registry_action::register_service,
        "Cannot register service: container is frozen");
    if (!frozen_check.is_ok()) {
        return frozen_check;
    }
 
    std::unique_lock lock(mutex_);
 
    // Check if already registered (must hold lock)
    auto registered_check = check_already_registered(interface_type, type_name);
    if (!registered_check.is_ok()) {
        return registered_check;
    }
 
    services_.emplace(
        interface_type,
        service_entry(interface_type, type_name, std::move(factory), lifetime)
    );
 
    interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
        interfaces::registry_action::register_service, type_name,
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}

References check_already_registered(), check_frozen_for_registration(), kcenon::common::source_location::current(), kcenon::common::interfaces::RegistryAuditLog::log_event(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::interfaces::register_service, and services_.

Referenced by kcenon::common::di::service_scope::register_factory_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ register_instance_internal()

VoidResult kcenon::common::di::service_container::register_instance_internal	(	std::type_index	interface_type,
		const std::string &	type_name,
		std::shared_ptr< void >	instance )

inlineoverrideprotectedvirtual

Internal instance registration (type-erased).

Implements kcenon::common::di::IServiceContainer.

Definition at line 503 of file service_container.h.

                                  {
 
    // Check frozen state before acquiring lock
    auto frozen_check = check_frozen_for_registration(
        type_name,
        interfaces::registry_action::register_service,
        "Cannot register instance: container is frozen");
    if (!frozen_check.is_ok()) {
        return frozen_check;
    }
 
    std::unique_lock lock(mutex_);
 
    // Check if already registered (must hold lock)
    auto registered_check = check_already_registered(interface_type, type_name);
    if (!registered_check.is_ok()) {
        return registered_check;
    }
 
    // Create entry with instance as singleton
    service_entry entry(
        interface_type,
        type_name,
        [](IServiceContainer&) -> std::shared_ptr<void> { return nullptr; },
        service_lifetime::singleton
    );
    entry.singleton_instance = std::move(instance);
    entry.is_instantiated = true;
 
    services_.emplace(interface_type, std::move(entry));
 
    interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
        interfaces::registry_action::register_service, type_name,
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}

References check_already_registered(), check_frozen_for_registration(), kcenon::common::source_location::current(), kcenon::common::interfaces::RegistryAuditLog::log_event(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::interfaces::register_service, services_, kcenon::common::di::singleton, and kcenon::common::di::service_container::service_entry::singleton_instance.

Referenced by kcenon::common::di::service_scope::register_instance_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ registered_services()

std::vector< service_descriptor > kcenon::common::di::service_container::registered_services ( ) const

inlineoverridevirtual

Get list of all registered service descriptors.

Returns: Vector of service descriptors

Implements kcenon::common::di::IServiceContainer.

Definition at line 361 of file service_container.h.

                                                                                  {
    std::shared_lock lock(mutex_);
 
    std::vector<service_descriptor> result;
    result.reserve(services_.size());
 
    for (const auto& [type_index, entry] : services_) {
        service_descriptor desc(entry.interface_type, entry.type_name, entry.lifetime);
        desc.is_instantiated = entry.is_instantiated;
        result.push_back(std::move(desc));
    }
 
    return result;
}

References kcenon::common::di::service_descriptor::is_instantiated, mutex_, and services_.

Referenced by kcenon::common::di::service_scope::registered_services().

Here is the caller graph for this function:

◆ resolve_internal()

Result< std::shared_ptr< void > > kcenon::common::di::service_container::resolve_internal ( std::type_index interface_type )

inlineoverrideprotectedvirtual

Internal service resolution (type-erased).

Implements kcenon::common::di::IServiceContainer.

Definition at line 544 of file service_container.h.

                                  {
    return resolve_with_detection(interface_type, nullptr);
}

References resolve_with_detection().

Here is the call graph for this function:

◆ resolve_with_detection()

Result< std::shared_ptr< void > > kcenon::common::di::service_container::resolve_with_detection	(	std::type_index	interface_type,
		std::unordered_map< std::type_index, std::shared_ptr< void > > *	scoped_instances = nullptr )

inlineprivate

Resolve a service with circular dependency detection.

Parameters

interface_type	The type to resolve
scoped_instances	Optional map for scoped instances (from scope)

Returns: Result containing the service or an error

Definition at line 549 of file service_container.h.

                                                                            {
 
    // Check for circular dependency
    if (is_resolving(interface_type)) {
        std::string cycle_info = get_resolution_stack_string();
        return make_error<std::shared_ptr<void>>(
            di_error_codes::circular_dependency,
            "Circular dependency detected: " + cycle_info,
            "di::service_container"
        );
    }
 
    // Check if service is registered
    {
        std::shared_lock lock(mutex_);
        auto it = services_.find(interface_type);
        if (it == services_.end()) {
            return make_error<std::shared_ptr<void>>(
                di_error_codes::service_not_registered,
                "Service not registered: " + std::string(interface_type.name()),
                "di::service_container"
            );
        }
    }
 
    // Push onto resolution stack
    push_resolution(interface_type);
 
    // RAII guard to pop from resolution stack
    struct resolution_guard {
        service_container* container;
        std::type_index type;
        ~resolution_guard() { container->pop_resolution(type); }
    } guard{this, interface_type};
 
    // Resolve based on lifetime
    std::shared_lock read_lock(mutex_);
    auto it = services_.find(interface_type);
    auto& entry = it->second;
 
    // Copy factory and lifetime before releasing lock to avoid deadlock
    // when factory calls resolve() recursively
    auto factory_copy = entry.factory;
    auto lifetime = entry.lifetime;
 
    switch (lifetime) {
        case service_lifetime::singleton: {
            // Double-checked locking for singleton
            if (entry.is_instantiated) {
                return Result<std::shared_ptr<void>>::ok(entry.singleton_instance);
            }
 
            read_lock.unlock();
 
            // Create instance outside of lock to avoid deadlock
            auto factory_result = invoke_factory_safe(factory_copy);
            if (!factory_result.is_ok()) {
                return factory_result;
            }
 
            // Now acquire write lock to store the instance
            std::unique_lock write_lock(mutex_);
 
            // Re-check after acquiring write lock (another thread may have created it)
            auto it2 = services_.find(interface_type);
            auto& entry2 = it2->second;
            if (entry2.is_instantiated) {
                // Another thread created it, return that instance
                return Result<std::shared_ptr<void>>::ok(entry2.singleton_instance);
            }
 
            entry2.singleton_instance = std::move(factory_result.value());
            entry2.is_instantiated = true;
            return Result<std::shared_ptr<void>>::ok(entry2.singleton_instance);
        }
 
        case service_lifetime::transient: {
            // Create new instance each time - release lock before calling factory
            read_lock.unlock();
            return invoke_factory_safe(factory_copy);
        }
 
        case service_lifetime::scoped: {
            // Scoped services should be resolved from a scope
            if (scoped_instances == nullptr) {
                return make_error<std::shared_ptr<void>>(
                    di_error_codes::scoped_from_root,
                    "Cannot resolve scoped service from root container. Use create_scope().",
                    "di::service_container"
                );
            }
 
            // Check if already instantiated in scope
            auto scoped_it = scoped_instances->find(interface_type);
            if (scoped_it != scoped_instances->end()) {
                return Result<std::shared_ptr<void>>::ok(scoped_it->second);
            }
 
            // Create new instance for scope - release lock before calling factory
            read_lock.unlock();
            auto factory_result = invoke_factory_safe(factory_copy);
            if (!factory_result.is_ok()) {
                return factory_result;
            }
 
            auto instance = std::move(factory_result.value());
            (*scoped_instances)[interface_type] = instance;
            return Result<std::shared_ptr<void>>::ok(std::move(instance));
        }
 
        default:
            return make_error<std::shared_ptr<void>>(
                di_error_codes::invalid_lifetime,
                "Unknown service lifetime",
                "di::service_container"
            );
    }
}

References kcenon::common::di::di_error_codes::circular_dependency, get_resolution_stack_string(), kcenon::common::di::di_error_codes::invalid_lifetime, invoke_factory_safe(), is_resolving(), kcenon::common::make_error(), mutex_, kcenon::common::ok(), pop_resolution(), push_resolution(), kcenon::common::di::scoped, kcenon::common::di::di_error_codes::scoped_from_root, kcenon::common::di::di_error_codes::service_not_registered, services_, kcenon::common::di::singleton, and kcenon::common::di::transient.

Referenced by resolve_internal(), and kcenon::common::di::service_scope::resolve_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unregister_internal()

VoidResult kcenon::common::di::service_container::unregister_internal ( std::type_index interface_type )

inlineoverrideprotectedvirtual

Internal unregistration (type-erased).

Implements kcenon::common::di::IServiceContainer.

Definition at line 675 of file service_container.h.

                                                                                     {
    std::string type_name = interface_type.name();
 
    if (is_frozen()) {
        interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
            interfaces::registry_action::unregister_service, type_name,
            interfaces::source_location::current(), false,
            "Container is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            "Cannot unregister service: container is frozen",
            "di::service_container"
        );
    }
 
    std::unique_lock lock(mutex_);
 
    auto it = services_.find(interface_type);
    if (it == services_.end()) {
        interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
            interfaces::registry_action::unregister_service, type_name,
            interfaces::source_location::current(), false,
            "Service not registered"));
        return make_error<std::monostate>(
            di_error_codes::service_not_registered,
            "Service not registered",
            "di::service_container"
        );
    }
 
    services_.erase(it);
 
    interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
        interfaces::registry_action::unregister_service, type_name,
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}

References kcenon::common::source_location::current(), is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), kcenon::common::make_error(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::error_codes::REGISTRY_FROZEN, kcenon::common::di::di_error_codes::service_not_registered, services_, and kcenon::common::interfaces::unregister_service.

Referenced by kcenon::common::di::service_scope::unregister_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ service_scope

friend class service_scope

friend

Definition at line 161 of file service_container.h.

Member Data Documentation

◆ frozen_

std::atomic<bool> kcenon::common::di::service_container::frozen_ {false}

private

Definition at line 256 of file service_container.h.

256{false};

Referenced by freeze(), and is_frozen().

◆ mutex_

std::shared_mutex kcenon::common::di::service_container::mutex_

mutableprivate

Definition at line 252 of file service_container.h.

Referenced by clear(), is_registered_internal(), register_factory_internal(), register_instance_internal(), registered_services(), resolve_with_detection(), and unregister_internal().

◆ resolution_order_

thread_local std::vector< std::type_index > kcenon::common::di::service_container::resolution_order_

inlinestaticprivate

Definition at line 260 of file service_container.h.

Referenced by get_resolution_stack_string(), pop_resolution(), and push_resolution().

◆ resolution_stack_

thread_local std::unordered_set< std::type_index > kcenon::common::di::service_container::resolution_stack_

inlinestaticprivate

Definition at line 259 of file service_container.h.

Referenced by is_resolving(), pop_resolution(), and push_resolution().

◆ services_

std::unordered_map<std::type_index, service_entry> kcenon::common::di::service_container::services_

private

Definition at line 253 of file service_container.h.

Referenced by check_already_registered(), clear(), is_registered_internal(), register_factory_internal(), register_instance_internal(), registered_services(), resolve_with_detection(), and unregister_internal().

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

include/kcenon/common/di/service_container.h

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ service_container() [1/3]

◆ ~service_container()

◆ service_container() [2/3]

◆ service_container() [3/3]

Member Function Documentation

◆ check_already_registered()

◆ check_frozen_for_registration()

◆ clear()

◆ create_scope()

◆ freeze()

◆ get_resolution_stack_string()

◆ global()

◆ invoke_factory_safe()

◆ is_frozen()

◆ is_registered_internal()

◆ is_resolving()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ pop_resolution()

◆ push_resolution()

◆ register_factory_internal()

◆ register_instance_internal()

◆ registered_services()

◆ resolve_internal()

◆ resolve_with_detection()

◆ unregister_internal()

Friends And Related Symbol Documentation

◆ service_scope

Member Data Documentation

◆ frozen_

◆ mutex_

◆ resolution_order_

◆ resolution_stack_

◆ services_