SkipListAcquire.h

#pragma once
 
#include <xrpld/app/ledger/detail/TimeoutCounter.h>
#include <xrpld/app/main/Application.h>
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/shamap/SHAMapItem.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <utility>
#include <vector>
 
namespace xrpl {
class InboundLedgers;
class PeerSet;
namespace test {
class LedgerReplayClient;
}  // namespace test

class SkipListAcquire final : public TimeoutCounter,
                              public std::enable_shared_from_this<SkipListAcquire>,
                              public CountedObject<SkipListAcquire>
{
public:
    using OnSkipListDataCB = std::function<void(bool successful, UInt256 const& hash)>;
 
    struct SkipListData
    {
        std::uint32_t const ledgerSeq;
        std::vector<xrpl::UInt256> const skipList;
 
        SkipListData(std::uint32_t const ledgerSeq, std::vector<xrpl::UInt256> skipList)
            : ledgerSeq(ledgerSeq), skipList(std::move(skipList))
        {
        }
    };

    SkipListAcquire(
        Application& app,
        InboundLedgers& inboundLedgers,
        UInt256 const& ledgerHash,
        std::unique_ptr<PeerSet> peerSet);
 
    ~SkipListAcquire() override;

    void
    init(int numPeers);

    void
    processData(std::uint32_t ledgerSeq, boost::intrusive_ptr<SHAMapItem const> const& item);

    void
    addDataCallback(OnSkipListDataCB&& cb);
 
    std::shared_ptr<SkipListData const>
    getData() const;
 
private:
    void
    onTimer(bool progress, ScopedLockType& peerSetLock) override;
 
    std::weak_ptr<TimeoutCounter>
    pmDowncast() override;

    void
    trigger(std::size_t limit, ScopedLockType& sl);

    void
    retrieveSkipList(std::shared_ptr<Ledger const> const& ledger, ScopedLockType& sl);

    void
    onSkipListAcquired(
        std::vector<UInt256> const& skipList,
        std::uint32_t ledgerSeq,
        ScopedLockType& sl);

    void
    notify(ScopedLockType& sl);
 
    InboundLedgers& inboundLedgers_;
    std::unique_ptr<PeerSet> peerSet_;
    std::vector<OnSkipListDataCB> dataReadyCallbacks_;
    std::shared_ptr<SkipListData const> data_;
    std::uint32_t noFeaturePeerCount_ = 0;
    bool fallBack_ = false;
 
    friend class test::LedgerReplayClient;
};
 
}  // namespace xrpl