LedgerDeltaAcquire.h

#pragma once
 
#include <xrpld/app/ledger/InboundLedger.h>
#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/protocol/LedgerHeader.h>
#include <xrpl/protocol/STTx.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <vector>
 
namespace xrpl {
class InboundLedgers;
class PeerSet;
namespace test {
class LedgerReplayClient;
}  // namespace test

class LedgerDeltaAcquire final : public TimeoutCounter,
                                 public std::enable_shared_from_this<LedgerDeltaAcquire>,
                                 public CountedObject<LedgerDeltaAcquire>
{
public:
    using OnDeltaDataCB = std::function<void(bool successful, uint256 const& hash)>;

    LedgerDeltaAcquire(
        Application& app,
        InboundLedgers& inboundLedgers,
        uint256 const& ledgerHash,
        std::uint32_t ledgerSeq,
        std::unique_ptr<PeerSet> peerSet);
 
    ~LedgerDeltaAcquire() override;

    void
    init(int numPeers);

    void
    processData(
        LedgerHeader const& info,
        std::map<std::uint32_t, std::shared_ptr<STTx const>>&& orderedTxns);

    std::shared_ptr<Ledger const>
    tryBuild(std::shared_ptr<Ledger const> const& parent);

    void
    addDataCallback(InboundLedger::Reason reason, OnDeltaDataCB&& cb);
 
private:
    void
    onTimer(bool progress, ScopedLockType& peerSetLock) override;
 
    std::weak_ptr<TimeoutCounter>
    pmDowncast() override;

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

    void
    onLedgerBuilt(ScopedLockType& sl, std::optional<InboundLedger::Reason> reason = {});

    void
    notify(ScopedLockType& sl);
 
    InboundLedgers& inboundLedgers_;
    std::uint32_t const ledgerSeq_;
    std::unique_ptr<PeerSet> peerSet_;
    std::shared_ptr<Ledger const> replayTemp_;
    std::shared_ptr<Ledger const> fullLedger_;
    std::map<std::uint32_t, std::shared_ptr<STTx const>> orderedTxns_;
    std::vector<OnDeltaDataCB> dataReadyCallbacks_;
    std::set<InboundLedger::Reason> reasons_;
    std::uint32_t noFeaturePeerCount_ = 0;
    bool fallBack_ = false;
 
    friend class LedgerReplayTask;  // for asserts only
    friend class test::LedgerReplayClient;
};
 
}  // namespace xrpl