di.h

 
 
#pragma once
 
#if !defined(__cpp_concepts)
#error "This library requires concepts"
#endif
 
#include <typeindex>
#include <vector>
#include <memory>
#include <map>
#include <functional>
#include <string>
#include <thread>
 
namespace ghassanpl::di
{
    template <typename T, typename... OTHERS>
    constexpr inline bool is_same_as_any_v = std::disjunction_v<std::is_same<std::decay_t<OTHERS>, std::decay_t<T>>...>;
 
    enum class Lifetime
    {
        Default,
        Transient,
        InstanceSingleton,
        WeakSingleton,
        ThreadSingleton,
    };
 
    struct DefaultImplementationStruct {};
    constexpr inline DefaultImplementationStruct DefaultImplementation;
 
 
    struct Container
    {
        Lifetime DefaultLifetime = Lifetime::Transient;
 
 
        template <typename INTERFACE, typename IMPLEMENTATION, typename... ARGS>
        void RegisterType(ARGS&&... args);
 
        template <typename INTERFACE>
        bool HasAnyImplementationsOf() const;
 
 
        template <typename INTERFACE>
        std::shared_ptr<INTERFACE> Resolve();
 
        template <typename INTERFACE>
        std::shared_ptr<INTERFACE> ResolveByName(std::string_view name);
 
        template <typename INTERFACE>
        std::vector<std::shared_ptr<INTERFACE>> ResolveAll();
 
 
        template <typename TYPE>
        std::shared_ptr<TYPE> Create();
 
        template <typename TYPE>
        std::unique_ptr<TYPE> CreateRaw();
 
        void DestroyAll()
        {
            mContainers.clear();
            mParentContainer = nullptr;
        }
 
        auto const& Containers() const { return mContainers; }
        auto const& DebugStore() const { return mDebugStore; }
 
    private:
 
        struct BaseInterfaceContainer
        {
            virtual ~BaseInterfaceContainer() noexcept = default;
            explicit BaseInterfaceContainer(Lifetime default_lifetime) : DefaultLifetime(default_lifetime) {}
            Lifetime DefaultLifetime = Lifetime::Default;
        };
 
        template <typename INTERFACE>
        struct InterfaceContainer;
 
        template <typename INTERFACE>
        struct ImplementationContainer;
 
        template <typename INTERFACE>
        InterfaceContainer<INTERFACE>& GetInterfaceContainer();
 
        template <typename INTERFACE, typename IMPLEMENTATION>
        ImplementationContainer<INTERFACE>* GetImplementationContainer();
 
        std::map<std::type_index, std::unique_ptr<BaseInterfaceContainer>> mContainers;
        std::vector<std::type_index> mResolutionStack;
        std::vector<std::pair<std::shared_ptr<void>, std::function<void(Container&, std::shared_ptr<void>)>>> mCreationsToReport;
        Container* mParentContainer = nullptr; 
 
        std::map<void const*, std::pair<std::type_index, std::weak_ptr<void>>> mDebugStore;
 
        template <typename INSTANCE>
        void ReportCreation(std::shared_ptr<INSTANCE> const& obj, std::function<void(Container&, std::shared_ptr<void>)> func);
 
        void ReportAwaitingCreations()
        {
            auto creations = std::exchange(mCreationsToReport, {}); 
            for (auto&& [ptr, callback] : creations)
                callback(*this, std::move(ptr));
        }
 
        template <typename INTERFACE, typename T>
        std::shared_ptr<INTERFACE> Instantiate(T& factory);
    };
}
 
#include "di_impl.h"