TreeNode.h

Go to the documentation of this file.

 
#pragma once
#include "TreeNodePath.h"
#include "catapult/types.h"
#include <bitset>
#include <memory>
 
namespace catapult { namespace tree { class TreeNode; } }
 
namespace catapult { namespace tree {
 
    // region LeafTreeNode
 
    class LeafTreeNode {
    public:
        LeafTreeNode(const TreeNodePath& path, const Hash256& value);
 
    public:
        const TreeNodePath& path() const;
 
        const Hash256& value() const;
 
        const Hash256& hash() const;
 
    private:
        TreeNodePath m_path;
        Hash256 m_value;
        Hash256 m_hash;
    };
 
    // endregion
 
    // region BranchTreeNode
 
    class BranchTreeNode {
    public:
        static constexpr size_t Max_Links = 16;
 
    public:
        explicit BranchTreeNode(const TreeNodePath& path);
 
    public:
        const TreeNodePath& path() const;
 
        size_t numLinks() const;
 
        bool hasLink(size_t index) const;
 
        const Hash256& link(size_t index) const;
 
        std::unique_ptr<const TreeNode> linkedNode(size_t index) const;
 
        uint8_t highestLinkIndex() const;
 
        const Hash256& hash() const;
 
    public:
        void setPath(const TreeNodePath& path);
 
        void setLink(const Hash256& link, size_t index);
 
        void setLink(const TreeNode& node, size_t index);
 
        void clearLink(size_t index);
 
        void compactLinks();
 
    private:
        void setLink(size_t index);
 
    private:
        TreeNodePath m_path;
        std::array<Hash256, BranchTreeNode::Max_Links> m_links;
        std::array<std::shared_ptr<const TreeNode>, BranchTreeNode::Max_Links> m_linkedNodes; // shared_ptr to allow copying
        std::bitset<BranchTreeNode::Max_Links> m_linkSet;
        mutable Hash256 m_hash;
        mutable bool m_isDirty;
    };
 
    // endregion
 
    // region TreeNode
 
    class TreeNode {
    public:
        TreeNode();
 
        explicit TreeNode(const LeafTreeNode& node);
 
        explicit TreeNode(const BranchTreeNode& node);
 
    public:
        bool empty() const;
 
        bool isBranch() const;
 
        bool isLeaf() const;
 
    public:
        const TreeNodePath& path() const;
 
        const Hash256& hash() const;
 
    public:
        void setPath(const TreeNodePath& path);
 
    public:
        const LeafTreeNode& asLeafNode() const;
 
        const BranchTreeNode& asBranchNode() const;
 
    public:
        TreeNode copy() const;
 
    private:
        TreeNodePath m_emptyPath;
        Hash256 m_emptyHash;
        std::unique_ptr<LeafTreeNode> m_pLeafNode;
        std::unique_ptr<BranchTreeNode> m_pBranchNode;
    };
 
    // endregion
}}