BasePatriciaTreeDelta.h

Go to the documentation of this file.

 
#pragma once
#include "PatriciaTree.h"
#include "ReadThroughMemoryDataSource.h"
#include "catapult/utils/HexFormatter.h"
#include "catapult/exceptions.h"
#include <unordered_map>
#include <unordered_set>
 
namespace catapult { namespace tree {
 
    template<typename TEncoder, typename TDataSource, typename THasher>
    class BasePatriciaTreeDelta {
    private:
        using KeyType = typename TEncoder::KeyType;
        using ValueType = typename TEncoder::ValueType;
 
    public:
        explicit BasePatriciaTreeDelta(const TDataSource& dataSource, const Hash256& rootHash)
                : m_dataSource(dataSource)
                , m_baseRootHash(rootHash)
                , m_tree(m_dataSource) {
            m_tree.tryLoad(rootHash);
        }
 
    public:
        Hash256 root() const {
            return m_tree.root();
        }
 
        Hash256 baseRoot() const {
            return m_baseRootHash;
        }
 
    public:
        void reset(const Hash256& rootHash) {
            if (Hash256() == rootHash)
                m_tree.clear();
            else if (!m_tree.tryLoad(rootHash))
                CATAPULT_THROW_RUNTIME_ERROR_1("unable to load root hash", rootHash);
 
            m_baseRootHash = rootHash;
        }
 
        void set(const KeyType& key, const ValueType& value) {
            return m_tree.set(key, value);
        }
 
        bool unset(const KeyType& key) {
            return m_tree.unset(key);
        }
 
    public:
        void setCheckpoint() {
            m_tree.saveAll();
        }
 
    public:
        template<typename TDestinationDataSource>
        void copyPendingChangesTo(TDestinationDataSource& dataSource) const {
            m_dataSource.forEach([&dataSource](const auto& node) {
                if (node.isLeaf())
                    dataSource.set(node.asLeafNode());
                else
                    dataSource.set(node.asBranchNode());
            });
        }
 
        template<typename TTree>
        void copyRootTo(TTree& tree) const {
            auto rootHash = root();
            if (Hash256() == rootHash)
                tree.clear();
            else
                tree.setRoot(*m_dataSource.get(rootHash));
        }
 
    private:
        ReadThroughMemoryDataSource<TDataSource> m_dataSource;
        Hash256 m_baseRootHash;
        PatriciaTree<TEncoder, ReadThroughMemoryDataSource<TDataSource>> m_tree;
    };
}}