BaseSet.h

Go to the documentation of this file.

 
#pragma once
#include "BaseSetCommitPolicy.h"
#include "BaseSetDefaultTraits.h"
#include "BaseSetFindIterator.h"
#include <memory>
 
namespace catapult {
    namespace deltaset {
        template<typename TElementTraits, typename TSetTraits>
        class BaseSetDelta;
 
        template<typename TSetTraits>
        class BaseSetIterationView;
    }
}
 
namespace catapult { namespace deltaset {
 
    template<
            typename TElementTraits,
            typename TSetTraits,
            typename TCommitPolicy = BaseSetCommitPolicy<TSetTraits>
    >
    class BaseSet : public utils::MoveOnly {
    public:
        using ElementType = typename TElementTraits::ElementType;
        using SetType = typename TSetTraits::SetType;
        using KeyType = typename TSetTraits::KeyType;
        using FindTraits = FindTraitsT<ElementType, TSetTraits::AllowsNativeValueModification>;
        using DeltaType = BaseSetDelta<TElementTraits, TSetTraits>;
 
        using FindConstIterator = BaseSetFindIterator<FindTraits, TSetTraits>;
 
    public:
        template<typename... TArgs>
        explicit BaseSet(TArgs&&... args) : m_elements(std::forward<TArgs>(args)...)
        {}
 
    public:
        bool empty() const {
            return m_elements.empty();
        }
 
        size_t size() const {
            return m_elements.size();
        }
 
        FindConstIterator find(const KeyType& key) const {
            auto iter = m_elements.find(key);
            return m_elements.cend() != iter ? FindConstIterator(std::move(iter)) : FindConstIterator();
        }
 
        bool contains(const KeyType& key) const {
            return m_elements.cend() != m_elements.find(key);
        }
 
    public:
        std::shared_ptr<DeltaType> rebase() {
            if (m_pWeakDelta.lock())
                CATAPULT_THROW_RUNTIME_ERROR("only a single attached delta is allowed at a time");
 
            auto pDelta = std::make_shared<DeltaType>(m_elements);
            m_pWeakDelta = pDelta;
            return pDelta;
        }
 
        std::shared_ptr<DeltaType> rebaseDetached() const {
            return std::make_shared<DeltaType>(m_elements);
        }
 
    public:
        template<typename... TArgs>
        void commit(TArgs&&... args) {
            auto pDelta = m_pWeakDelta.lock();
            if (!pDelta)
                CATAPULT_THROW_RUNTIME_ERROR("attempting to commit changes to a set without any outstanding attached deltas");
 
            auto deltas = pDelta->deltas();
            TCommitPolicy::Update(m_elements, deltas, std::forward<TArgs>(args)...);
            pDelta->reset();
        }
 
    private:
        SetType m_elements;
        std::weak_ptr<DeltaType> m_pWeakDelta;
 
    private:
        template<typename TElementTraits2, typename TSetTraits2, typename TCommitPolicy2>
        friend bool IsBaseSetIterable(const BaseSet<TElementTraits2, TSetTraits2, TCommitPolicy2>& set);
 
        template<typename TElementTraits2, typename TSetTraits2, typename TCommitPolicy2>
        friend BaseSetIterationView<TSetTraits2> MakeIterableView(const BaseSet<TElementTraits2, TSetTraits2, TCommitPolicy2>& set);
    };
}}