CacheDescriptorAdapters.h

Go to the documentation of this file.

 
#pragma once
#include "CacheConfiguration.h"
#include "catapult/cache_db/CacheDatabase.h"
#include "catapult/cache_db/UpdateSet.h"
#include "catapult/deltaset/BaseSet.h"
#include "catapult/deltaset/ConditionalContainer.h"
#include "catapult/deltaset/OrderedSet.h"
#include <unordered_map>
 
namespace catapult { namespace cache {
 
    namespace detail {
        template<typename TElementTraits, typename TDescriptor, typename TValueHasher>
        struct UnorderedMapAdapter {
        private:
            struct DescriptorAdapter {
            public:
                using KeyType = typename TDescriptor::KeyType;
                using ValueType = typename TDescriptor::ValueType;
                using StorageType = std::pair<const KeyType, ValueType>;
                using Serializer = typename TDescriptor::Serializer;
 
                static constexpr auto GetKeyFromValue = TDescriptor::GetKeyFromValue;
 
                static constexpr auto& ToKey(const StorageType& element) {
                    return element.first;
                }
 
                static constexpr auto& ToValue(const StorageType& element) {
                    return element.second;
                }
 
                static auto ToStorage(const ValueType& value) {
                    return StorageType(TDescriptor::GetKeyFromValue(value), value);
                }
            };
 
            using StorageMapType = CacheContainerView<DescriptorAdapter>;
            using MemoryMapType = std::unordered_map<typename TDescriptor::KeyType, typename TDescriptor::ValueType, TValueHasher>;
 
            struct Converter {
                static constexpr auto ToKey = TDescriptor::GetKeyFromValue;
            };
 
            // workaround for VS truncation
            using MapStorageTraits = deltaset::MapStorageTraits<
                deltaset::ConditionalContainer<
                    deltaset::MapKeyTraits<MemoryMapType>,
                    StorageMapType,
                    MemoryMapType
                >,
                Converter,
                MemoryMapType
            >;
 
            struct StorageTraits : public MapStorageTraits {};
 
        public:
            using BaseSetType = deltaset::BaseSet<TElementTraits, StorageTraits>;
 
            using BaseSetDeltaType = typename BaseSetType::DeltaType;
 
            using BaseSetDeltaPointerType = std::shared_ptr<BaseSetDeltaType>;
        };
    }
 
    template<typename TDescriptor, typename TValueHasher = std::hash<typename TDescriptor::KeyType>>
    using MutableUnorderedMapAdapter = detail::UnorderedMapAdapter<
        deltaset::MutableTypeTraits<typename TDescriptor::ValueType>,
        TDescriptor,
        TValueHasher>;
 
    template<typename TDescriptor, typename TValueHasher = std::hash<typename TDescriptor::KeyType>>
    using ImmutableUnorderedMapAdapter = detail::UnorderedMapAdapter<
        deltaset::ImmutableTypeTraits<typename TDescriptor::ValueType>,
        TDescriptor,
        TValueHasher>;
 
    namespace detail {
        template<typename TElementTraits>
        struct OrderedMemorySetAdapter {
        private:
            using ElementType = std::remove_const_t<typename TElementTraits::ElementType>;
 
            class StorageSetType : public deltaset::detail::OrderedSetType<TElementTraits> {
            public:
                StorageSetType(CacheDatabase&, size_t)
                {}
            };
 
            using MemorySetType = std::set<ElementType>;
 
            // workaround for VS truncation
            using SetStorageTraits = deltaset::SetStorageTraits<
                deltaset::ConditionalContainer<
                    deltaset::SetKeyTraits<MemorySetType>,
                    StorageSetType,
                    MemorySetType
                >,
                MemorySetType
            >;
 
            struct StorageTraits : public SetStorageTraits {};
 
        public:
            using BaseSetType = deltaset::OrderedSet<TElementTraits, StorageTraits>;
 
            using BaseSetDeltaType = typename BaseSetType::DeltaType;
 
            using BaseSetDeltaPointerType = std::shared_ptr<BaseSetDeltaType>;
        };
    }
 
    template<typename TDescriptor>
    using MutableOrderedMemorySetAdapter = detail::OrderedMemorySetAdapter<
        deltaset::MutableTypeTraits<typename TDescriptor::ValueType>>;
 
    template<typename TDescriptor>
    using ImmutableOrderedMemorySetAdapter = detail::OrderedMemorySetAdapter<
        deltaset::ImmutableTypeTraits<typename TDescriptor::ValueType>>;
 
    namespace detail {
        template<typename TElementTraits, typename TDescriptor>
        struct OrderedSetAdapter {
        private:
            struct DescriptorAdapter {
            public:
                using KeyType = typename TDescriptor::KeyType;
                using ValueType = typename TDescriptor::ValueType;
                using StorageType = typename TDescriptor::KeyType;
                using Serializer = typename TDescriptor::Serializer;
 
                static constexpr auto GetKeyFromValue = TDescriptor::GetKeyFromValue;
 
                static constexpr auto& ToKey(const StorageType& element) {
                    return element;
                }
 
                static constexpr auto& ToValue(const StorageType& element) {
                    return element;
                }
 
                static constexpr auto& ToStorage(const ValueType& value) {
                    return value;
                }
            };
 
            using ElementType = std::remove_const_t<typename TElementTraits::ElementType>;
            using StorageSetType = CacheContainerView<DescriptorAdapter>;
            using MemorySetType = std::set<ElementType>;
 
            // workaround for VS truncation
            using SetStorageTraits = deltaset::SetStorageTraits<
                deltaset::ConditionalContainer<
                    deltaset::SetKeyTraits<MemorySetType>,
                    StorageSetType,
                    MemorySetType
                >,
                MemorySetType
            >;
 
            struct StorageTraits : public SetStorageTraits {};
 
        public:
            using BaseSetType = deltaset::OrderedSet<TElementTraits, StorageTraits>;
 
            using BaseSetDeltaType = typename BaseSetType::DeltaType;
 
            using BaseSetDeltaPointerType = std::shared_ptr<BaseSetDeltaType>;
        };
    }
 
    template<typename TDescriptor>
    using MutableOrderedSetAdapter = detail::OrderedSetAdapter<
        deltaset::MutableTypeTraits<typename TDescriptor::ValueType>,
        TDescriptor>;
 
    template<typename TDescriptor>
    using ImmutableOrderedSetAdapter = detail::OrderedSetAdapter<
        deltaset::ImmutableTypeTraits<typename TDescriptor::ValueType>,
        TDescriptor>;
}}