SubscriptionManager.h

Go to the documentation of this file.

 
#pragma once
#include "NodeSubscriber.h"
#include "StateChangeSubscriber.h"
#include "TransactionStatusSubscriber.h"
#include "catapult/cache_tx/MemoryPtCache.h"
#include "catapult/cache_tx/MemoryUtCache.h"
#include "catapult/cache_tx/PtChangeSubscriber.h"
#include "catapult/cache_tx/UtChangeSubscriber.h"
#include "catapult/io/BlockChangeSubscriber.h"
#include "catapult/io/FileBlockStorage.h"
#include "catapult/utils/Casting.h"
 
namespace catapult { namespace config { class CatapultConfiguration; } }
 
namespace catapult { namespace subscribers {
 
    class SubscriptionManager {
    public:
        explicit SubscriptionManager(const config::CatapultConfiguration& config);
 
    public:
        io::BlockStorage& fileStorage();
 
    public:
        void addBlockChangeSubscriber(std::unique_ptr<io::BlockChangeSubscriber>&& pSubscriber);
 
        void addUtChangeSubscriber(std::unique_ptr<cache::UtChangeSubscriber>&& pSubscriber);
 
        void addPtChangeSubscriber(std::unique_ptr<cache::PtChangeSubscriber>&& pSubscriber);
 
        void addTransactionStatusSubscriber(std::unique_ptr<TransactionStatusSubscriber>&& pSubscriber);
 
        void addStateChangeSubscriber(std::unique_ptr<StateChangeSubscriber>&& pSubscriber);
 
        void addNodeSubscriber(std::unique_ptr<NodeSubscriber>&& pSubscriber);
 
    public:
        std::unique_ptr<io::BlockChangeSubscriber> createBlockChangeSubscriber();
 
        std::unique_ptr<cache::UtChangeSubscriber> createUtChangeSubscriber();
 
        std::unique_ptr<cache::PtChangeSubscriber> createPtChangeSubscriber();
 
        std::unique_ptr<TransactionStatusSubscriber> createTransactionStatusSubscriber();
 
        std::unique_ptr<StateChangeSubscriber> createStateChangeSubscriber();
 
        std::unique_ptr<NodeSubscriber> createNodeSubscriber();
 
    public:
        std::unique_ptr<io::BlockStorage> createBlockStorage(io::BlockChangeSubscriber*& pSubscriber);
 
        std::unique_ptr<cache::MemoryUtCacheProxy> createUtCache(const cache::MemoryCacheOptions& options);
 
        std::unique_ptr<cache::MemoryPtCacheProxy> createPtCache(const cache::MemoryCacheOptions& options);
 
    private:
        enum class SubscriberType : uint32_t { BlockChange, UtChange, PtChange, TransactionStatus, StateChange, Node, Count };
 
    private:
        void requireUnused(SubscriberType subscriberType) const;
 
        void markUsed(SubscriberType subscriberType);
 
    private:
        const config::CatapultConfiguration& m_config;
        std::unique_ptr<io::FileBlockStorage> m_pStorage;
        std::array<bool, utils::to_underlying_type(SubscriberType::Count)> m_subscriberUsedFlags;
 
        std::vector<std::unique_ptr<io::BlockChangeSubscriber>> m_blockChangeSubscribers;
        std::vector<std::unique_ptr<cache::UtChangeSubscriber>> m_utChangeSubscribers;
        std::vector<std::unique_ptr<cache::PtChangeSubscriber>> m_ptChangeSubscribers;
        std::vector<std::unique_ptr<TransactionStatusSubscriber>> m_transactionStatusSubscribers;
        std::vector<std::unique_ptr<StateChangeSubscriber>> m_stateChangeSubscribers;
        std::vector<std::unique_ptr<NodeSubscriber>> m_nodeSubscribers;
    };
}}