SHAMapNodeID.h

#ifndef XRPL_SHAMAP_SHAMAPNODEID_H_INCLUDED
#define XRPL_SHAMAP_SHAMAPNODEID_H_INCLUDED
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
 
#include <optional>
#include <string>
#include <tuple>
 
namespace ripple {
 
class SHAMapNodeID : public CountedObject<SHAMapNodeID>
{
private:
    uint256 id_;
    unsigned int depth_ = 0;
 
public:
    SHAMapNodeID() = default;
    SHAMapNodeID(SHAMapNodeID const& other) = default;
    SHAMapNodeID(unsigned int depth, uint256 const& hash);
 
    SHAMapNodeID&
    operator=(SHAMapNodeID const& other) = default;
 
    bool
    isRoot() const
    {
        return depth_ == 0;
    }
 
    // Get the wire format (256-bit nodeID, 1-byte depth)
    std::string
    getRawString() const;
 
    unsigned int
    getDepth() const
    {
        return depth_;
    }
 
    uint256 const&
    getNodeID() const
    {
        return id_;
    }
 
    SHAMapNodeID
    getChildNodeID(unsigned int m) const;
 
    static SHAMapNodeID
    createID(int depth, uint256 const& key);
 
    // FIXME-C++20: use spaceship and operator synthesis
    bool
    operator<(SHAMapNodeID const& n) const
    {
        return std::tie(depth_, id_) < std::tie(n.depth_, n.id_);
    }
 
    bool
    operator>(SHAMapNodeID const& n) const
    {
        return n < *this;
    }
 
    bool
    operator<=(SHAMapNodeID const& n) const
    {
        return !(n < *this);
    }
 
    bool
    operator>=(SHAMapNodeID const& n) const
    {
        return !(*this < n);
    }
 
    bool
    operator==(SHAMapNodeID const& n) const
    {
        return (depth_ == n.depth_) && (id_ == n.id_);
    }
 
    bool
    operator!=(SHAMapNodeID const& n) const
    {
        return !(*this == n);
    }
};
 
inline std::string
to_string(SHAMapNodeID const& node)
{
    if (node.isRoot())
        return "NodeID(root)";
 
    return "NodeID(" + std::to_string(node.getDepth()) + "," +
        to_string(node.getNodeID()) + ")";
}
 
inline std::ostream&
operator<<(std::ostream& out, SHAMapNodeID const& node)
{
    return out << to_string(node);
}
 
[[nodiscard]] std::optional<SHAMapNodeID>
deserializeSHAMapNodeID(void const* data, std::size_t size);
 
[[nodiscard]] inline std::optional<SHAMapNodeID>
deserializeSHAMapNodeID(std::string const& s)
{
    return deserializeSHAMapNodeID(s.data(), s.size());
}
[[nodiscard]] unsigned int
selectBranch(SHAMapNodeID const& id, uint256 const& hash);
 
}  // namespace ripple
 
#endif