OfferStream.h

#pragma once
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/protocol/Book.h>
#include <xrpl/protocol/Concepts.h>
#include <xrpl/tx/paths/BookTip.h>
#include <xrpl/tx/paths/Offer.h>
 
#include <boost/container/flat_set.hpp>
 
#include <cstdint>
#include <optional>
 
namespace xrpl {
 
template <StepAmount TIn, StepAmount TOut>
class TOfferStreamBase
{
public:
    class StepCounter
    {
    private:
        std::uint32_t const limit_;
        std::uint32_t count_{0};
        beast::Journal j_;
 
    public:
        StepCounter(std::uint32_t limit, beast::Journal j) : limit_(limit), j_(j)
        {
        }
 
        bool
        step()
        {
            if (count_ >= limit_)
            {
                JLOG(j_.debug()) << "Exceeded " << limit_ << " step limit.";
                return false;
            }
            count_++;
            return true;
        }
        [[nodiscard]] std::uint32_t
        count() const
        {
            return count_;
        }
    };
 
protected:
    beast::Journal const j_;
    ApplyView& view_;
    ApplyView& cancelView_;
    Book book_;
    bool validBook_;
    NetClock::time_point const expire_;
    BookTip tip_;
    TOffer<TIn, TOut> offer_;
    std::optional<TOut> ownerFunds_;
    StepCounter& counter_;
 
    void
    erase(ApplyView& view);
 
    virtual void
    permRmOffer(uint256 const& offerIndex) = 0;
 
    template <class TTakerPays, class TTakerGets>
        requires ValidTaker<TTakerPays, TTakerGets>
    [[nodiscard]] bool
    shouldRmSmallIncreasedQOffer() const;
 
public:
    TOfferStreamBase(
        ApplyView& view,
        ApplyView& cancelView,
        Book const& book,
        NetClock::time_point when,
        StepCounter& counter,
        beast::Journal journal);
 
    virtual ~TOfferStreamBase() = default;

    [[nodiscard]] TOffer<TIn, TOut>&
    tip() const
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
        return const_cast<TOfferStreamBase*>(this)->offer_;
    }

    bool
    step();
 
    [[nodiscard]] TOut
    ownerFunds() const
    {
        return *ownerFunds_;  // NOLINT(bugprone-unchecked-optional-access) always set after step()
                              // is called
    }
};

template <StepAmount TIn, StepAmount TOut>
class FlowOfferStream : public TOfferStreamBase<TIn, TOut>
{
private:
    boost::container::flat_set<uint256> permToRemove_;
 
public:
    using TOfferStreamBase<TIn, TOut>::TOfferStreamBase;
 
    // The following interface allows offer crossing to permanently
    // remove self crossed offers.  The motivation is somewhat
    // unintuitive.  See the discussion in the comments for
    // BookOfferCrossingStep::limitSelfCrossQuality().
    void
    permRmOffer(uint256 const& offerIndex) override;
 
    [[nodiscard]] boost::container::flat_set<uint256> const&
    permToRemove() const
    {
        return permToRemove_;
    }
};
}  // namespace xrpl