TreeNodePath.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/utils/traits/Traits.h"
#include <algorithm>
#include <iosfwd>
#include <vector>
#include <stdint.h>
 
namespace catapult { namespace tree {
 
    class TreeNodePath {
    public:
        TreeNodePath();
 
        template<typename TKey>
        explicit TreeNodePath(TKey key) : m_adjustment(0) {
            if constexpr (utils::traits::is_scalar_v<TKey>) {
                m_size = 2 * sizeof(TKey);
                m_path.resize(sizeof(TKey));
 
                // copy in big endian byte order
                const auto* pKeyData = reinterpret_cast<const uint8_t*>(&key);
                std::reverse_copy(pKeyData, pKeyData + sizeof(TKey), m_path.begin());
            } else {
                m_size = 2 * key.size();
                m_path.resize(key.size());
                std::copy(key.cbegin(), key.cend(), m_path.begin());
            }
        }
 
    private:
        TreeNodePath(const std::vector<uint8_t>& path, size_t offset, size_t size);
 
    public:
        bool empty() const;
 
        size_t size() const;
 
    public:
        uint8_t nibbleAt(size_t index) const;
 
    public:
        bool operator==(const TreeNodePath& rhs) const;
 
        bool operator!=(const TreeNodePath& rhs) const;
 
    public:
        TreeNodePath subpath(size_t offset) const;
 
        TreeNodePath subpath(size_t offset, size_t size) const;
 
    public:
        static TreeNodePath Join(const TreeNodePath& lhs, const TreeNodePath& rhs);
 
        static TreeNodePath Join(const TreeNodePath& lhs, uint8_t nibble, const TreeNodePath& rhs);
 
    private:
        size_t m_size;
        size_t m_adjustment; // used to track odd / even starting nibble
        std::vector<uint8_t> m_path;
    };
 
    std::ostream& operator<<(std::ostream& out, const TreeNodePath& path);
 
    size_t FindFirstDifferenceIndex(const TreeNodePath& lhs, const TreeNodePath& rhs);
}}