service_container_interface.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 <any>
#include <concepts>
#include <functional>
#include <memory>
#include <string>
#include <typeindex>
#include <vector>
 
#include "../patterns/result.h"
#include "../concepts/service.h"
#include "../error/error_codes.h"
 
namespace kcenon::common {
namespace di {
 
enum class service_lifetime {
    singleton,
 
    transient,
 
    scoped
};
 
inline const char* to_string(service_lifetime lifetime) {
    switch (lifetime) {
        case service_lifetime::singleton: return "singleton";
        case service_lifetime::transient: return "transient";
        case service_lifetime::scoped: return "scoped";
        default: return "unknown";
    }
}
 
struct service_descriptor {
    std::type_index interface_type;
 
    std::string interface_name;
 
    service_lifetime lifetime;
 
    bool is_instantiated = false;
 
    std::string description;
 
    service_descriptor(std::type_index type, std::string name, service_lifetime lt)
        : interface_type(type)
        , interface_name(std::move(name))
        , lifetime(lt) {}
};
 
// Forward declaration
class IServiceScope;
 
class IServiceContainer {
public:
    virtual ~IServiceContainer() = default;
 
    // ===== Service Registration (Type-safe templates) =====
 
    template<concepts::ServiceInterface TInterface,
             concepts::ServiceImplementation<TInterface> TImpl>
    VoidResult register_type(service_lifetime lifetime = service_lifetime::singleton) {
 
        return register_factory_internal(
            std::type_index(typeid(TInterface)),
            typeid(TInterface).name(),
            [](IServiceContainer&) -> std::shared_ptr<void> {
                return std::make_shared<TImpl>();
            },
            lifetime
        );
    }
 
    template<typename TInterface>
    VoidResult register_instance(std::shared_ptr<TInterface> instance) {
        if (!instance) {
            return make_error<std::monostate>(
                error_codes::INVALID_ARGUMENT,
                "Cannot register null instance",
                "di::IServiceContainer"
            );
        }
 
        return register_instance_internal(
            std::type_index(typeid(TInterface)),
            typeid(TInterface).name(),
            std::static_pointer_cast<void>(instance)
        );
    }
 
    template<concepts::ServiceInterface TInterface,
             concepts::ServiceFactory<TInterface> TFactory>
    VoidResult register_factory(TFactory&& factory,
                                service_lifetime lifetime = service_lifetime::singleton) {
        return register_factory_internal(
            std::type_index(typeid(TInterface)),
            typeid(TInterface).name(),
            [f = std::forward<TFactory>(factory)](IServiceContainer& c) -> std::shared_ptr<void> {
                return std::static_pointer_cast<void>(f(c));
            },
            lifetime
        );
    }
 
    template<concepts::ServiceInterface TInterface,
             concepts::SimpleServiceFactory<TInterface> TFactory>
    VoidResult register_simple_factory(TFactory&& factory,
                                       service_lifetime lifetime = service_lifetime::singleton) {
        return register_factory_internal(
            std::type_index(typeid(TInterface)),
            typeid(TInterface).name(),
            [f = std::forward<TFactory>(factory)](IServiceContainer&) -> std::shared_ptr<void> {
                return std::static_pointer_cast<void>(f());
            },
            lifetime
        );
    }
 
    // ===== Service Resolution =====
 
    template<typename TInterface>
    Result<std::shared_ptr<TInterface>> resolve() {
        auto result = resolve_internal(std::type_index(typeid(TInterface)));
 
        if (result.is_err()) {
            return make_error<std::shared_ptr<TInterface>>(result.error());
        }
 
        return Result<std::shared_ptr<TInterface>>::ok(
            std::static_pointer_cast<TInterface>(result.value())
        );
    }
 
    template<typename TInterface>
    std::shared_ptr<TInterface> resolve_or_null() {
        auto result = resolve<TInterface>();
        if (result.is_ok()) {
            return result.value();
        }
        return nullptr;
    }
 
    // ===== Scope Management =====
 
    virtual std::unique_ptr<IServiceScope> create_scope() = 0;
 
    // ===== Introspection =====
 
    template<typename TInterface>
    bool is_registered() const {
        return is_registered_internal(std::type_index(typeid(TInterface)));
    }
 
    virtual std::vector<service_descriptor> registered_services() const = 0;
 
    template<typename TInterface>
    VoidResult unregister() {
        return unregister_internal(std::type_index(typeid(TInterface)));
    }
 
    virtual VoidResult clear() = 0;
 
protected:
    // Internal type-erased methods for implementation
 
    virtual 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) = 0;
 
    virtual VoidResult register_instance_internal(
        std::type_index interface_type,
        const std::string& type_name,
        std::shared_ptr<void> instance) = 0;
 
    virtual Result<std::shared_ptr<void>> resolve_internal(
        std::type_index interface_type) = 0;
 
    virtual bool is_registered_internal(std::type_index interface_type) const = 0;
 
    virtual VoidResult unregister_internal(std::type_index interface_type) = 0;
};
 
class IServiceScope : public IServiceContainer {
public:
    ~IServiceScope() override = default;
 
    virtual IServiceContainer& parent() = 0;
 
    virtual const IServiceContainer& parent() const = 0;
};
 
namespace di_error_codes {
    constexpr int service_not_registered = error::codes::common_errors::di_service_not_registered;
 
    constexpr int circular_dependency = error::codes::common_errors::di_circular_dependency;
 
    constexpr int already_registered = error::codes::common_errors::di_already_registered;
 
    constexpr int factory_error = error::codes::common_errors::di_factory_error;
 
    constexpr int invalid_lifetime = error::codes::common_errors::di_invalid_lifetime;
 
    constexpr int scoped_from_root = error::codes::common_errors::di_scoped_from_root;
}
 
} // namespace di
} // namespace kcenon::common