dip.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <type_traits>
#include <cassert>
#include <functional>
#include <vector>
 
// #include <iostream> // For testing
 
namespace dip
{
    template <class Service>
    struct Injector
    {
        typedef std::function<Service *()> AcquireFunction;
 
        typedef std::function<void(Service *)> ReleaseFunction;
 
        AcquireFunction acquire;
 
        ReleaseFunction release;
    };
 
    template <class Service>
    struct instance
    {
        static_assert(
            std::is_abstract<Service>::value,
            "Only abstract classes are injectable");
        static_assert(
            std::has_virtual_destructor<Service>::value,
            "An injectable service must declare a virtual destructor");
 
        typedef Service *service_type;
 
        typedef const Service *const_service_type;
 
        instance()
        {
            assert(_injector.acquire && "Missing dependency injection");
            _instance = _injector.acquire();
            assert(_instance && "An injector retrieved a null provider");
        }
 
        ~instance() noexcept
        {
            if (_injector.release)
                _injector.release(_instance);
        }
 
        [[nodiscard]]
        service_type operator->() const noexcept
        {
            return _instance;
        }
 
        [[nodiscard]]
        Service &operator*() const noexcept
        {
            return *_instance;
        }
 
        instance(const instance &) = delete;
        instance(instance &&) = delete;
        instance &operator=(const instance &) = delete;
        instance &operator=(instance &&) = delete;
 
        static void inject(const Injector<Service> &injector) noexcept
        {
            assert(
                (_injector.acquire == nullptr) &&
                (_injector.release == nullptr) &&
                "Dependency already injected");
            assert(injector.acquire && "Invalid injector");
            _injector = injector;
        }
 
        template <class Provider, typename... _Args>
        static void inject_singleton(_Args &&...__args)
        {
            static_assert(
                std::is_base_of<Service, Provider>::value,
                "Provider does not implement Service");
            assert(
                (_injector.acquire == nullptr) &&
                (_injector.release == nullptr) &&
                "Dependency already injected");
            _injector.release = nullptr;
            _injector.acquire = [... args = std::forward<_Args>(__args)]() -> Service *
            {
                static Provider p(args...);
                return &p;
            };
        }
 
        template <class Provider, typename... _Args>
        static void inject_thread_singleton(_Args &&...__args)
        {
            static_assert(
                std::is_base_of<Service, Provider>::value,
                "Provider does not implement Service");
            assert(
                (_injector.acquire == nullptr) &&
                (_injector.release == nullptr) &&
                "Dependency already injected");
            _injector.release = nullptr;
            _injector.acquire = [... args = std::forward<_Args>(__args)]() -> Service *
            {
                static thread_local Provider p(args...);
                return &p;
            };
        }
 
        template <class Provider, typename... _Args>
        static void inject_transient(_Args &&...__args)
        {
            static_assert(
                std::is_base_of<Service, Provider>::value,
                "Provider does not implement Service");
            assert(
                (_injector.acquire == nullptr) &&
                (_injector.release == nullptr) &&
                "Dependency already injected");
            _injector.acquire =
                [... args = std::forward<_Args>(__args)]() -> Service *
            {
                return new Provider(args...);
            };
            _injector.release = [](Service *provider) -> void
            {
                delete provider;
            };
        }
 
        static void clear_injection() noexcept
        {
            _injector.acquire = nullptr;
            _injector.release = nullptr;
        }
 
    private:
        service_type _instance = nullptr;
        inline static Injector<Service> _injector;
    }; // struct instance
 
    template <class Service>
    inline void inject(const Injector<Service> &injector)
    {
        instance<Service>::inject(injector);
    }
 
    template <class Service, class Provider, typename... _Args>
    inline void inject_transient(_Args &&...args)
    {
        instance<Service>::template inject_transient<Provider>(
            std::forward<_Args>(args)...);
    }
 
    template <class Service, class Provider, typename... _Args>
    inline void inject_singleton(_Args &&...args)
    {
        instance<Service>::template inject_singleton<Provider>(
            std::forward<_Args>(args)...);
    }
 
    template <class Service, class Provider, typename... _Args>
    inline void inject_thread_singleton(_Args &&...args)
    {
        instance<Service>::template inject_thread_singleton<Provider>(
            std::forward<_Args>(args)...);
    }
 
    template <class Service>
    struct instance_set
    {
        static_assert(
            std::is_abstract<Service>::value,
            "Only abstract classes are injectable");
        static_assert(
            std::has_virtual_destructor<Service>::value,
            "An injectable service must declare a virtual destructor");
 
