OpenView.h

#pragma once
 
#include <xrpl/ledger/RawView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/ledger/detail/RawStateTable.h>
#include <xrpl/protocol/STArray.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <boost/container/pmr/monotonic_buffer_resource.hpp>
#include <boost/container/pmr/polymorphic_allocator.hpp>
 
#include <functional>
#include <utility>
 
namespace xrpl {
 
inline constexpr struct open_ledger_t
{
    explicit constexpr open_ledger_t() = default;
} open_ledger{};
 
inline constexpr struct batch_view_t
{
    explicit constexpr batch_view_t() = default;
} batch_view{};
 
//------------------------------------------------------------------------------
 
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 initialBufferSize = kilobytes(256);
 
    class txs_iter_impl;
 
    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<key_type>,
        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> monotonic_resource_;
    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(
        open_ledger_t,
        ReadView const* base,
        Rules const& rules,
        std::shared_ptr<void const> hold = nullptr);
 
    OpenView(open_ledger_t, Rules const& rules, std::shared_ptr<ReadView const> const& base)
        : OpenView(open_ledger, &*base, rules, base)
    {
    }
 
    OpenView(batch_view_t, 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;
 
    std::shared_ptr<SLE const>
    read(Keylet const& k) const override;
 
    std::unique_ptr<sles_type::iter_base>
    slesBegin() const override;
 
    std::unique_ptr<sles_type::iter_base>
    slesEnd() const override;
 
    std::unique_ptr<sles_type::iter_base>
    slesUpperBound(uint256 const& key) const override;
 
    std::unique_ptr<txs_type::iter_base>
    txsBegin() const override;
 
    std::unique_ptr<txs_type::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(std::shared_ptr<SLE> const& sle) override;
 
    void
    rawInsert(std::shared_ptr<SLE> const& sle) override;
 
    void
    rawReplace(std::shared_ptr<SLE> const& 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