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>
#include "min-cpp-version/cpp20.h"
 
namespace ghassanpl::di
{
    
    enum class Lifetime
    {
        Default, 
        Transient, 
        InstanceSingleton, 
        WeakSingleton, 
        ThreadSingleton, 
    };
 
    struct DefaultImplementationStruct {};

    constexpr inline DefaultImplementationStruct DefaultImplementation;
 
    // TODO: Split into ContainerBuilder and Container (or [Dependency]Registry and [Dependency]Container)
    // Oooh, idea: Container container = Container(Registry1(), Registry2(), ...);

    struct Container
    {
        Lifetime DefaultLifetime = Lifetime::Transient;

        template <typename INTERFACE, typename IMPLEMENTATION, typename... PROPS>
        void RegisterType(PROPS&&... properties);

        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()
        {
            mDebugStore.clear();
            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;
            virtual bool HasAnyImplementations() const = 0;
        };
 
        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);
    };

    template <typename T>
    concept has_default_lifetime = requires { { T::DefaultLifetime } -> std::convertible_to<Lifetime>; };

}
 
 
#include "di_impl.h"