OpenView.h

#pragma once
 
#include <xrpl/basics/ByteUtilities.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/ledger/RawView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/ledger/detail/RawStateTable.h>
#include <xrpl/protocol/Fees.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <boost/container/pmr/monotonic_buffer_resource.hpp>
#include <boost/container/pmr/polymorphic_allocator.hpp>
 
#include <cstddef>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <utility>
 
namespace xrpl {

inline constexpr struct OpenLedgerT
{
    explicit constexpr OpenLedgerT() = default;
} kOpenLedger{};

inline constexpr struct BatchViewT
{
    explicit constexpr BatchViewT() = default;
} kBatchView{};
 
//------------------------------------------------------------------------------

class OpenView final : public ReadView, public TxsRawView
{
private:
    // Initial size for the monotonic_buffer_resource used for allocations
    // The size was chosen from the old `qalloc` code (which this replaces).
    // It is unclear how the size initially chosen in qalloc.
    static constexpr size_t kInitialBufferSize = kilobytes(256);
 
    class TxsIterImpl;
 
    struct TxData
    {
        std::shared_ptr<Serializer const> txn;
        std::shared_ptr<Serializer const> meta;
 
        // Constructor needed for emplacement in std::map
        TxData(
            std::shared_ptr<Serializer const> const& txn,
            std::shared_ptr<Serializer const> const& meta)
            : txn(txn), meta(meta)
        {
        }
    };
 
    // List of tx, key order
    // Use boost::pmr functionality instead of std::pmr
    // functions b/c clang does not support pmr yet (as-of 9/2020)
    using txs_map = std::map<
        key_type,
        TxData,
        std::less<>,
        boost::container::pmr::polymorphic_allocator<std::pair<key_type const, TxData>>>;
 
    // monotonic_resource_ must outlive `items_`. Make a pointer so it may be
    // easily moved.
    std::unique_ptr<boost::container::pmr::monotonic_buffer_resource> monotonicResource_;
    txs_map txs_;
    Rules rules_;
    LedgerHeader header_;
    ReadView const* base_;
    detail::RawStateTable items_;
    std::shared_ptr<void const> hold_;

    std::size_t baseTxCount_ = 0;
 
    bool open_ = true;
 
public:
    OpenView() = delete;
    OpenView&
    operator=(OpenView&&) = delete;
    OpenView&
    operator=(OpenView const&) = delete;
 
    OpenView(OpenView&&) = default;

    OpenView(OpenView const&);

    OpenView(
        OpenLedgerT,
        ReadView const* base,
        Rules rules,
        std::shared_ptr<void const> hold = nullptr);
 
    OpenView(OpenLedgerT, Rules const& rules, std::shared_ptr<ReadView const> const& base)
        : OpenView(kOpenLedger, &*base, rules, base)
    {
    }
 
    OpenView(BatchViewT, OpenView& base) : OpenView(std::addressof(base))
    {
        baseTxCount_ = base.txCount();
    }

    OpenView(ReadView const* base, std::shared_ptr<void const> hold = nullptr);

    bool
    open() const override
    {
        return open_;
    }

    std::size_t
    txCount() const;

    void
    apply(TxsRawView& to) const;
 
    // ReadView
 
    LedgerHeader const&
    header() const override;
 
    Fees const&
    fees() const override;
 
    Rules const&
    rules() const override;
 
    bool
    exists(Keylet const& k) const override;
 
    std::optional<key_type>
    succ(key_type const& key, std::optional<key_type> const& last = std::nullopt) const override;
 
    SLE::const_pointer
    read(Keylet const& k) const override;
 
    std::unique_ptr<SlesType::iter_base>
    slesBegin() const override;
 
    std::unique_ptr<SlesType::iter_base>
    slesEnd() const override;
 
    std::unique_ptr<SlesType::iter_base>
    slesUpperBound(uint256 const& key) const override;
 
    std::unique_ptr<TxsType::iter_base>
    txsBegin() const override;
 
    std::unique_ptr<TxsType::iter_base>
    txsEnd() const override;
 
    bool
    txExists(key_type const& key) const override;
 
    tx_type
    txRead(key_type const& key) const override;
 
    // RawView
 
    void
    rawErase(SLE::ref sle) override;
 
    void
    rawInsert(SLE::ref sle) override;
 
    void
    rawReplace(SLE::ref sle) override;
 
    void
    rawDestroyXRP(XRPAmount const& fee) override;
 
    // TxsRawView
 
    void
    rawTxInsert(
        key_type const& key,
        std::shared_ptr<Serializer const> const& txn,
        std::shared_ptr<Serializer const> const& metaData) override;
};
 
}  // namespace xrpl