AccountStateCacheTypes.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/cache/CacheDatabaseMixin.h"
#include "catapult/cache/CacheDescriptorAdapters.h"
#include "catapult/deltaset/BaseSetDelta.h"
#include "catapult/model/NetworkInfo.h"
#include "catapult/state/AccountState.h"
#include "catapult/utils/Casting.h"
#include "catapult/utils/Hashers.h"
 
namespace catapult {
    namespace cache {
        struct AccountStateBaseSetDeltaPointers;
        struct AccountStateBaseSets;
        class AccountStateCache;
        class AccountStateCacheDelta;
        class AccountStateCacheView;
        class AccountStatePatriciaTree;
        struct AccountStatePrimarySerializer;
        class BasicAccountStateCacheDelta;
        class BasicAccountStateCacheView;
        struct KeyAddressPairSerializer;
        class ReadOnlyAccountStateCache;
    }
}
 
namespace catapult { namespace cache {
 
    struct AccountStateCacheDescriptor {
    public:
        static constexpr auto Name = "AccountStateCache:Address";
 
    public:
        // key value types
        using KeyType = Address;
        using ValueType = state::AccountState;
 
        // cache types
        using CacheType = AccountStateCache;
        using CacheDeltaType = AccountStateCacheDelta;
        using CacheViewType = AccountStateCacheView;
 
        using Serializer = AccountStatePrimarySerializer;
        using PatriciaTree = AccountStatePatriciaTree;
 
    public:
        static auto GetKeyFromValue(const ValueType& accountState) {
            return accountState.Address;
        }
    };
 
    struct AccountStateCacheTypes {
    public:
        using CacheReadOnlyType = ReadOnlyAccountStateCache;
 
        struct Options {
            model::NetworkIdentifier NetworkIdentifier;
 
            uint64_t ImportanceGrouping;
 
            Amount MinHarvesterBalance;
 
            MosaicId CurrencyMosaicId;
 
            MosaicId HarvestingMosaicId;
        };
 
    // region secondary descriptors
 
    public:
        struct KeyLookupMapTypesDescriptor {
        public:
            using KeyType = Key;
            using ValueType = std::pair<Key, Address>;
            using Serializer = KeyAddressPairSerializer;
 
        public:
            static auto GetKeyFromValue(const ValueType& pair) {
                return pair.first;
            }
        };
 
    // endregion
 
    // region other adapters
 
    public:
        template<typename TSets>
        class ComposedLookupAdapter {
        public:
            static constexpr auto Name = TSets::Name;
 
        private:
            using SetOneType = typename TSets::SetOneType;
            using SetTwoType = typename TSets::SetTwoType;
 
        public:
            using KeyType = typename SetOneType::KeyType;
            using ValueType = typename SetTwoType::ElementType;
 
        public:
            ComposedLookupAdapter(const SetOneType& set1, SetTwoType& set2)
                    : m_set1(set1)
                    , m_set2(set2)
            {}
 
        public:
            using FindIterator = typename TSets::FindIterator;
            using FindConstIterator = typename TSets::FindConstIterator;
 
        public:
            FindConstIterator find(const KeyType& key) const {
                auto setOneIter = m_set1.find(key);
                const auto* pPair = setOneIter.get();
                return pPair ? utils::as_const(m_set2).find(pPair->second) : FindConstIterator();
            }
 
            FindIterator find(const KeyType& key) {
                auto setOneIter = m_set1.find(key);
                const auto* pPair = setOneIter.get();
                return pPair ? m_set2.find(pPair->second) : FindIterator();
            }
 
        private:
            const SetOneType& m_set1;
            SetTwoType& m_set2;
        };
 
    // endregion
 
    public:
        using PrimaryTypes = MutableUnorderedMapAdapter<AccountStateCacheDescriptor, utils::ArrayHasher<Address>>;
        using KeyLookupMapTypes = ImmutableUnorderedMapAdapter<KeyLookupMapTypesDescriptor, utils::ArrayHasher<Key>>;
 
    public:
        // workaround for VS truncation
        struct ComposableBaseSets {
            static constexpr auto Name = "AccountStateCache:Key";
 
            using SetOneType = const KeyLookupMapTypes::BaseSetType;
            using SetTwoType = const PrimaryTypes::BaseSetType;
 
            using FindIterator = SetTwoType::FindConstIterator;
            using FindConstIterator = SetTwoType::FindConstIterator;
        };
 
        struct ComposableBaseSetDeltas {
            static constexpr auto Name = "AccountStateCache:Key";
 
            using SetOneType = const KeyLookupMapTypes::BaseSetDeltaType;
            using SetTwoType = PrimaryTypes::BaseSetDeltaType;
 
            using FindIterator = SetTwoType::FindIterator;
            using FindConstIterator = SetTwoType::FindConstIterator;
        };
 
    public:
        using BaseSetDeltaPointers = AccountStateBaseSetDeltaPointers;
        using BaseSets = AccountStateBaseSets;
    };
}}