kcenon::pacs::di Namespace Reference

Namespaces
namespace	test

Classes
class	DicomNetworkService
	Default implementation of IDicomNetwork using network_adapter. More...
class	IDicomNetwork
	Network service interface for DICOM communication. More...
class	ILogger
	Abstract logger interface for dependency injection. More...
class	LoggerService
	Default implementation of ILogger using logger_adapter. More...
class	NullLogger
	No-op logger implementation for default injection. More...
struct	registration_config
	Configuration for service registration. More...

Typedefs
using	IDicomStorage = storage::storage_interface
	Storage interface for DICOM data persistence.
using	IDicomCodec = encoding::compression::compression_codec
	Codec interface for image compression/decompression.

Functions
std::shared_ptr< ILogger >	null_logger ()
	Get a shared null logger instance.
kcenon::common::VoidResult	register_services (kcenon::common::di::IServiceContainer &container, const registration_config &config={})
template<typename TStorage > requires std::derived_from<TStorage, IDicomStorage>
kcenon::common::VoidResult	register_storage (kcenon::common::di::IServiceContainer &container, std::function< std::shared_ptr< TStorage >(kcenon::common::di::IServiceContainer &)> factory, kcenon::common::di::service_lifetime lifetime=kcenon::common::di::service_lifetime::singleton)
	Register storage service with custom implementation.
kcenon::common::VoidResult	register_storage_instance (kcenon::common::di::IServiceContainer &container, std::shared_ptr< IDicomStorage > instance)
	Register storage service with pre-created instance.
template<typename TNetwork > requires std::derived_from<TNetwork, IDicomNetwork>
kcenon::common::VoidResult	register_network (kcenon::common::di::IServiceContainer &container, std::function< std::shared_ptr< TNetwork >(kcenon::common::di::IServiceContainer &)> factory, kcenon::common::di::service_lifetime lifetime=kcenon::common::di::service_lifetime::singleton)
	Register network service with custom implementation.
kcenon::common::VoidResult	register_network_instance (kcenon::common::di::IServiceContainer &container, std::shared_ptr< IDicomNetwork > instance)
	Register network service with pre-created instance.
template<typename TLogger > requires std::derived_from<TLogger, ILogger>
kcenon::common::VoidResult	register_logger (kcenon::common::di::IServiceContainer &container, std::function< std::shared_ptr< TLogger >(kcenon::common::di::IServiceContainer &)> factory, kcenon::common::di::service_lifetime lifetime=kcenon::common::di::service_lifetime::singleton)
	Register logger service with custom implementation.
kcenon::common::VoidResult	register_logger_instance (kcenon::common::di::IServiceContainer &container, std::shared_ptr< ILogger > instance)
	Register logger service with pre-created instance.
std::shared_ptr< kcenon::common::di::service_container >	create_container (const registration_config &config={})

Typedef Documentation

IDicomCodec

using kcenon::pacs::di::IDicomCodec = encoding::compression::compression_codec

Codec interface for image compression/decompression.

Alias for kcenon::pacs::encoding::compression::compression_codec providing unified access through the DI container.

See also

kcenon::pacs::encoding::compression::compression_codec

Definition at line 58 of file service_interfaces.h.

IDicomStorage

using kcenon::pacs::di::IDicomStorage = storage::storage_interface

Storage interface for DICOM data persistence.

Alias for kcenon::pacs::storage::storage_interface providing unified access through the DI container.

See also

kcenon::pacs::storage::storage_interface

Definition at line 44 of file service_interfaces.h.

Function Documentation

create_container()

std::shared_ptr< kcenon::common::di::service_container > kcenon::pacs::di::create_container ( const registration_config & config = {} )

inlinenodiscard

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 297 of file service_registration.h.

                                                     {}) {
    auto container = std::make_shared<kcenon::common::di::service_container>();
    auto result = register_services(*container, config);
    if (result.is_err()) {
        return nullptr;
    }
    return container;
}

null_logger()

std::shared_ptr< ILogger > kcenon::pacs::di::null_logger ( )

inlinenodiscard

Get a shared null logger instance.

Returns a singleton NullLogger instance for use as a default. This avoids repeated allocations when services need a default logger.

Returns

Shared pointer to NullLogger

Definition at line 271 of file ilogger.h.

                                                          {
    static auto instance = std::make_shared<NullLogger>();
    return instance;
}

Referenced by kcenon::pacs::client::job_manager::job_manager(), kcenon::pacs::client::remote_node_manager::remote_node_manager(), kcenon::pacs::services::scp_service::set_logger(), kcenon::pacs::client::sync_manager::sync_manager(), and kcenon::pacs::client::sync_manager::sync_manager().

Here is the caller graph for this function:

register_logger()

template<typename TLogger >
requires std::derived_from<TLogger, ILogger>

kcenon::common::VoidResult kcenon::pacs::di::register_logger ( kcenon::common::di::IServiceContainer & container, std::function< std::shared_ptr< TLogger >(kcenon::common::di::IServiceContainer &)> factory, kcenon::common::di::service_lifetime lifetime = kcenon::common::di::service_lifetime::singleton )

inlinenodiscard

Register logger service with custom implementation.

Template Parameters

TLogger

Logger implementation type (must derive from ILogger)

Parameters

container	The service container
factory	Factory function for creating logger instances
lifetime	Service lifetime (default: singleton)

Returns

VoidResult indicating success or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 250 of file service_registration.h.

                                                                                       {
 
    return container.register_factory<ILogger>(
        [f = std::move(factory)](kcenon::common::di::IServiceContainer& c) -> std::shared_ptr<ILogger> {
            return f(c);
        },
        lifetime
    );
}

