SkipListAcquire.h

#ifndef XRPL_APP_LEDGER_SKIPLISTACQUIRE_H_INCLUDED
#define XRPL_APP_LEDGER_SKIPLISTACQUIRE_H_INCLUDED
 
#include <xrpld/app/ledger/InboundLedger.h>
#include <xrpld/app/ledger/Ledger.h>
#include <xrpld/app/ledger/detail/TimeoutCounter.h>
#include <xrpld/app/main/Application.h>
 
#include <xrpl/shamap/SHAMap.h>
 
namespace ripple {
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<ripple::uint256> const skipList;
 
        SkipListData(
            std::uint32_t const ledgerSeq,
            std::vector<ripple::uint256> const& skipList)
            : ledgerSeq(ledgerSeq), skipList(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 ripple
 
#endif