ApplyView.h

#pragma once
 
#include <xrpl/basics/safe_cast.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/RawView.h>
#include <xrpl/ledger/ReadView.h>
 
namespace xrpl {
 
enum ApplyFlags : std::uint32_t {
    tapNONE = 0x00,
 
    // This is a local transaction with the
    // fail_hard flag set.
    tapFAIL_HARD = 0x10,
 
    // This is not the transaction's last pass
    // Transaction can be retried, soft failures allowed
    tapRETRY = 0x20,
 
    // Transaction came from a privileged source
    tapUNLIMITED = 0x400,
 
    // Transaction is executing as part of a batch
    tapBATCH = 0x800,
 
    // Transaction shouldn't be applied
    // Signatures shouldn't be checked
    tapDRY_RUN = 0x1000
};
 
constexpr ApplyFlags
operator|(ApplyFlags const& lhs, ApplyFlags const& rhs)
{
    return safe_cast<ApplyFlags>(
        safe_cast<std::underlying_type_t<ApplyFlags>>(lhs) | safe_cast<std::underlying_type_t<ApplyFlags>>(rhs));
}
 
static_assert((tapFAIL_HARD | tapRETRY) == safe_cast<ApplyFlags>(0x30u), "ApplyFlags operator |");
static_assert((tapRETRY | tapFAIL_HARD) == safe_cast<ApplyFlags>(0x30u), "ApplyFlags operator |");
 
constexpr ApplyFlags
operator&(ApplyFlags const& lhs, ApplyFlags const& rhs)
{
    return safe_cast<ApplyFlags>(
        safe_cast<std::underlying_type_t<ApplyFlags>>(lhs) & safe_cast<std::underlying_type_t<ApplyFlags>>(rhs));
}
 
static_assert((tapFAIL_HARD & tapRETRY) == tapNONE, "ApplyFlags operator &");
static_assert((tapRETRY & tapFAIL_HARD) == tapNONE, "ApplyFlags operator &");
 
constexpr ApplyFlags
operator~(ApplyFlags const& flags)
{
    return safe_cast<ApplyFlags>(~safe_cast<std::underlying_type_t<ApplyFlags>>(flags));
}
 
static_assert(~tapRETRY == safe_cast<ApplyFlags>(0xFFFFFFDFu), "ApplyFlags operator ~");
 
inline ApplyFlags
operator|=(ApplyFlags& lhs, ApplyFlags const& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
 
inline ApplyFlags
operator&=(ApplyFlags& lhs, ApplyFlags const& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
//------------------------------------------------------------------------------
 
class ApplyView : public ReadView
{
private:
    std::optional<std::uint64_t>
    dirAdd(
        bool preserveOrder,
        Keylet const& directory,
        uint256 const& key,
        std::function<void(std::shared_ptr<SLE> const&)> const& describe);
 
public:
    ApplyView() = default;
 
    virtual ApplyFlags
    flags() const = 0;
 
    virtual std::shared_ptr<SLE>
    peek(Keylet const& k) = 0;
 
    virtual void
    erase(std::shared_ptr<SLE> const& sle) = 0;
 
    virtual void
    insert(std::shared_ptr<SLE> const& sle) = 0;
 
    virtual void
    update(std::shared_ptr<SLE> const& sle) = 0;
 
    //--------------------------------------------------------------------------
 
    // Called when a credit is made to an account
    // This is required to support PaymentSandbox
    virtual void
    creditHook(AccountID const& from, AccountID const& to, STAmount const& amount, STAmount const& preCreditBalance)
    {
    }
 
    // Called when the owner count changes
    // This is required to support PaymentSandbox
    virtual void
    adjustOwnerCountHook(AccountID const& account, std::uint32_t cur, std::uint32_t next)
    {
    }
 
    std::optional<std::uint64_t>
    dirAppend(
        Keylet const& directory,
        Keylet const& key,
        std::function<void(std::shared_ptr<SLE> const&)> const& describe)
    {
        if (key.type != ltOFFER)
        {
            // LCOV_EXCL_START
            UNREACHABLE(
                "xrpl::ApplyView::dirAppend : only Offers are appended to "
                "book directories");
            // Only Offers are appended to book directories. Call dirInsert()
            // instead
            return std::nullopt;
            // LCOV_EXCL_STOP
        }
        return dirAdd(true, directory, key.key, describe);
    }
    std::optional<std::uint64_t>
    dirInsert(
        Keylet const& directory,
        uint256 const& key,
        std::function<void(std::shared_ptr<SLE> const&)> const& describe)
    {
        return dirAdd(false, directory, key, describe);
    }
 
    std::optional<std::uint64_t>
    dirInsert(
        Keylet const& directory,
        Keylet const& key,
        std::function<void(std::shared_ptr<SLE> const&)> const& describe)
    {
        return dirAdd(false, directory, key.key, describe);
    }
    bool
    dirRemove(Keylet const& directory, std::uint64_t page, uint256 const& key, bool keepRoot);
 
    bool
    dirRemove(Keylet const& directory, std::uint64_t page, Keylet const& key, bool keepRoot)
    {
        return dirRemove(directory, page, key.key, keepRoot);
    }
    bool
    dirDelete(Keylet const& directory, std::function<void(uint256 const&)> const&);
 
    bool
    emptyDirDelete(Keylet const& directory);
};
 
namespace directory {
std::uint64_t
createRoot(
    ApplyView& view,
    Keylet const& directory,
    uint256 const& key,
    std::function<void(std::shared_ptr<SLE> const&)> const& describe);
 
auto
findPreviousPage(ApplyView& view, Keylet const& directory, SLE::ref start);
 
std::uint64_t
insertKey(
    ApplyView& view,
    SLE::ref node,
    std::uint64_t page,
    bool preserveOrder,
    STVector256& indexes,
    uint256 const& key);
 
std::optional<std::uint64_t>
insertPage(
    ApplyView& view,
    std::uint64_t page,
    SLE::pointer node,
    std::uint64_t nextPage,
    SLE::ref next,
    uint256 const& key,
    Keylet const& directory,
    std::function<void(std::shared_ptr<SLE> const&)> const& describe);
 
}  // namespace directory
}  // namespace xrpl