service_registration.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "service_interfaces.h"
 
#include <kcenon/pacs/storage/file_storage.h>
#include <kcenon/pacs/encoding/compression/codec_factory.h>
 
#include <kcenon/common/di/service_container.h>
 
#include <filesystem>
#include <memory>
 
namespace kcenon::pacs::di {
 
// =============================================================================
// Service Registration Configuration
// =============================================================================
 
struct registration_config {
    std::filesystem::path storage_path;
 
    bool enable_network = true;
 
    bool enable_codecs = true;
 
    bool enable_logger = true;
 
    bool use_singletons = true;
 
    registration_config() = default;
};
 
// =============================================================================
// Service Registration Functions
// =============================================================================
 
[[nodiscard]] inline kcenon::common::VoidResult register_services(
    kcenon::common::di::IServiceContainer& container,
    const registration_config& config = {}) {
 
    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({});
}
 
template<typename TStorage>
    requires std::derived_from<TStorage, IDicomStorage>
[[nodiscard]] inline 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) {
 
    return container.register_factory<IDicomStorage>(
        [f = std::move(factory)](kcenon::common::di::IServiceContainer& c) -> std::shared_ptr<IDicomStorage> {
            return f(c);
        },
        lifetime
    );
}
 
[[nodiscard]] inline kcenon::common::VoidResult register_storage_instance(
    kcenon::common::di::IServiceContainer& container,
    std::shared_ptr<IDicomStorage> instance) {
 
    return container.register_instance<IDicomStorage>(std::move(instance));
}
 
template<typename TNetwork>
    requires std::derived_from<TNetwork, IDicomNetwork>
[[nodiscard]] inline 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) {
 
    return container.register_factory<IDicomNetwork>(
        [f = std::move(factory)](kcenon::common::di::IServiceContainer& c) -> std::shared_ptr<IDicomNetwork> {
            return f(c);
        },
        lifetime
    );
}
 
[[nodiscard]] inline kcenon::common::VoidResult register_network_instance(
    kcenon::common::di::IServiceContainer& container,
    std::shared_ptr<IDicomNetwork> instance) {
 
    return container.register_instance<IDicomNetwork>(std::move(instance));
}
 
template<typename TLogger>
    requires std::derived_from<TLogger, ILogger>
[[nodiscard]] inline 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) {
 
    return container.register_factory<ILogger>(
        [f = std::move(factory)](kcenon::common::di::IServiceContainer& c) -> std::shared_ptr<ILogger> {
            return f(c);
        },
        lifetime
    );
}
 
[[nodiscard]] inline kcenon::common::VoidResult register_logger_instance(
    kcenon::common::di::IServiceContainer& container,
    std::shared_ptr<ILogger> instance) {
 
    return container.register_instance<ILogger>(std::move(instance));
}
 
// =============================================================================
// Convenience Functions
// =============================================================================
 
[[nodiscard]] inline std::shared_ptr<kcenon::common::di::service_container>
create_container(const registration_config& config = {}) {
    auto container = std::make_shared<kcenon::common::di::service_container>();
    auto result = register_services(*container, config);
    if (result.is_err()) {
        return nullptr;
    }
    return container;
}
 
}  // namespace kcenon::pacs::di