CacheMixins.h

Go to the documentation of this file.

 
#pragma once
#include "IdentifierGroupCacheUtils.h"
#include "catapult/deltaset/BaseSetDelta.h"
#include "catapult/deltaset/BaseSetDeltaIterationView.h"
#include "catapult/deltaset/BaseSetIterationView.h"
#include "catapult/utils/Casting.h"
#include "catapult/utils/HexFormatter.h"
#include "catapult/utils/IdentifierGroup.h"
#include "catapult/functions.h"
#include "catapult/types.h"
 
namespace catapult { namespace cache {
 
    template<typename TSet>
    class SizeMixin {
    public:
        explicit SizeMixin(const TSet& set) : m_set(set)
        {}
 
    public:
        size_t size() const {
            return m_set.size();
        }
 
    private:
        const TSet& m_set;
    };
 
    template<typename TSet, typename TCacheDescriptor>
    class ContainsMixin {
    private:
        using KeyType = typename TCacheDescriptor::KeyType;
 
    public:
        explicit ContainsMixin(const TSet& set) : m_set(set)
        {}
 
    public:
        bool contains(const KeyType& key) const {
            return m_set.contains(key);
        }
 
    private:
        const TSet& m_set;
    };
 
    template<typename TSet>
    class IterationMixin {
    public:
        struct IterableView {
        public:
            explicit IterableView(const TSet& set) : m_set(set)
            {}
 
        public:
            auto begin() const {
                return MakeIterableView(m_set).begin();
            }
 
            auto end() const {
                return MakeIterableView(m_set).end();
            }
 
        private:
            const TSet& m_set;
        };
 
    public:
        explicit IterationMixin(const TSet& set) : m_set(set)
        {}
 
    public:
        auto tryMakeIterableView() const {
            // use argument dependent lookup to resolve IsBaseSetIterable
            return IsBaseSetIterable(m_set) ? std::make_unique<IterableView>(m_set) : nullptr;
        }
 
    private:
        const TSet& m_set;
    };
 
    namespace detail {
        template<typename TCacheDescriptor, typename T>
        [[noreturn]]
        void ThrowInvalidKeyError(const char* keyState, const T& key) {
            std::ostringstream out;
            out << "value with key '" << key << "' is " << keyState << " in cache (" << TCacheDescriptor::Name << ")";
            CATAPULT_THROW_INVALID_ARGUMENT(out.str().c_str());
        }
 
        template<typename TCacheDescriptor, size_t N>
        [[noreturn]]
        void ThrowInvalidKeyError(const char* keyState, const std::array<uint8_t, N>& key) {
            ThrowInvalidKeyError<TCacheDescriptor>(keyState, utils::HexFormat(key));
        }
 
        template<typename TValue>
        struct NoOpAdapter {
            using AdaptedValueType = TValue;
 
            static TValue& Adapt(TValue& value) {
                return value;
            }
        };
 
        template<typename TCacheDescriptor, typename TValueAdapter, typename TBaseSetIterator, typename TValue>
        class CacheFindIterator {
        private:
            using KeyType = typename TCacheDescriptor::KeyType;
 
        public:
            CacheFindIterator() = default;
 
            CacheFindIterator(TBaseSetIterator&& iter, const KeyType& key)
                    : m_iter(std::move(iter))
                    , m_key(key)
            {}
 
        public:
            TValue& get() const {
                auto* pValue = tryGet();
                if (!pValue)
                    detail::ThrowInvalidKeyError<TCacheDescriptor>("not", m_key);
 
                return *pValue;
            }
 
            TValue* tryGet() const {
                auto pValue = m_iter.get(); // can be raw or shared_ptr
                return pValue ? &TValueAdapter::Adapt(*pValue) : nullptr;
            }
 
            const auto* tryGetUnadapted() const {
                auto pValue = m_iter.get(); // can be raw or shared_ptr
                return &*pValue;
            }
 
        private:
            TBaseSetIterator m_iter;
            KeyType m_key;
        };
    }
 
    template<
        typename TSet,
        typename TCacheDescriptor,
        typename TValueAdapter = detail::NoOpAdapter<const typename TCacheDescriptor::ValueType>>
    class ConstAccessorMixin {
    private:
        using KeyType = typename TCacheDescriptor::KeyType;
        using ValueType = typename TValueAdapter::AdaptedValueType;
        using SetIteratorType = typename TSet::FindConstIterator;
 
