SHAMapTreeNode.h

#pragma once
 
#include <xrpl/basics/IntrusivePointer.h>
#include <xrpl/basics/IntrusiveRefCounts.h>
#include <xrpl/basics/SHAMapHash.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/shamap/SHAMapItem.h>
#include <xrpl/shamap/SHAMapNodeID.h>
 
#include <cstdint>
#include <string>
 
namespace xrpl {
 
// 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 wireTypeTransaction = 0;
static constexpr unsigned char const wireTypeAccountState = 1;
static constexpr unsigned char const wireTypeInner = 2;
static constexpr unsigned char const wireTypeCompressedInner = 3;
static constexpr unsigned char const wireTypeTransactionWithMeta = 4;
 
enum class SHAMapNodeType {
    tnINNER = 1,
    tnTRANSACTION_NM = 2,  // transaction, no metadata
    tnTRANSACTION_MD = 3,  // transaction, with metadata
    tnACCOUNT_STATE = 4
};
 
class SHAMapTreeNode : public IntrusiveRefCounts
{
protected:
    SHAMapHash hash_;
 
    std::uint32_t cowid_;
 
protected:
    SHAMapTreeNode(SHAMapTreeNode const&) = delete;
    SHAMapTreeNode&
    operator=(SHAMapTreeNode const&) = delete;
 
    explicit SHAMapTreeNode(std::uint32_t cowid) noexcept : cowid_(cowid)
    {
    }
 
    explicit SHAMapTreeNode(std::uint32_t cowid, SHAMapHash const& hash) noexcept
        : hash_(hash), cowid_(cowid)
    {
    }
public:
    virtual ~SHAMapTreeNode() noexcept = default;
 
    // Needed to support weak intrusive pointers
    virtual void
    partialDestructor() {};
 
    std::uint32_t
    cowid() const
    {
        return cowid_;
    }
 
    void
    unshare()
    {
        cowid_ = 0;
    }
 
    virtual intr_ptr::SharedPtr<SHAMapTreeNode>
    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 is_root = false) const = 0;
 
    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeFromPrefix(Slice rawNode, SHAMapHash const& hash);
 
    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeFromWire(Slice rawNode);
 
private:
    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeTransaction(Slice data, SHAMapHash const& hash, bool hashValid);
 
    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeAccountState(Slice data, SHAMapHash const& hash, bool hashValid);
 
    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool hashValid);
};
 
}  // namespace xrpl