ApplyView.h

#ifndef XRPL_LEDGER_APPLYVIEW_H_INCLUDED
#define XRPL_LEDGER_APPLYVIEW_H_INCLUDED
 
#include <xrpl/basics/safe_cast.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/RawView.h>
#include <xrpl/ledger/ReadView.h>
 
namespace ripple {
 
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(
                "ripple::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 ripple
 
#endif