    public:
        using const_iterator = detail::CacheFindIterator<TCacheDescriptor, TValueAdapter, SetIteratorType, const ValueType>;
 
    public:
        explicit ConstAccessorMixin(const TSet& set) : m_set(set)
        {}
 
    public:
        const_iterator find(const KeyType& key) const {
            auto setIter = m_set.find(key);
            return const_iterator(std::move(setIter), key);
        }
 
    private:
        const TSet& m_set;
    };
 
    template<
        typename TSet,
        typename TCacheDescriptor,
        typename TValueAdapter = detail::NoOpAdapter<typename TCacheDescriptor::ValueType>>
    class MutableAccessorMixin {
    private:
        using KeyType = typename TCacheDescriptor::KeyType;
        using ValueType = typename TValueAdapter::AdaptedValueType;
        using SetIteratorType = typename TSet::FindIterator;
 
    public:
        using iterator = detail::CacheFindIterator<TCacheDescriptor, TValueAdapter, SetIteratorType, ValueType>;
 
    public:
        explicit MutableAccessorMixin(TSet& set) : m_set(set)
        {}
 
    public:
        iterator find(const KeyType& key) {
            auto setIter = m_set.find(key);
            return iterator(std::move(setIter), key);
        }
 
    private:
        TSet& m_set;
    };
 
    template<typename TSet, typename TCacheDescriptor>
    class ActivePredicateMixin {
    private:
        using KeyType = typename TCacheDescriptor::KeyType;
 
    public:
        explicit ActivePredicateMixin(const TSet& set) : m_set(set)
        {}
 
    public:
        bool isActive(const KeyType& key, Height height) const {
            auto iter = m_set.find(key);
            const auto* pValue = iter.get();
            return pValue && pValue->isActive(height);
        }
 
    private:
        const TSet& m_set;
    };
 
    template<typename TSet, typename TCacheDescriptor>
    class BasicInsertRemoveMixin {
    private:
        using KeyType = typename TCacheDescriptor::KeyType;
        using ValueType = typename TCacheDescriptor::ValueType;
 
    public:
        explicit BasicInsertRemoveMixin(TSet& set) : m_set(set)
        {}
 
    public:
        void insert(const ValueType& value) {
            auto result = m_set.insert(value);
            if (deltaset::InsertResult::Inserted == result || deltaset::InsertResult::Unremoved == result)
                return;
 
            CATAPULT_LOG(error) << "insert failed with " << utils::to_underlying_type(result);
            detail::ThrowInvalidKeyError<TCacheDescriptor>("already", TCacheDescriptor::GetKeyFromValue(value));
        }
 
        void remove(const KeyType& key) {
            auto result = m_set.remove(key);
            if (deltaset::RemoveResult::None != result && deltaset::RemoveResult::Redundant != result)
                return;
 
            CATAPULT_LOG(error) << "remove failed with " << utils::to_underlying_type(result);
            detail::ThrowInvalidKeyError<TCacheDescriptor>("not", key);
        }
 
    private:
        TSet& m_set;
    };
 
    template<typename TSet, typename THeightGroupedSet>
    class HeightBasedTouchMixin {
    public:
        HeightBasedTouchMixin(TSet& set, THeightGroupedSet& heightGroupedSet)
                : m_set(set)
                , m_heightGroupedSet(heightGroupedSet)
        {}
 
    public:
        typename THeightGroupedSet::ElementType::Identifiers touch(Height height) {
            // 1. using non-const set, touch all elements at height
            ForEachIdentifierWithGroup(m_set, m_heightGroupedSet, height, [](const auto&) {});
 
            // 2. using const set, find identifiers of all deactivating elements
            return FindDeactivatingIdentifiersAtHeight(m_set, m_heightGroupedSet, height);
        }
 
    private:
        TSet& m_set;
        THeightGroupedSet& m_heightGroupedSet;
    };
 
    template<typename TSet, typename THeightGroupedSet>
    class HeightBasedPruningMixin {
    public:
        HeightBasedPruningMixin(TSet& set, THeightGroupedSet& heightGroupedSet)
                : m_set(set)
                , m_heightGroupedSet(heightGroupedSet)
        {}
 
    public:
        void prune(Height height) {
            RemoveAllIdentifiersWithGroup(m_set, m_heightGroupedSet, height);
        }
 
    private:
        TSet& m_set;
        THeightGroupedSet& m_heightGroupedSet;
    };
}}