STLedgerEntry.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STBase.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/Serializer.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
 
namespace xrpl {
 
class Rules;
namespace test {
class Invariants_test;
}  // namespace test
 
class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
{
    uint256 key_;
    LedgerEntryType type_;
 
public:
    using pointer = std::shared_ptr<STLedgerEntry>;
    using ref = std::shared_ptr<STLedgerEntry> const&;
    using const_pointer = std::shared_ptr<STLedgerEntry const>;
    using const_ref = std::shared_ptr<STLedgerEntry const> const&;

    explicit STLedgerEntry(Keylet const& k);
    STLedgerEntry(LedgerEntryType type, uint256 const& key);
    STLedgerEntry(SerialIter& sit, uint256 const& index);
    STLedgerEntry(SerialIter&& sit, uint256 const& index);
    STLedgerEntry(STObject const& object, uint256 const& index);
 
    [[nodiscard]] SerializedTypeID
    getSType() const override;
 
    [[nodiscard]] std::string
    getFullText() const override;
 
    [[nodiscard]] std::string
    getText() const override;
 
    [[nodiscard]] json::Value
    getJson(JsonOptions options = JsonOptions::Values::None) const override;

    [[nodiscard]] uint256 const&
    key() const;
 
    [[nodiscard]] LedgerEntryType
    getType() const;
 
    // is this a ledger entry that can be threaded
    [[nodiscard]] bool
    isThreadedType(Rules const& rules) const;
 
    bool
    thread(
        uint256 const& txID,
        std::uint32_t ledgerSeq,
        uint256& prevTxID,
        std::uint32_t& prevLedgerID);
 
private:
    /*  Make STObject comply with the template for this SLE type
        Can throw
    */
    void
    setSLEType();
 
    friend test::Invariants_test;  // this test wants access to the private
                                   // type_
 
    STBase*
    copy(std::size_t n, void* buf) const override;
    STBase*
    move(std::size_t n, void* buf) override;
 
    friend class detail::STVar;
};
 
using SLE = STLedgerEntry;
 
inline STLedgerEntry::STLedgerEntry(LedgerEntryType type, uint256 const& key)
    : STLedgerEntry(Keylet(type, key))
{
}
 
inline STLedgerEntry::STLedgerEntry(
    SerialIter&& sit,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
    uint256 const& index)
    : STLedgerEntry(sit, index)
{
}

inline uint256 const&
STLedgerEntry::key() const
{
    return key_;
}
 
inline LedgerEntryType
STLedgerEntry::getType() const
{
    return type_;
}
 
}  // namespace xrpl