NamespaceCacheTypes.h

Go to the documentation of this file.

 
#pragma once
#include "src/state/Namespace.h"
#include "src/state/NamespaceEntry.h"
#include "src/state/RootNamespaceHistory.h"
#include "catapult/cache/CacheDatabaseMixin.h"
#include "catapult/cache/CacheDescriptorAdapters.h"
#include "catapult/deltaset/BaseSetDelta.h"
#include "catapult/utils/Hashers.h"
#include "catapult/utils/IdentifierGroup.h"
 
namespace catapult {
    namespace cache {
        class BasicNamespaceCacheDelta;
        class BasicNamespaceCacheView;
        struct NamespaceBaseSetDeltaPointers;
        struct NamespaceBaseSets;
        class NamespaceCache;
        class NamespaceCacheDelta;
        class NamespaceCacheView;
        struct NamespaceFlatMapTypesSerializer;
        struct NamespaceHeightGroupingSerializer;
        class NamespacePatriciaTree;
 
        template<typename TCache, typename TCacheDelta, typename TKey, typename TGetResult>
        class ReadOnlyArtifactCache;
        struct RootNamespaceHistoryPrimarySerializer;
    }
}
 
namespace catapult { namespace cache {
 
    struct NamespaceCacheDescriptor {
    public:
        static constexpr auto Name = "NamespaceCache";
 
    public:
        // key value types
        using KeyType = NamespaceId;
        using ValueType = state::RootNamespaceHistory;
 
        // cache types
        using CacheType = NamespaceCache;
        using CacheDeltaType = NamespaceCacheDelta;
        using CacheViewType = NamespaceCacheView;
 
        using Serializer = RootNamespaceHistoryPrimarySerializer;
        using PatriciaTree = NamespacePatriciaTree;
 
    public:
        static auto GetKeyFromValue(const ValueType& history) {
            return history.id();
        }
    };
 
    struct NamespaceCacheTypes {
    public:
        using CacheReadOnlyType = ReadOnlyArtifactCache<
            BasicNamespaceCacheView,
            BasicNamespaceCacheDelta,
            NamespaceId,
            state::NamespaceEntry>;
 
        struct Options {
            BlockDuration GracePeriodDuration;
        };
 
    // region secondary descriptors
 
    private:
        struct FlatMapTypesDescriptor {
        public:
            using KeyType = NamespaceId;
            using ValueType = state::Namespace;
            using Serializer = NamespaceFlatMapTypesSerializer;
 
        public:
            static auto GetKeyFromValue(const ValueType& ns) {
                return ns.id();
            }
        };
 
    public:
        struct HeightGroupingTypesDescriptor {
        public:
            using KeyType = Height;
            using ValueType = utils::IdentifierGroup<NamespaceId, Height, utils::BaseValueHasher<NamespaceId>>;
            using Serializer = NamespaceHeightGroupingSerializer;
 
        public:
            static auto GetKeyFromValue(const ValueType& heightNamespaces) {
                return heightNamespaces.key();
            }
        };
 
    // endregion
 
    public:
        using PrimaryTypes = MutableUnorderedMapAdapter<NamespaceCacheDescriptor, utils::BaseValueHasher<NamespaceId>>;
        using FlatMapTypes = MutableUnorderedMapAdapter<FlatMapTypesDescriptor, utils::BaseValueHasher<NamespaceId>>;
        using HeightGroupingTypes = MutableUnorderedMapAdapter<HeightGroupingTypesDescriptor, utils::BaseValueHasher<Height>>;
 
    public:
        using BaseSetDeltaPointers = NamespaceBaseSetDeltaPointers;
        using BaseSets = NamespaceBaseSets;
    };
}}