AccountStateCache.h

Go to the documentation of this file.

 
#pragma once
#include "AccountStateCacheDelta.h"
#include "AccountStateCacheView.h"
#include "catapult/cache/BasicCache.h"
 
namespace catapult { namespace cache {
 
    using AccountStateBasicCache = BasicCache<
        AccountStateCacheDescriptor,
        AccountStateCacheTypes::BaseSets,
        AccountStateCacheTypes::Options,
        const model::AddressSet&>;
 
    class BasicAccountStateCache : public AccountStateBasicCache {
    public:
        BasicAccountStateCache(const CacheConfiguration& config, const AccountStateCacheTypes::Options& options)
                : BasicAccountStateCache(config, options, std::make_unique<model::AddressSet>())
        {}
 
    private:
        BasicAccountStateCache(
                const CacheConfiguration& config,
                const AccountStateCacheTypes::Options& options,
                std::unique_ptr<model::AddressSet>&& pHighValueAddresses)
                : AccountStateBasicCache(config, AccountStateCacheTypes::Options(options), *pHighValueAddresses)
                , m_pHighValueAddresses(std::move(pHighValueAddresses))
        {}
 
    public:
        void init(model::AddressSet&& highValueAddresses) {
            *m_pHighValueAddresses = std::move(highValueAddresses);
        }
 
        void commit(const CacheDeltaType& delta) {
            // high value addresses need to be captured before committing because committing clears the deltas
            auto highValueAddresses = delta.highValueAddresses().Current;
            AccountStateBasicCache::commit(delta);
            *m_pHighValueAddresses = std::move(highValueAddresses);
        }
 
    private:
        // unique pointer to allow set reference to be valid after moves of this cache
        std::unique_ptr<model::AddressSet> m_pHighValueAddresses;
    };
 
    class AccountStateCache : public SynchronizedCacheWithInit<BasicAccountStateCache> {
    public:
        DEFINE_CACHE_CONSTANTS(AccountState)
 
    public:
        AccountStateCache(const CacheConfiguration& config, const AccountStateCacheTypes::Options& options)
                : SynchronizedCacheWithInit<BasicAccountStateCache>(BasicAccountStateCache(config, options))
                , m_networkIdentifier(options.NetworkIdentifier)
                , m_importanceGrouping(options.ImportanceGrouping)
        {}
 
    public:
        model::NetworkIdentifier networkIdentifier() const {
            return m_networkIdentifier;
        }
 
        uint64_t importanceGrouping() const {
            return m_importanceGrouping;
        }
 
    private:
        model::NetworkIdentifier m_networkIdentifier;
        uint64_t m_importanceGrouping;
    };
}}