NamespaceCacheMixins.h

Go to the documentation of this file.

 
#pragma once
#include "src/state/NamespaceEntry.h"
#include "src/state/RootNamespaceHistory.h"
#include "catapult/deltaset/BaseSetDelta.h"
#include <numeric>
 
namespace catapult { namespace cache {
 
    struct NamespaceSizes {
        size_t Active;
 
        size_t Deep;
    };
 
    template<typename TSet>
    class NamespaceDeepSizeMixin {
    public:
        explicit NamespaceDeepSizeMixin(const NamespaceSizes& sizes) : m_sizes(sizes)
        {}
 
    public:
        size_t activeSize() const {
            return m_sizes.Active;
        }
 
        size_t deepSize() const {
            return m_sizes.Deep;
        }
 
    protected:
        void incrementActiveSize(size_t delta = 1) {
            m_sizes.Active += delta;
        }
 
        void decrementActiveSize(size_t delta = 1) {
            m_sizes.Active -= delta;
        }
 
        void incrementDeepSize(size_t delta = 1) {
            m_sizes.Deep += delta;
        }
 
        void decrementDeepSize(size_t delta = 1) {
            m_sizes.Deep -= delta;
        }
 
    private:
        NamespaceSizes m_sizes;
    };
 
    template<typename TPrimarySet, typename TFlatMap>
    class NamespaceLookupMixin {
    public:
        class const_iterator {
        public:
            const_iterator() : m_isValid(false)
            {}
 
            explicit const_iterator(NamespaceId id)
                    : m_isValid(false)
                    , m_id(id)
            {}
 
            const_iterator(typename TFlatMap::FindConstIterator&& namespaceIter, typename TPrimarySet::FindConstIterator&& rootIter)
                    : m_isValid(true)
                    , m_namespaceIter(std::move(namespaceIter))
                    , m_rootIter(std::move(rootIter))
                    , m_entry(*m_namespaceIter.get(), m_rootIter.get()->back())
            {}
 
        public:
            const state::NamespaceEntry& get() const {
                if (!m_isValid)
                    CATAPULT_THROW_INVALID_ARGUMENT_1("unknown namespace", m_id);
 
                return *tryGet();
            }
 
            const state::NamespaceEntry* tryGet() const {
                return m_isValid ? &m_entry : nullptr;
            }
 
            const state::RootNamespaceHistory* tryGetUnadapted() const {
                return m_rootIter.get();
            }
 
        private:
            bool m_isValid;
            NamespaceId m_id;
            typename TFlatMap::FindConstIterator m_namespaceIter;
            typename TPrimarySet::FindConstIterator m_rootIter;
            state::NamespaceEntry m_entry;
        };
 
    public:
        explicit NamespaceLookupMixin(const TPrimarySet& set, const TFlatMap& flatMap)
                : m_set(set)
                , m_flatMap(flatMap)
        {}
 
    public:
        bool isActive(NamespaceId id, Height height) const {
            auto namespaceIter = m_flatMap.find(id);
            if (!namespaceIter.get())
                return false;
 
            auto historyIter = m_set.find(namespaceIter.get()->rootId());
            if (!historyIter.get())
                CATAPULT_THROW_RUNTIME_ERROR_1("no history for root namespace found", namespaceIter.get()->rootId());
 
            return historyIter.get()->isActiveAndUnlocked(height);
        }
 
        const_iterator find(NamespaceId id) const {
            auto namespaceIter = m_flatMap.find(id);
            if (!namespaceIter.get())
                return const_iterator(id);
 
            auto rootIter = m_set.find(namespaceIter.get()->rootId());
            return const_iterator(std::move(namespaceIter), std::move(rootIter));
        }
 
    private:
        const TPrimarySet& m_set;
        const TFlatMap& m_flatMap;
    };
}}