PtBootstrapperService.h

Go to the documentation of this file.

 
#pragma once
#include "PtTypes.h"
#include "catapult/extensions/BasicServerHooks.h"
#include "catapult/extensions/ServiceRegistrar.h"
#include "catapult/handlers/HandlerTypes.h"
 
namespace catapult { namespace cache { class MemoryPtCacheProxy; } }
 
namespace catapult { namespace partialtransaction {
 
    // region PtServerHooks
 
    class PtServerHooks {
    public:
        void setCosignedTransactionInfosConsumer(const CosignedTransactionInfosConsumer& consumer) {
            extensions::SetOnce(m_cosignedTransactionInfosConsumer, consumer);
        }
 
        void setPtRangeConsumer(const handlers::TransactionRangeHandler& consumer) {
            extensions::SetOnce(m_ptRangeConsumer, consumer);
        }
 
        void setCosignatureRangeConsumer(const handlers::RangeHandler<model::DetachedCosignature>& consumer) {
            extensions::SetOnce(m_cosignatureRangeConsumer, consumer);
        }
 
    public:
        const auto& cosignedTransactionInfosConsumer() const {
            return extensions::Require(m_cosignedTransactionInfosConsumer);
        }
 
        const auto& ptRangeConsumer() const {
            return extensions::Require(m_ptRangeConsumer);
        }
 
        const auto& cosignatureRangeConsumer() const {
            return extensions::Require(m_cosignatureRangeConsumer);
        }
 
    private:
        CosignedTransactionInfosConsumer m_cosignedTransactionInfosConsumer;
        handlers::TransactionRangeHandler m_ptRangeConsumer;
        handlers::RangeHandler<model::DetachedCosignature> m_cosignatureRangeConsumer;
    };
 
    // endregion
 
    using PtCacheSupplier = supplier<std::unique_ptr<cache::MemoryPtCacheProxy>>;
 
    DECLARE_SERVICE_REGISTRAR(PtBootstrapper)(const PtCacheSupplier& ptCacheSupplier);
 
    cache::MemoryPtCacheProxy& GetMemoryPtCache(const extensions::ServiceLocator& locator);
 
    PtServerHooks& GetPtServerHooks(const extensions::ServiceLocator& locator);
}}