ServiceState.h

Go to the documentation of this file.

 
#pragma once
#include "ServerHooks.h"
#include "ServiceState.h"
#include "catapult/config/CatapultConfiguration.h"
#include "catapult/ionet/PacketHandlers.h"
#include "catapult/net/PacketIoPickerContainer.h"
#include "catapult/thread/Task.h"
 
namespace catapult {
    namespace cache {
        class CatapultCache;
        class MemoryUtCacheProxy;
    }
    namespace extensions { class LocalNodeChainScore; }
    namespace io { class BlockStorageCache; }
    namespace ionet { class NodeContainer; }
    namespace plugins { class PluginManager; }
    namespace state { struct CatapultState; }
    namespace subscribers {
        class NodeSubscriber;
        class StateChangeSubscriber;
        class TransactionStatusSubscriber;
    }
    namespace thread { class MultiServicePool; }
    namespace utils { class DiagnosticCounter; }
}
 
namespace catapult { namespace extensions {
 
    class ServiceState {
    public:
        ServiceState(
                const config::CatapultConfiguration& config,
                ionet::NodeContainer& nodes,
                cache::CatapultCache& cache,
                state::CatapultState& state,
                io::BlockStorageCache& storage,
                LocalNodeChainScore& score,
                cache::MemoryUtCacheProxy& utCache,
                const supplier<Timestamp>& timeSupplier,
                subscribers::TransactionStatusSubscriber& transactionStatusSubscriber,
                subscribers::StateChangeSubscriber& stateChangeSubscriber,
                subscribers::NodeSubscriber& nodeSubscriber,
                const std::vector<utils::DiagnosticCounter>& counters,
                const plugins::PluginManager& pluginManager,
                thread::MultiServicePool& pool)
                : m_config(config)
                , m_nodes(nodes)
                , m_cache(cache)
                , m_state(state)
                , m_storage(storage)
                , m_score(score)
                , m_utCache(utCache)
                , m_timeSupplier(timeSupplier)
                , m_transactionStatusSubscriber(transactionStatusSubscriber)
                , m_stateChangeSubscriber(stateChangeSubscriber)
                , m_nodeSubscriber(nodeSubscriber)
                , m_counters(counters)
                , m_pluginManager(pluginManager)
                , m_pool(pool)
                , m_packetHandlers(m_config.Node.MaxPacketDataSize.bytes32())
        {}
 
    public:
        const auto& config() const {
            return m_config;
        }
 
        auto& nodes() const {
            return m_nodes;
        }
 
        auto& cache() const {
            return m_cache;
        }
 
        auto& state() const {
            return m_state;
        }
 
        auto& storage() const {
            return m_storage;
        }
 
        auto& score() const {
            return m_score;
        }
 
        auto& utCache() const {
            return m_utCache;
        }
 
        auto timeSupplier() const {
            return m_timeSupplier;
        }
 
        auto& transactionStatusSubscriber() const {
            return m_transactionStatusSubscriber;
        }
 
        auto& stateChangeSubscriber() const {
            return m_stateChangeSubscriber;
        }
 
        auto& nodeSubscriber() const {
            return m_nodeSubscriber;
        }
 
        const auto& counters() const {
            return m_counters;
        }
 
        const auto& pluginManager() const {
            return m_pluginManager;
        }
 
        auto& pool() {
            return m_pool;
        }
 
        auto& tasks() {;
            return m_tasks;
        }
 
        auto& packetHandlers() {
            return m_packetHandlers;
        }
 
        const auto& hooks() const {
            return m_hooks;
        }
 
        auto& hooks() {
            return m_hooks;
        }
 
        auto& packetIoPickers() {
            return m_packetIoPickers;
        }
 
    private:
        // references
        const config::CatapultConfiguration& m_config;
        ionet::NodeContainer& m_nodes;
        cache::CatapultCache& m_cache;
        state::CatapultState& m_state;
        io::BlockStorageCache& m_storage;
        LocalNodeChainScore& m_score;
        cache::MemoryUtCacheProxy& m_utCache;
        supplier<Timestamp> m_timeSupplier;
 
        subscribers::TransactionStatusSubscriber& m_transactionStatusSubscriber;
        subscribers::StateChangeSubscriber& m_stateChangeSubscriber;
        subscribers::NodeSubscriber& m_nodeSubscriber;
 
        const std::vector<utils::DiagnosticCounter>& m_counters;
        const plugins::PluginManager& m_pluginManager;
        thread::MultiServicePool& m_pool;
 
        // owned
        std::vector<thread::Task> m_tasks;
        ionet::ServerPacketHandlers m_packetHandlers;
        ServerHooks m_hooks;
        net::PacketIoPickerContainer m_packetIoPickers;
    };
}}