SHAMapInnerNode.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/SHAMapHash.h>
#include <xrpl/basics/Slice.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/shamap/SHAMapNodeID.h>
#include <xrpl/shamap/SHAMapTreeNode.h>
#include <xrpl/shamap/detail/TaggedPointer.h>
 
#include <atomic>
#include <cstdint>
#include <optional>
#include <string>
 
namespace xrpl {
 
class SHAMapInnerNode final : public SHAMapTreeNode, public CountedObject<SHAMapInnerNode>
{
public:
    static constexpr unsigned int kBranchFactor = 16;
 
private:
    TaggedPointer hashesAndChildren_;
 
    std::uint32_t fullBelowGen_ = 0;
    std::uint16_t isBranch_ = 0;

    mutable std::atomic<std::uint16_t> lock_ = 0;

    void
    resizeChildArrays(std::uint8_t toAllocate);

    std::optional<int>
    getChildIndex(int i) const;

    template <class F>
    void
    iterChildren(F&& f) const;

    template <class F>
    void
    iterNonEmptyChildIndexes(F&& f) const;
 
public:
    explicit SHAMapInnerNode(std::uint32_t cowid, std::uint8_t numAllocatedChildren = 2);
 
    SHAMapInnerNode(SHAMapInnerNode const&) = delete;
    SHAMapInnerNode&
    operator=(SHAMapInnerNode const&) = delete;
    ~SHAMapInnerNode() override;
 
    // Needed to support intrusive weak pointers
    void
    partialDestructor() override;
 
    SHAMapTreeNodePtr
    clone(std::uint32_t cowid) const override;
 
    SHAMapNodeType
    getType() const override
    {
        return SHAMapNodeType::TnInner;
    }
 
    bool
    isLeaf() const override
    {
        return false;
    }
 
    bool
    isInner() const override
    {
        return true;
    }
 
    bool
    isEmpty() const;
 
    bool
    isEmptyBranch(int m) const;
 
    int
    getBranchCount() const;
 
    SHAMapHash const&
    getChildHash(int m) const;
 
    void
    setChild(int m, SHAMapTreeNodePtr child);
 
    void
    shareChild(int m, SHAMapTreeNodePtr const& child);
 
    SHAMapTreeNode*
    getChildPointer(int branch);
 
    SHAMapTreeNodePtr
    getChild(int branch);
 
    SHAMapTreeNodePtr
    canonicalizeChild(int branch, SHAMapTreeNodePtr node);
 
    // sync functions
    bool
    isFullBelow(std::uint32_t generation) const;
 
    void
    setFullBelowGen(std::uint32_t gen);
 
    void
    updateHash() override;

    void
    updateHashDeep();
 
    void
    serializeForWire(Serializer&) const override;
 
    void
    serializeWithPrefix(Serializer&) const override;
 
    std::string
    getString(SHAMapNodeID const&) const override;
 
    void
    invariants(bool isRoot = false) const override;
 
    static SHAMapTreeNodePtr
    makeFullInner(Slice data, SHAMapHash const& hash, bool hashValid);
 
    static SHAMapTreeNodePtr
    makeCompressedInner(Slice data);
};
 
inline bool
SHAMapInnerNode::isEmpty() const
{
    return isBranch_ == 0;
}
 
inline bool
SHAMapInnerNode::isEmptyBranch(int m) const
{
    return (isBranch_ & (1 << m)) == 0;
}
 
inline int
SHAMapInnerNode::getBranchCount() const
{
    return popcnt16(isBranch_);
}
 
inline bool
SHAMapInnerNode::isFullBelow(std::uint32_t generation) const
{
    return fullBelowGen_ == generation;
}
 
inline void
SHAMapInnerNode::setFullBelowGen(std::uint32_t gen)
{
    fullBelowGen_ = gen;
}
 
}  // namespace xrpl