ServiceLocator.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CONSOLIX_SERVICE_LOCATOR_HPP_INCLUDED
#define _CONSOLIX_SERVICE_LOCATOR_HPP_INCLUDED

 
#if CONSOLIX_USE_LOGIT == 1
#include <logit.hpp>
#endif
 
#include "std_compat.hpp"
 
#include <unordered_map>
#include <functional>
#include <memory>
#include <typeindex>
#include <stdexcept>
#include <mutex>
 
namespace consolix {

    class ServiceLocator {
    public:

        static ServiceLocator& get_instance() {
            static ServiceLocator* instance = new ServiceLocator();
            return *instance;
        }

        template <typename T>
        void register_service(std::function<std::shared_ptr<T>()> creator) {
            std::shared_ptr<T> service = creator();
 
            std::unique_lock<compat::shared_mutex> lock(m_mutex);
            const auto type = std::type_index(typeid(T));
            if (m_services.find(type) != m_services.end()) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Service already registered: ", std::string(typeid(T).name()));
#               endif
                throw std::runtime_error("Service already registered: " + std::string(typeid(T).name()));
            }
            m_services[type] = std::move(service);
        }

        template <typename T>
        void register_service() {
            std::unique_lock<compat::shared_mutex> lock(m_mutex);
            const auto type = std::type_index(typeid(T));
            if (m_services.find(type) != m_services.end()) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Service already registered: ", std::string(typeid(T).name()));
#               endif
                throw std::runtime_error("Service already registered: " + std::string(typeid(T).name()));
            }
            m_services[type] = std::make_shared<T>();
        }

        template <typename T>
        T& get_service() {
            compat::shared_lock<compat::shared_mutex> lock(m_mutex);
            const auto type = std::type_index(typeid(T));
            auto it = m_services.find(type);
            if (it == m_services.end()) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Service not registered: ", std::string(typeid(T).name()));
#               endif
                throw std::runtime_error("Service not registered: " + std::string(typeid(T).name()));
            }
            return *std::static_pointer_cast<T>(it->second);
        }

        template <typename T>
        bool has_service() {
            compat::shared_lock<compat::shared_mutex> lock(m_mutex);
            const auto type_id = std::type_index(typeid(T));
            return m_services.find(type_id) != m_services.end();
        }

        void clear_all() {
            std::unique_lock<compat::shared_mutex> lock(m_mutex);
            m_services.clear();
        }
 
    private:
        std::unordered_map<
            std::type_index,
            std::shared_ptr<void>> m_services; 
        compat::shared_mutex       m_mutex;    
 
        ServiceLocator() = default;
        ~ServiceLocator() = default;
 
        // Delete copy and move constructors and assignment operators.
        ServiceLocator(const ServiceLocator&) = delete;
        ServiceLocator& operator=(const ServiceLocator&) = delete;
        ServiceLocator(ServiceLocator&&) = delete;
        ServiceLocator& operator=(ServiceLocator&&) = delete;
    }; // ServiceLocator
 
} // namespace consolix
 
#endif // _CONSOLIX_SERVICE_LOCATOR_HPP_INCLUDED