ServiceLocator.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/utils/DiagnosticCounter.h"
#include "catapult/exceptions.h"
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace catapult { namespace crypto { class KeyPair; } }
 
namespace catapult { namespace extensions {
 
    class ServiceLocator {
    public:
        static constexpr uint64_t Sentinel_Counter_Value = static_cast<uint64_t>(-1);
 
    public:
        explicit ServiceLocator(const crypto::KeyPair& keyPair) : m_keyPair(keyPair)
        {}
 
        ~ServiceLocator() {
            CATAPULT_LOG(info) << "destroying " << m_rootedServices.size() << " rooted services";
 
            // destroy rooted services in reverse order of registration
            auto i = 1u;
            while (!m_rootedServices.empty()) {
                CATAPULT_LOG(debug) << i << ": destroying rooted service " << m_rootedServices.back().first;
                m_rootedServices.pop_back();
                ++i;
            }
        }
 
    public:
        const crypto::KeyPair& keyPair() const {
            return m_keyPair;
        }
 
        const std::vector<utils::DiagnosticCounter>& counters() const {
            return m_counters;
        }
 
        size_t numServices() const {
            return m_services.size();
        }
 
        template<typename TService>
        std::shared_ptr<TService> service(const std::string& serviceName) const {
            std::shared_ptr<TService> pService;
            if (!tryGetService(serviceName, pService))
                CATAPULT_THROW_INVALID_ARGUMENT_1("requested service is not registered", serviceName);
 
            return pService;
        }
 
    public:
        void registerService(const std::string& serviceName, const std::shared_ptr<void>& pService) {
            if (!m_services.emplace(serviceName, pService).second)
                CATAPULT_THROW_INVALID_ARGUMENT_1("service is already registered", serviceName);
        }
 
        void registerRootedService(const std::string& serviceName, const std::shared_ptr<void>& pService) {
            registerService(serviceName, pService);
            m_rootedServices.emplace_back(serviceName, pService);
        }
 
        template<typename TService, typename TSupplier>
        void registerServiceCounter(const std::string& serviceName, const std::string& counterName, TSupplier supplier) {
            m_counters.emplace_back(utils::DiagnosticCounterId(counterName), [this, serviceName, supplier]() {
                std::shared_ptr<TService> pService;
                this->tryGetService(serviceName, pService);
                return pService ? supplier(*pService) : Sentinel_Counter_Value;
            });
        }
 
    private:
        template<typename TService>
        bool tryGetService(const std::string& serviceName, std::shared_ptr<TService>& pService) const {
            auto iter = m_services.find(serviceName);
            if (m_services.cend() == iter)
                return false;
 
            auto pVoidService = iter->second.lock();
            pService = std::shared_ptr<TService>(pVoidService, reinterpret_cast<TService*>(pVoidService.get()));
            return true;
        }
 
    private:
        const crypto::KeyPair& m_keyPair;
        std::vector<utils::DiagnosticCounter> m_counters;
        std::unordered_map<std::string, std::weak_ptr<void>> m_services;
        std::vector<std::pair<std::string, std::shared_ptr<void>>> m_rootedServices;
    };
}}