AccountStateCacheDelta.h

Go to the documentation of this file.

 
#pragma once
#include "AccountStateBaseSets.h"
#include "AccountStateCacheSerializers.h"
#include "ReadOnlyAccountStateCache.h"
#include "catapult/cache/CacheMixinAliases.h"
#include "catapult/cache/ReadOnlyViewSupplier.h"
#include "catapult/model/ContainerTypes.h"
 
namespace catapult { namespace cache {
 
    struct AccountStateCacheDeltaMixins {
    public:
        using KeyLookupAdapter = AccountStateCacheTypes::ComposedLookupAdapter<AccountStateCacheTypes::ComposableBaseSetDeltas>;
 
    private:
        using AddressMixins = PatriciaTreeCacheMixins<AccountStateCacheTypes::PrimaryTypes::BaseSetDeltaType, AccountStateCacheDescriptor>;
        using KeyMixins = BasicCacheMixins<KeyLookupAdapter, KeyLookupAdapter>;
 
    public:
        using Size = AddressMixins::Size;
        using ContainsAddress = AddressMixins::Contains;
        using ContainsKey = ContainsMixin<
            AccountStateCacheTypes::KeyLookupMapTypes::BaseSetDeltaType,
            AccountStateCacheTypes::KeyLookupMapTypesDescriptor>;
        using ConstAccessorAddress = AddressMixins::ConstAccessor;
        using ConstAccessorKey = KeyMixins::ConstAccessor;
        using MutableAccessorAddress = AddressMixins::MutableAccessor;
        using MutableAccessorKey = KeyMixins::MutableAccessor;
        using PatriciaTreeDelta = AddressMixins::PatriciaTreeDelta;
        using DeltaElements = AddressMixins::DeltaElements;
 
        // no mutable key accessor because address-to-key pairs are immutable
    };
 
    class BasicAccountStateCacheDelta
            : public utils::MoveOnly
            , public AccountStateCacheDeltaMixins::Size
            , public AccountStateCacheDeltaMixins::ContainsAddress
            , public AccountStateCacheDeltaMixins::ContainsKey
            , public AccountStateCacheDeltaMixins::ConstAccessorAddress
            , public AccountStateCacheDeltaMixins::ConstAccessorKey
            , public AccountStateCacheDeltaMixins::MutableAccessorAddress
            , public AccountStateCacheDeltaMixins::MutableAccessorKey
            , public AccountStateCacheDeltaMixins::PatriciaTreeDelta
            , public AccountStateCacheDeltaMixins::DeltaElements {
    public:
        using ReadOnlyView = ReadOnlyAccountStateCache;
 
    public:
        BasicAccountStateCacheDelta(
                const AccountStateCacheTypes::BaseSetDeltaPointers& accountStateSets,
                const AccountStateCacheTypes::Options& options,
                const model::AddressSet& highValueAddresses);
 
    private:
        BasicAccountStateCacheDelta(
                const AccountStateCacheTypes::BaseSetDeltaPointers& accountStateSets,
                const AccountStateCacheTypes::Options& options,
                const model::AddressSet& highValueAddresses,
                std::unique_ptr<AccountStateCacheDeltaMixins::KeyLookupAdapter>&& pKeyLookupAdapter);
 
    public:
        using AccountStateCacheDeltaMixins::ContainsAddress::contains;
        using AccountStateCacheDeltaMixins::ContainsKey::contains;
 
        using AccountStateCacheDeltaMixins::ConstAccessorAddress::find;
        using AccountStateCacheDeltaMixins::ConstAccessorKey::find;
        using AccountStateCacheDeltaMixins::MutableAccessorAddress::find;
        using AccountStateCacheDeltaMixins::MutableAccessorKey::find;
 
    public:
        model::NetworkIdentifier networkIdentifier() const;
 
        uint64_t importanceGrouping() const;
 
        Amount minHarvesterBalance() const;
 
        MosaicId harvestingMosaicId() const;
 
    public:
        void addAccount(const Address& address, Height addressHeight);
 
        void addAccount(const Key& publicKey, Height publicKeyHeight);
 
        void addAccount(const state::AccountState& accountState);
 
    public:
        void queueRemove(const Address& address, Height height);
 
        void queueRemove(const Key& publicKey, Height height);
 
        void commitRemovals();
 
    public:
        struct HighValueAddressesTuple {
            model::AddressSet Current;
 
            model::AddressSet Removed;
        };
 
        HighValueAddressesTuple highValueAddresses() const;
 
    private:
        Address getAddress(const Key& publicKey);
 
        void remove(const Address& address, Height height);
        void remove(const Key& publicKey, Height height);
 
    private:
        // height is first component for a nicer equals
        template<typename TArray>
        using ArrayHeightPair = std::pair<Height, TArray>;
 
        template<typename TArray>
        struct ArrayHeightPairHasher {
            size_t operator()(const ArrayHeightPair<TArray>& arrayHeightPair) const {
                return Hasher(arrayHeightPair.second);
            }
 
            utils::ArrayHasher<TArray> Hasher;
        };
 
        template<typename TArray>
        using QueuedRemovalSet = std::unordered_set<ArrayHeightPair<TArray>, ArrayHeightPairHasher<TArray>>;
 
    private:
        AccountStateCacheTypes::PrimaryTypes::BaseSetDeltaPointerType m_pStateByAddress;
        AccountStateCacheTypes::KeyLookupMapTypes::BaseSetDeltaPointerType m_pKeyToAddress;
 
        const AccountStateCacheTypes::Options& m_options;
        const model::AddressSet& m_highValueAddresses;
        std::unique_ptr<AccountStateCacheDeltaMixins::KeyLookupAdapter> m_pKeyLookupAdapter;
 
        QueuedRemovalSet<Address> m_queuedRemoveByAddress;
        QueuedRemovalSet<Key> m_queuedRemoveByPublicKey;
    };
 
    class AccountStateCacheDelta : public ReadOnlyViewSupplier<BasicAccountStateCacheDelta> {
    public:
        AccountStateCacheDelta(
                const AccountStateCacheTypes::BaseSetDeltaPointers& accountStateSets,
                const AccountStateCacheTypes::Options& options,
                const model::AddressSet& highValueAddresses)
                : ReadOnlyViewSupplier(accountStateSets, options, highValueAddresses)
        {}
    };
}}