register_logger_instance()

kcenon::common::VoidResult kcenon::pacs::di::register_logger_instance ( kcenon::common::di::IServiceContainer & container, std::shared_ptr< ILogger > instance )

inlinenodiscard

Register logger service with pre-created instance.

Parameters

container	The service container
instance	The logger instance to register

Returns

VoidResult indicating success or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 270 of file service_registration.h.

                                     {
 
    return container.register_instance<ILogger>(std::move(instance));
}

register_network()

template<typename TNetwork >
requires std::derived_from<TNetwork, IDicomNetwork>

kcenon::common::VoidResult kcenon::pacs::di::register_network ( kcenon::common::di::IServiceContainer & container, std::function< std::shared_ptr< TNetwork >(kcenon::common::di::IServiceContainer &)> factory, kcenon::common::di::service_lifetime lifetime = kcenon::common::di::service_lifetime::singleton )

inlinenodiscard

Register network service with custom implementation.

Template Parameters

TNetwork

Network implementation type (must derive from IDicomNetwork)

Parameters

container	The service container
factory	Factory function for creating network service instances
lifetime	Service lifetime (default: singleton)

Returns

VoidResult indicating success or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 212 of file service_registration.h.

                                                                                       {
 
    return container.register_factory<IDicomNetwork>(
        [f = std::move(factory)](kcenon::common::di::IServiceContainer& c) -> std::shared_ptr<IDicomNetwork> {
            return f(c);
        },
        lifetime
    );
}

register_network_instance()

kcenon::common::VoidResult kcenon::pacs::di::register_network_instance ( kcenon::common::di::IServiceContainer & container, std::shared_ptr< IDicomNetwork > instance )

inlinenodiscard

Register network service with pre-created instance.

Parameters

container	The service container
instance	The network service instance to register

Returns

VoidResult indicating success or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 232 of file service_registration.h.

                                           {
 
    return container.register_instance<IDicomNetwork>(std::move(instance));
}

register_services()

kcenon::common::VoidResult kcenon::pacs::di::register_services ( kcenon::common::di::IServiceContainer & container, const registration_config & config = {} )

inlinenodiscard

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 94 of file service_registration.h.

                                        {}) {
 
    using namespace kcenon::common::di;
 
    const auto lifetime = config.use_singletons
        ? service_lifetime::singleton
        : service_lifetime::transient;
 
    // -------------------------------------------------------------------------
    // Register IDicomStorage
    // -------------------------------------------------------------------------
    {
        auto storage_path = config.storage_path;
        if (storage_path.empty()) {
            storage_path = std::filesystem::temp_directory_path() / "pacs_storage";
        }
 
        auto result = container.register_factory<IDicomStorage>(
            [path = storage_path](IServiceContainer&) -> std::shared_ptr<IDicomStorage> {
                storage::file_storage_config storage_config;
                storage_config.root_path = path;
                storage_config.create_directories = true;
                return std::make_shared<storage::file_storage>(storage_config);
            },
            lifetime
        );
 
        if (result.is_err()) {
            return result;
        }
    }
 
    // -------------------------------------------------------------------------
    // Register IDicomNetwork
    // -------------------------------------------------------------------------
    if (config.enable_network) {
        auto result = container.register_factory<IDicomNetwork>(
            [](IServiceContainer&) -> std::shared_ptr<IDicomNetwork> {
                return std::make_shared<DicomNetworkService>();
            },
            lifetime
        );
 
        if (result.is_err()) {
            return result;
        }
    }
 
    // -------------------------------------------------------------------------
    // Register ILogger
    // -------------------------------------------------------------------------
    if (config.enable_logger) {
        auto result = container.register_factory<ILogger>(
            [](IServiceContainer&) -> std::shared_ptr<ILogger> {
                return std::make_shared<LoggerService>();
            },
            lifetime
        );
 
        if (result.is_err()) {
            return result;
        }
    }
 
    return kcenon::common::VoidResult::ok({});
}

register_storage()

template<typename TStorage >
requires std::derived_from<TStorage, IDicomStorage>

kcenon::common::VoidResult kcenon::pacs::di::register_storage ( kcenon::common::di::IServiceContainer & container, std::function< std::shared_ptr< TStorage >(kcenon::common::di::IServiceContainer &)> factory, kcenon::common::di::service_lifetime lifetime = kcenon::common::di::service_lifetime::singleton )

inlinenodiscard

Register storage service with custom implementation.

Template Parameters

TStorage

Storage implementation type (must derive from IDicomStorage)

Parameters

container	The service container
factory	Factory function for creating storage instances
lifetime	Service lifetime (default: singleton)

Returns

VoidResult indicating success or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 174 of file service_registration.h.

                                                                                       {
 
    return container.register_factory<IDicomStorage>(
        [f = std::move(factory)](kcenon::common::di::IServiceContainer& c) -> std::shared_ptr<IDicomStorage> {
            return f(c);
        },
        lifetime
    );
}

register_storage_instance()

kcenon::common::VoidResult kcenon::pacs::di::register_storage_instance ( kcenon::common::di::IServiceContainer & container, std::shared_ptr< IDicomStorage > instance )

inlinenodiscard

Register storage service with pre-created instance.

Parameters

container	The service container
instance	The storage instance to register

Returns

VoidResult indicating success or error

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/service_registration.h.

Definition at line 194 of file service_registration.h.

                                           {
 
    return container.register_instance<IDicomStorage>(std::move(instance));
}