BaseSetDefaultTraits.h

Go to the documentation of this file.

 
#pragma once
#include <memory>
 
namespace catapult { namespace deltaset {
 
    // region key + storage traits
 
    // KeyType => the data key
    // ValueType => the data value (this is assumed to be convertible to KeyType)
    // StorageType => the underlying storage (e.g. pair) composed of both key and value
 
    template<typename TSet>
    struct SetKeyTraits {
        using KeyType = typename TSet::value_type;
        using ValueType = typename TSet::value_type;
        using StorageType = typename TSet::value_type;
 
        static constexpr const KeyType& ToKey(const StorageType& element) {
            return element;
        }
    };
 
    template<typename TMap>
    struct MapKeyTraits {
        using KeyType = typename TMap::key_type;
        using ValueType = typename TMap::mapped_type;
        using StorageType = typename TMap::value_type;
 
        static constexpr const KeyType& ToKey(const StorageType& element) {
            return element.first;
        }
    };
 
    template<typename TSet, typename TMemorySetType = TSet>
    struct SetStorageTraits {
        using SetType = TSet;
        using MemorySetType = TMemorySetType;
 
        using KeyTraits = SetKeyTraits<MemorySetType>;
        using KeyType = typename KeyTraits::KeyType;
        using ValueType = typename KeyTraits::ValueType;
        using StorageType = typename KeyTraits::StorageType;
 
        static constexpr bool AllowsNativeValueModification = false;
 
        static constexpr const KeyType& ToKey(const StorageType& element) {
            return KeyTraits::ToKey(element);
        }
 
        static constexpr const StorageType& ToStorage(const ValueType& value) {
            return value;
        }
 
        template<typename TIterator>
        static const StorageType& ToStorage(const KeyType& key, TIterator&&) {
            return key;
        }
 
        static constexpr const ValueType& ToValue(const StorageType& element) {
            return element;
        }
    };
 
    template<typename TMap, typename TElementToKeyConverter, typename TMemoryMapType = TMap>
    struct MapStorageTraits {
        using SetType = TMap;
        using MemorySetType = TMemoryMapType;
 
        using KeyTraits = MapKeyTraits<MemorySetType>;
        using KeyType = typename KeyTraits::KeyType;
        using ValueType = typename KeyTraits::ValueType;
        using StorageType = typename KeyTraits::StorageType;
 
        static constexpr bool AllowsNativeValueModification = true;
 
        static constexpr const KeyType& ToKey(const StorageType& element) {
            return KeyTraits::ToKey(element);
        }
 
        static constexpr KeyType ToKey(const ValueType& value) {
            return TElementToKeyConverter::ToKey(value);
        }
 
        static constexpr StorageType ToStorage(const ValueType& value) {
            return std::make_pair(ToKey(value), value);
        }
 
        template<typename TIterator>
        static const StorageType& ToStorage(const KeyType&, TIterator&& iter) {
            return *iter;
        }
 
        static constexpr const ValueType& ToValue(const StorageType& element) {
            return element.second;
        }
 
        static constexpr ValueType& ToValue(StorageType& element) {
            return element.second;
        }
    };
 
    // endregion
 
    // region mutability traits
 
    // mutability tagging allows BaseSet to optimize for immutable values that can never be modified
    // in contrast, mutable values have copy-on-write semantics
 
    struct MutableTypeTag {};
 
    template<typename TElement>
    struct MutableTypeTraits {
        using ElementType = TElement;
        using MutabilityTag = MutableTypeTag;
 
        static constexpr TElement Copy(const TElement* pElement) {
            return *pElement;
        }
    };
 
    struct ImmutableTypeTag {};
 
    template<typename TElement>
    struct ImmutableTypeTraits {
        using ElementType = const TElement;
        using MutabilityTag = ImmutableTypeTag;
    };
 
    // endregion
 
    // region find traits
 
    // used to find values, ensuring that values stored in stl set-based containers are always exposed as const
    // (because they're not modifiable)
 
    template<typename T, bool AllowsNativeValueModification>
    struct FindTraitsT {
        using ConstResultType = const T*;
        using ResultType = const T*;
 
        static constexpr ResultType ToResult(const T& value) {
            return &value;
        }
    };
 
    template<typename T>
    struct FindTraitsT<T, true> {
        using ConstResultType = const T*;
        using ResultType = T*;
 
        // this needs to be a template in order to allow T to be const (immutable)
        template<typename TValue>
        static constexpr auto ToResult(TValue& value) {
            return &value;
        }
    };
 
    // endregion
}}