service_container.h

Go to the documentation of this file.

 
#pragma once
 
// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <mutex>
#include <functional>
 
namespace kcenon::thread {
 
class service_container {
public:
    enum class lifetime {
        singleton,  // Single instance shared across all requests
        transient   // New instance for each request
    };
 
    template<typename Interface, typename Implementation>
    void register_singleton(std::shared_ptr<Implementation> instance) {
        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};
    }
 
    template<typename Interface>
    void register_factory(std::function<std::shared_ptr<Interface>()> factory,
                         lifetime lt = lifetime::transient) {
        std::lock_guard<std::mutex> lock(mutex_);
        services_[std::type_index(typeid(Interface))] = 
            service_entry{lt, nullptr, 
                [factory]() -> std::shared_ptr<void> { 
                    return factory(); 
                }};
    }
 
    template<typename Interface, typename Implementation, typename... Args>
    void register_transient() {
        static_assert(std::is_base_of_v<Interface, Implementation>,
                      "Implementation must derive from Interface");
        
        register_factory<Interface>(
            []() { return std::make_shared<Implementation>(); },
            lifetime::transient);
    }
 
    template<typename Interface>
    std::shared_ptr<Interface> resolve() {
        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;
    }
 
    template<typename Interface>
    bool is_registered() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return services_.find(std::type_index(typeid(Interface))) != services_.end();
    }
 
    void clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        services_.clear();
    }
 
    static service_container& global() {
        static service_container instance;
        return instance;
    }
 
private:
    struct service_entry {
        lifetime lifetime_scope;
        mutable std::shared_ptr<void> instance;
        std::function<std::shared_ptr<void>()> factory;
    };
 
    mutable std::mutex mutex_;
    std::unordered_map<std::type_index, service_entry> services_;
};
 
template<typename Interface>
class scoped_service {
public:
    scoped_service(std::shared_ptr<Interface> service) {
        service_container::global().register_singleton<Interface>(service);
    }
 
    ~scoped_service() {
        // Note: In a real implementation, you might want to support unregistration
        // For now, services remain registered for the application lifetime
    }
};
 
} // namespace kcenon::thread