OfferStream.h

#ifndef XRPL_APP_BOOK_OFFERSTREAM_H_INCLUDED
#define XRPL_APP_BOOK_OFFERSTREAM_H_INCLUDED
 
#include <xrpld/app/tx/detail/BookTip.h>
#include <xrpld/app/tx/detail/Offer.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/View.h>
 
#include <boost/container/flat_set.hpp>
 
namespace ripple {
 
template <class TIn, class TOut>
class TOfferStreamBase
{
public:
    class StepCounter
    {
    private:
        std::uint32_t const limit_;
        std::uint32_t count_;
        beast::Journal j_;
 
    public:
        StepCounter(std::uint32_t limit, beast::Journal j)
            : limit_(limit), count_(0), j_(j)
        {
        }
 
        bool
        step()
        {
            if (count_ >= limit_)
            {
                JLOG(j_.debug()) << "Exceeded " << limit_ << " step limit.";
                return false;
            }
            count_++;
            return true;
        }
        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>
    bool
    shouldRmSmallIncreasedQOffer() const;
 
public:
    TOfferStreamBase(
        ApplyView& view,
        ApplyView& cancelView,
        Book const& book,
        NetClock::time_point when,
        StepCounter& counter,
        beast::Journal journal);
 
    virtual ~TOfferStreamBase() = default;
 
    TOffer<TIn, TOut>&
    tip() const
    {
        return const_cast<TOfferStreamBase*>(this)->offer_;
    }
 
    bool
    step();
 
    TOut
    ownerFunds() const
    {
        return *ownerFunds_;
    }
};
 
class OfferStream : public TOfferStreamBase<STAmount, STAmount>
{
protected:
    void
    permRmOffer(uint256 const& offerIndex) override;
 
public:
    using TOfferStreamBase<STAmount, STAmount>::TOfferStreamBase;
};
 
template <class TIn, class 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;
 
    boost::container::flat_set<uint256> const&
    permToRemove() const
    {
        return permToRemove_;
    }
};
}  // namespace ripple
 
#endif