SHAMapTreeNode.h

#pragma once
 
#include <xrpl/basics/IntrusivePointer.h>
#include <xrpl/basics/IntrusiveRefCounts.h>
#include <xrpl/basics/SHAMapHash.h>
#include <xrpl/basics/Slice.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/shamap/SHAMapNodeID.h>
 
#include <cstddef>
#include <cstdint>
#include <string>
 
namespace xrpl {
 
class SHAMapTreeNode;
using SHAMapTreeNodePtr = intr_ptr::SharedPtr<SHAMapTreeNode>;
 
// These are wire-protocol identifiers used during serialization to encode the
// type of a node. They should not be arbitrarily be changed.
static constexpr unsigned char const kWireTypeTransaction = 0;
static constexpr unsigned char const kWireTypeAccountState = 1;
static constexpr unsigned char const kWireTypeInner = 2;
static constexpr unsigned char const kWireTypeCompressedInner = 3;
static constexpr unsigned char const kWireTypeTransactionWithMeta = 4;
 
// Lower bound on SHAMap leaf item payload size, in bytes.
inline constexpr std::size_t kMinShaMapItemBytes = 12;
 
enum class SHAMapNodeType {
    TnInner = 1,
    TnTransactionNm = 2,  // transaction, no metadata
    TnTransactionMd = 3,  // transaction, with metadata
    TnAccountState = 4
};
 
class SHAMapTreeNode : public IntrusiveRefCounts
{
protected:
    SHAMapHash hash_;

    std::uint32_t cowid_;

    explicit SHAMapTreeNode(std::uint32_t cowid) noexcept : cowid_(cowid)
    {
    }
 
    explicit SHAMapTreeNode(std::uint32_t cowid, SHAMapHash const& hash) noexcept
        : hash_(hash), cowid_(cowid)
    {
    }

 
public:
    ~SHAMapTreeNode() noexcept override = default;
 
    SHAMapTreeNode(SHAMapTreeNode const&) = delete;
    SHAMapTreeNode&
    operator=(SHAMapTreeNode const&) = delete;
 
    // Needed to support weak intrusive pointers
    virtual void
    partialDestructor() {};

    std::uint32_t
    cowid() const
    {
        return cowid_;
    }

    void
    unshare()
    {
        cowid_ = 0;
    }

    virtual SHAMapTreeNodePtr
    clone(std::uint32_t cowid) const = 0;

    virtual void
    updateHash() = 0;

    SHAMapHash const&
    getHash() const
    {
        return hash_;
    }

    virtual SHAMapNodeType
    getType() const = 0;

    virtual bool
    isLeaf() const = 0;

    virtual bool
    isInner() const = 0;

    virtual void
    serializeForWire(Serializer&) const = 0;

    virtual void
    serializeWithPrefix(Serializer&) const = 0;
 
    virtual std::string
    getString(SHAMapNodeID const&) const;
 
    virtual void
    invariants(bool isRoot = false) const = 0;
 
    static SHAMapTreeNodePtr
    makeFromPrefix(Slice rawNode, SHAMapHash const& hash);
 
    static SHAMapTreeNodePtr
    makeFromWire(Slice rawNode);
 
private:
    static SHAMapTreeNodePtr
    makeTransaction(Slice data, SHAMapHash const& hash, bool hashValid);
 
    static SHAMapTreeNodePtr
    makeAccountState(Slice data, SHAMapHash const& hash, bool hashValid);
 
    static SHAMapTreeNodePtr
    makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool hashValid);
};
 
}  // namespace xrpl