DirectoryHelpers.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STLedgerEntry.h>
 
#include <cstdint>
#include <functional>
#include <memory>
#include <type_traits>
 
namespace xrpl {
 
namespace detail {
 
template <class V, class N>
bool
internalDirNext(
    V& view,
    uint256 const& root,
    std::shared_ptr<N>& page,
    unsigned int& index,
    uint256& entry)
    requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
{
    auto const& svIndexes = page->getFieldV256(sfIndexes);
    XRPL_ASSERT(index <= svIndexes.size(), "xrpl::detail::internalDirNext : index inside range");
 
    if (index >= svIndexes.size())
    {
        auto const next = page->getFieldU64(sfIndexNext);
 
        if (!next)
        {
            entry.zero();
            return false;
        }
 
        if constexpr (std::is_const_v<N>)
        {
            page = view.read(keylet::page(root, next));
        }
        else
        {
            page = view.peek(keylet::page(root, next));
        }
 
        XRPL_ASSERT(page, "xrpl::detail::internalDirNext : non-null root");
 
        if (!page)
            return false;
 
        index = 0;
 
        return internalDirNext(view, root, page, index, entry);
    }
 
    entry = svIndexes[index++];
    return true;
}
 
template <class V, class N>
bool
internalDirFirst(
    V& view,
    uint256 const& root,
    std::shared_ptr<N>& page,
    unsigned int& index,
    uint256& entry)
    requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
{
    if constexpr (std::is_const_v<N>)
    {
        page = view.read(keylet::page(root));
    }
    else
    {
        page = view.peek(keylet::page(root));
    }
 
    if (!page)
        return false;
 
    index = 0;
 
    return internalDirNext(view, root, page, index, entry);
}
 
}  // namespace detail

bool
cdirFirst(
    ReadView const& view,
    uint256 const& root,
    SLE::const_pointer& page,
    unsigned int& index,
    uint256& entry);
 
bool
dirFirst(
    ApplyView& view,
    uint256 const& root,
    SLE::pointer& page,
    unsigned int& index,
    uint256& entry);

bool
cdirNext(
    ReadView const& view,
    uint256 const& root,
    SLE::const_pointer& page,
    unsigned int& index,
    uint256& entry);
 
bool
dirNext(
    ApplyView& view,
    uint256 const& root,
    SLE::pointer& page,
    unsigned int& index,
    uint256& entry);

void
forEachItem(ReadView const& view, Keylet const& root, std::function<void(SLE::const_ref)> const& f);

bool
forEachItemAfter(
    ReadView const& view,
    Keylet const& root,
    uint256 const& after,
    std::uint64_t const hint,
    unsigned int limit,
    std::function<bool(SLE::const_ref)> const& f);

inline void
forEachItem(ReadView const& view, AccountID const& id, std::function<void(SLE::const_ref)> const& f)
{
    forEachItem(view, keylet::ownerDir(id), f);
}

inline bool
forEachItemAfter(
    ReadView const& view,
    AccountID const& id,
    uint256 const& after,
    std::uint64_t const hint,
    unsigned int limit,
    std::function<bool(SLE::const_ref)> const& f)
{
    return forEachItemAfter(view, keylet::ownerDir(id), after, hint, limit, f);
}

[[nodiscard]] bool
dirIsEmpty(ReadView const& view, Keylet const& k);

[[nodiscard]] std::function<void(SLE::ref)>
describeOwnerDir(AccountID const& account);
 
}  // namespace xrpl