        typedef Service *service_type;
        typedef const Service *const_service_type;
        using iterator = std::vector<service_type>::iterator;
        using const_iterator = std::vector<service_type>::const_iterator;
        using reverse_iterator = std::vector<service_type>::reverse_iterator;
        using const_reverse_iterator =
            std::vector<service_type>::const_reverse_iterator;
 
        instance_set()
        {
            assert(!_injectors.empty() && "No dependency injections");
            for (auto injector : _injectors)
            {
                assert(injector.acquire && "Missing dependency injection");
                auto instance = injector.acquire();
                assert(instance && "An injector retrieved a null provider");
                _instances.push_back(instance);
            }
        }
 
        ~instance_set() noexcept
        {
            for (std::size_t i = 0; i < _injectors.size(); i++)
                if (_injectors[i].release)
                    _injectors[i].release(_instances.at(i));
        }
 
        instance_set(const instance_set &) = delete;
        instance_set(instance_set &&) = delete;
        instance_set &operator=(const instance_set &) = delete;
        instance_set &operator=(instance_set &&) = delete;
 
        constexpr std::size_t size() const noexcept
        {
            return _instances.size();
        }
 
        service_type operator[](std::size_t index)
        {
            return _instances[index];
        }
 
        const_service_type operator[](std::size_t index) const
        {
            return _instances[index];
        }
 
        service_type at(std::size_t index)
        {
            return _instances.at(index);
        }
 
        const_service_type at(std::size_t index) const
        {
            return _instances.at(index);
        }
 
        iterator begin() { return _instances.begin(); }
        const_iterator begin() const { return _instances.begin(); }
        const_iterator cbegin() const noexcept { return _instances.begin(); }
        iterator end() { return _instances.end(); }
        const_iterator end() const { return _instances.end(); }
        const_iterator cend() const noexcept { return _instances.cend(); }
        reverse_iterator rbegin() { return _instances.rbegin(); }
        const_reverse_iterator rbegin() const { return _instances.rbegin(); }
        const_reverse_iterator crbegin() const noexcept
        {
            return _instances.crbegin();
        }
        reverse_iterator rend() { return _instances.rend(); }
        const_reverse_iterator rend() const { return _instances.rend(); }
        const_reverse_iterator crend() const noexcept
        {
            return _instances.crend();
        }
 
        static void add(const Injector<Service> &injector) noexcept
        {
            assert(injector.acquire && "Invalid injector");
            _injectors.push_back(injector);
        }
 
        template <class Provider, typename... _Args>
        static void add_singleton(_Args &&...__args)
        {
            static_assert(
                std::is_base_of<Service, Provider>::value,
                "Provider does not implement Service");
            Injector<Service> injector{
                .acquire =
                    [... args = std::forward<_Args>(__args)]() -> Service *
                {
                    static Provider p(args...);
                    return &p;
                }};
            add(injector);
        }
 
        template <class Provider, typename... _Args>
        static void add_thread_singleton(_Args &&...__args)
        {
            static_assert(
                std::is_base_of<Service, Provider>::value,
                "Provider does not implement Service");
            Injector<Service> injector{
                .acquire =
                    [... args = std::forward<_Args>(__args)]() -> Service *
                {
                    static thread_local Provider p(args...);
                    return &p;
                }};
            add(injector);
        }
 
        template <class Provider, typename... _Args>
        static void add_transient(_Args &&...__args)
        {
            static_assert(
                std::is_base_of<Service, Provider>::value,
                "Provider does not implement Service");
            Injector<Service> injector{
                .acquire =
                    [... args = std::forward<_Args>(__args)]() -> Service *
                {
                    static thread_local Provider p(args...);
                    return &p;
                },
                .release = [](Service *provider) -> void
                {
                    delete provider;
                }};
            add(injector);
        }
 
        static void clear_injections() noexcept
        {
            _injectors.clear();
        }
 
    private:
        std::vector<service_type> _instances;
        inline static std::vector<Injector<Service>> _injectors;
    }; // struct instances
 
    template <class Service>
    inline void add(const Injector<Service> &injector)
    {
        instance_set<Service>::add(injector);
    }
 
    template <class Service, class Provider, typename... _Args>
    inline void add_transient(_Args &&...args)
    {
        instance_set<Service>::template add_transient<Provider>(
            std::forward<_Args>(args)...);
    }
 
    template <class Service, class Provider, typename... _Args>
    inline void add_singleton(_Args &&...args)
    {
        instance_set<Service>::template add_singleton<Provider>(
            std::forward<_Args>(args)...);
    }
 
    template <class Service, class Provider, typename... _Args>
    inline void add_thread_singleton(_Args &&...args)
    {
        instance_set<Service>::template add_thread_singleton<Provider>(
            std::forward<_Args>(args)...);
    }
}; // namespace dip