LedgerDeltaAcquire.h

#ifndef XRPL_APP_LEDGER_LEDGERDELTAACQUIRE_H_INCLUDED
#define XRPL_APP_LEDGER_LEDGERDELTAACQUIRE_H_INCLUDED
 
#include <xrpld/app/ledger/InboundLedger.h>
#include <xrpld/app/ledger/Ledger.h>
#include <xrpld/app/ledger/detail/TimeoutCounter.h>
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
 
#include <map>
 
namespace ripple {
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(
        LedgerInfo 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 ripple
 
#endif