ConditionalContainer.h

Go to the documentation of this file.

 
#pragma once
#include "BaseSetCommitPolicy.h"
#include "DeltaElements.h"
#include <memory>
 
namespace catapult { namespace deltaset {
 
    namespace detail {
        // need to expose hashed or sorted container traits as hint to key storage in BaseSetDelta secondary containers
        template<typename T, typename = void>
        struct StlContainerTraits {
            using key_compare = typename T::key_compare;
        };
 
        template<typename T>
        struct StlContainerTraits<T, utils::traits::is_type_expression_t<typename T::hasher>> {
            using hasher = typename T::hasher;
            using key_equal = typename T::key_equal;
        };
    }
 
    enum class ConditionalContainerMode {
        Storage,
 
        Memory
    };
 
    template<typename TKeyTraits, typename TStorageSet, typename TMemorySet>
    class ConditionalContainer : public detail::StlContainerTraits<TMemorySet> {
    public:
        using StorageSetType = TStorageSet;
        using MemorySetType = TMemorySet;
 
        using value_type = typename MemorySetType::value_type;
 
    private:
        // use flags to support similar storage and memory sets with same iterator
        using StorageFlag = std::integral_constant<ConditionalContainerMode, ConditionalContainerMode::Storage>;
        using MemoryFlag = std::integral_constant<ConditionalContainerMode, ConditionalContainerMode::Memory>;
 
    public:
        class ConditionalIterator {
        public:
            ConditionalIterator() = default;
 
            explicit ConditionalIterator(typename StorageSetType::const_iterator&& iter, StorageFlag)
                    : m_storageIter(std::move(iter))
                    , m_mode(ConditionalContainerMode::Storage)
            {}
 
            explicit ConditionalIterator(typename MemorySetType::const_iterator&& iter, MemoryFlag)
                    : m_memoryIter(std::move(iter))
                    , m_mode(ConditionalContainerMode::Memory)
            {}
 
        public:
            bool operator==(const ConditionalIterator& rhs) const {
                return ConditionalContainerMode::Storage == m_mode ? m_storageIter == rhs.m_storageIter : m_memoryIter == rhs.m_memoryIter;
            }
 
            bool operator!=(const ConditionalIterator& rhs) const {
                return !(*this == rhs);
            }
 
        public:
            const auto* operator->() const {
                return &operator*();
            }
 
            const auto& operator*() const {
                return ConditionalContainerMode::Storage == m_mode ? *m_storageIter : *m_memoryIter;
            }
 
        private:
            typename StorageSetType::const_iterator m_storageIter;
            typename MemorySetType::const_iterator m_memoryIter;
            ConditionalContainerMode m_mode;
        };
 
    public:
        using const_iterator = ConditionalIterator;
        using iterator = ConditionalIterator;
 
    public:
        ConditionalContainer() : ConditionalContainer(ConditionalContainerMode::Memory)
        {}
 
        template<typename... TStorageArgs>
        explicit ConditionalContainer(ConditionalContainerMode mode, TStorageArgs&&... storageArgs) {
            if (ConditionalContainerMode::Storage == mode)
                m_pContainer1 = std::make_unique<StorageSetType>(std::forward<TStorageArgs>(storageArgs)...);
            else
                m_pContainer2 = std::make_unique<MemorySetType>();
        }
 
    public:
        bool empty() const {
            return m_pContainer1 ? m_pContainer1->empty() : m_pContainer2->empty();
        }
 
        size_t size() const {
            return m_pContainer1 ? m_pContainer1->size() : m_pContainer2->size();
        }
 
    public:
        ConditionalIterator cend() const {
            return m_pContainer1
                    ? ConditionalIterator(m_pContainer1->cend(), StorageFlag())
                    : ConditionalIterator(m_pContainer2->cend(), MemoryFlag());
        }
 
        ConditionalIterator find(const typename TKeyTraits::KeyType& key) const {
            return m_pContainer1
                    ? ConditionalIterator(m_pContainer1->find(key), StorageFlag())
                    : ConditionalIterator(m_pContainer2->find(key), MemoryFlag());
        }
 
    public:
        void update(const DeltaElements<MemorySetType>& deltas) {
            if (m_pContainer1)
                UpdateSet<TKeyTraits>(*m_pContainer1, deltas);
            else
                UpdateSet<TKeyTraits>(*m_pContainer2, deltas);
        }
 
        template<typename TPruningBoundary>
        void prune(const TPruningBoundary& pruningBoundary) {
            if (m_pContainer1)
                PruneBaseSet(*m_pContainer1, pruningBoundary);
            else
                PruneBaseSet(*m_pContainer2, pruningBoundary);
        }
 
    private:
        std::unique_ptr<StorageSetType> m_pContainer1;
        std::unique_ptr<MemorySetType> m_pContainer2;
 
    private:
        template<typename TKeyTraits2, typename TStorageSet2, typename TMemorySet2>
        friend bool IsSetIterable(const ConditionalContainer<TKeyTraits2, TStorageSet2, TMemorySet2>& set);
 
        template<typename TKeyTraits2, typename TStorageSet2, typename TMemorySet2>
        friend const TMemorySet2& SelectIterableSet(const ConditionalContainer<TKeyTraits2, TStorageSet2, TMemorySet2>& set);
    };
 
    template<typename TKeyTraits, typename TStorageSet, typename TMemorySet>
    bool IsSetIterable(const ConditionalContainer<TKeyTraits, TStorageSet, TMemorySet>& set) {
        return !!set.m_pContainer2;
    }
 
    template<typename TKeyTraits, typename TStorageSet, typename TMemorySet>
    const TMemorySet& SelectIterableSet(const ConditionalContainer<TKeyTraits, TStorageSet, TMemorySet>& set) {
        if (!IsSetIterable(set))
            CATAPULT_THROW_INVALID_ARGUMENT("ConditionalContainer is only iterable when it is memory-based");
 
        return *set.m_pContainer2;
    }
 
    template<typename TKeyTraits, typename TStorageSet, typename TMemorySet>
    void UpdateSet(ConditionalContainer<TKeyTraits, TStorageSet, TMemorySet>& container, const DeltaElements<TMemorySet>& deltas) {
        container.update(deltas);
    }
 
    template<typename TKeyTraits, typename TStorageSet, typename TMemorySet, typename TPruningBoundary>
    void PruneBaseSet(ConditionalContainer<TKeyTraits, TStorageSet, TMemorySet>& container, const TPruningBoundary& pruningBoundary) {
        container.prune(pruningBoundary);
    }
}}