RegisteredServices.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 "solinject/Defines.hpp"
#include "IService.hpp"
#include "IServiceTyped.hpp"
#include "SingletonService.hpp"
#include "TransientService.hpp"
#include "SharedService.hpp"
#include "ScopedService.hpp"
#include "solinject/exceptions/ServiceNotRegisteredException.hpp"
#include "solinject/Utils.hpp"
 
namespace sol::di::impl
{
    class RegisteredServices
    {
    public:
        template <class T>
        using Factory = typename IServiceTyped<T>::Factory;
 
        template <class T>
        using ServicePtr = typename IServiceTyped<T>::ServicePtr;
 
        using DIServicePtr = std::shared_ptr<IService>;
 
        using RegisteredServicesMap = std::map<std::type_index, std::vector<DIServicePtr>>;
 
        RegisteredServices() {}
 
        RegisteredServices(RegisteredServicesMap services) :
            m_RegisteredServices(std::move(services))
        {
        }
 
        RegisteredServices(const RegisteredServices& other) :
            m_RegisteredServices(other.m_RegisteredServices)
        {
        }
 
        RegisteredServices(RegisteredServices&& other) : RegisteredServices()
        {
            swap(*this, other);
        }
 
        RegisteredServices& operator=(RegisteredServices other)
        {
            swap(*this, other);
            return *this;
        }
 
        RegisteredServices& operator=(RegisteredServices&& other)
        {
            swap(*this, other);
            return *this;
        }
 
        friend void swap(RegisteredServices& a, RegisteredServices& b)
        {
            using std::swap;
 
            swap(a.m_RegisteredServices, b.m_RegisteredServices);
        }
 
        void Merge(RegisteredServices other)
        {
            for (auto& pair : other.m_RegisteredServices)
            {
                auto& source = pair.second;
                auto& destination = m_RegisteredServices[pair.first];
 
                impl::ConcatenateVectors(destination, std::move(source));
            }
        }
 
        template<class T>
        void RegisterSingletonService(Factory<T> factory)
        {
            RegisterServiceInternal<T, SingletonService<T>>(factory);
        }
 
        template<class T>
        void RegisterSingletonService(ServicePtr<T> instance)
        {
            RegisterServiceInternal<T, SingletonService<T>>(instance);
        }
 
        template<class T>
        void RegisterTransientService(Factory<T> factory)
        {
            RegisterServiceInternal<T, TransientService<T>>(factory);
        }
 
        template<class T>
        void RegisterSharedService(Factory<T> factory)
        {
            RegisterServiceInternal<T, SharedService<T>>(factory);
        }
 
        void RegisterService(std::type_index type, DIServicePtr diService)
        {
            RegisterServiceInternal(type, diService);
        }
 
        template<class T>
        ServicePtr<T> GetRequiredService(const Container& container) const
        {
            return GetServiceInternal<T, false>(container);
        }
 
        template <class T>
        ServicePtr<T> GetService(const Container& container) const
        {
            return GetServiceInternal<T, true>(container);
        }
 
        template <class T>
        std::vector<ServicePtr<T>> GetServices(const Container& container) const
        {
            using namespace std::string_literals;
 
            auto serviceIt = m_RegisteredServices.find(std::type_index(typeid(T)));
 
            if (serviceIt == m_RegisteredServices.end())
                return std::vector<ServicePtr<T>>();
 
            auto& services = serviceIt->second;
 
            std::vector<ServicePtr<T>> result;
            result.reserve(services.size());
 
            std::transform(
                services.begin(),
                services.end(),
                std::back_inserter(result),
                [this, &container](auto& diService)
                {
                    return GetServiceInstance<T>(diService, container);
                }
            );
 
            return result;
        }
    private:
        RegisteredServicesMap m_RegisteredServices;
 
        void RegisterServiceInternal(std::type_index type, DIServicePtr diService)
        {
            m_RegisteredServices[type].push_back(diService);
        }
 
        template <class TService, class TDIService>
        void RegisterServiceInternal(Factory<TService> factory)
        {
            RegisterServiceInternal(
                std::type_index(typeid(TService)),
                std::make_shared<TDIService>(factory)
            );
        }
 
        template <class TService, class TDIService>
        void RegisterServiceInternal(ServicePtr<TService> instance)
        {
            solinject_req_assert(instance != nullptr);
 
            m_RegisteredServices[std::type_index(typeid(TService))].push_back(std::make_shared<TDIService>(instance));
        }
 
        template <class T>
        ServicePtr<T> GetServiceInstance(const DIServicePtr& diServicePtr, const Container& container) const
        {
            solinject_req_assert(diServicePtr != nullptr);
 
            auto castedDiServicePtr = std::dynamic_pointer_cast<IServiceTyped<T>>(diServicePtr);
 
            solinject_req_assert(castedDiServicePtr != nullptr && "The service is resolvable as T");
 
            return castedDiServicePtr->GetService(container);
        }
 
        template <class T, bool nothrow>
        ServicePtr<T> GetServiceInternal(const Container& container) const
        {
            using namespace std::string_literals;
 
            auto serviceIt = m_RegisteredServices.find(std::type_index(typeid(T)));
 
            bool serviceFound =
                serviceIt != m_RegisteredServices.end() &&
                !serviceIt->second.empty();
 
            if constexpr (!nothrow)
                solinject_assert(serviceFound);
 
            if (!serviceFound)
                if constexpr (nothrow)
                    return nullptr;
                else
                    throw exc::ServiceNotRegisteredException(typeid(T));
 
            auto& services = serviceIt->second;
 
            return GetServiceInstance<T>(*services.rbegin(), container);
        }
    };
}