Container.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
 
/*
 * solinject - C++ Dependency Injection header-only library
 * Copyright (C) 2022  SemperSolus0x3d
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
#include <map>
#include <vector>
#include <algorithm>
#include <memory>
#include <typeinfo>
#include <typeindex>
#include <mutex>
 
#include "Defines.hpp"
#include "IService.hpp"
#include "IServiceTyped.hpp"
#include "RegisteredServices.hpp"
#include "ScopedServiceBuilders.hpp"
#include "Utils.hpp"
 
namespace sol::di
{
    namespace impl { class IService; }
 
    class Container
    {
    public:
        template <class T>
        using Factory = typename impl::IServiceTyped<T>::Factory;
 
        template <class T>
        using ServicePtr = typename impl::IServiceTyped<T>::ServicePtr;
 
        using DIServicePtr = impl::RegisteredServices::DIServicePtr;
 
        using ScopedServiceBuilderPtr = impl::ScopedServiceBuilders::ScopedServiceBuilderPtr;
 
        Container() : m_Mutex(std::make_shared<Mutex>()) {}
 
        Container(const Container& other) = delete;
 
        Container(Container&& other) noexcept : Container()
        {
            swap(*this, other);
        }
 
        Container& operator=(const Container& other) = delete;
 
        Container& operator=(Container&& other) noexcept
        {
            swap(*this, other);
            return *this;
        }
 
        friend void swap(Container& a, Container& b) noexcept
        {
            using std::swap;
 
            if (&a == &b)
                return;
 
            ScopedLock lock(*a.m_Mutex, *b.m_Mutex);
 
            swap(a.m_RegisteredServices, b.m_RegisteredServices);
            swap(a.m_ScopedServiceBuilders, b.m_ScopedServiceBuilders);
            swap(a.m_Mutex, b.m_Mutex);
        }
 
        Container CreateScope() const
        {
            using namespace impl;
 
            auto lock = LockMutex();
 
            RegisteredServices diServices = m_RegisteredServices;
            diServices.Merge(m_ScopedServiceBuilders.BuildDIServices());
 
            return Container(std::move(diServices), m_Mutex);
        }
 
        bool IsScope() { return m_IsScope; }
 
        template<class T>
        void RegisterSingletonService(Factory<T> factory)
        {
            auto lock = LockMutex();
            m_RegisteredServices.template RegisterSingletonService<T>(factory);
        }
 
        template<class T>
        void RegisterSingletonService(ServicePtr<T> instance)
        {
            solinject_assert(instance != nullptr);
 
            if (instance == nullptr)
                throw std::invalid_argument("instance was nullptr");
 
            auto lock = LockMutex();
            m_RegisteredServices.template RegisterSingletonService<T>(instance);
        }
 
        template<class T>
        void RegisterTransientService(Factory<T> factory)
        {
            auto lock = LockMutex();
            m_RegisteredServices.template RegisterTransientService<T>(factory);
        }
 
        template<class T>
        void RegisterSharedService(Factory<T> factory)
        {
            auto lock = LockMutex();
            m_RegisteredServices.template RegisterSharedService<T>(factory);
        }
 
        template<class T>
        void RegisterScopedService(Factory<T> factory)
        {
            auto lock = LockMutex();
            m_ScopedServiceBuilders.template RegisterScopedService<T>(factory);
        }
 
        void RegisterService(std::type_index type, DIServicePtr diService)
        {
            m_RegisteredServices.RegisterService(type, diService);
        }
 
        void RegisterScopedServiceBuilder(std::type_index type, ScopedServiceBuilderPtr serviceBuilder)
        {
            m_ScopedServiceBuilders.RegisterScopedService(type, serviceBuilder);
        }
 
        template<class T>
        ServicePtr<T> GetRequiredService() const
        {
            auto lock = LockMutex();
            return m_RegisteredServices.template GetRequiredService<T>(*this);
        }
 
        template <class T>
        ServicePtr<T> GetService() const
        {
            auto lock = LockMutex();
            return m_RegisteredServices.template GetService<T>(*this);
        }
 
        template <class T>
        std::vector<ServicePtr<T>> GetServices() const
        {
            auto lock = LockMutex();
            return m_RegisteredServices.template GetServices<T>(*this);
        }
 
    private:
        #ifndef SOLINJECT_NOTHREADSAFE
            using Mutex = std::recursive_mutex;
            using Lock = std::lock_guard<Mutex>;
            using ScopedLock = std::scoped_lock<Mutex, Mutex>;
        #else
            using Mutex = impl::Empty;
            using Lock = impl::Empty;
            using ScopedLock = impl::Empty;
        #endif
 
        using MutexPtr = std::shared_ptr<Mutex>;
 
        Container(
            impl::RegisteredServices&& services,
            MutexPtr mutexPtr
        ) :
            m_RegisteredServices(std::move(services)),
            m_Mutex(mutexPtr),
            m_IsScope(true)
        {
            solinject_req_assert(mutexPtr != nullptr);
        }
 
        impl::RegisteredServices m_RegisteredServices;
 
        impl::ScopedServiceBuilders m_ScopedServiceBuilders;
 
        MutexPtr m_Mutex;
 
        bool m_IsScope = false;
 
        Lock LockMutex() const
        {
            return Lock(*m_Mutex);
        }
    }; // class Container
} // sol::di