TimeoutCounter.h

#pragma once
 
#include <xrpld/app/main/Application.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/core/Job.h>
 
#include <boost/asio/basic_waitable_timer.hpp>
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
 
namespace xrpl {

class TimeoutCounter
{
public:
    virtual void
    cancel();
 
    virtual ~TimeoutCounter() = default;
 
protected:
    using ScopedLockType = std::unique_lock<std::recursive_mutex>;
 
    struct QueueJobParameter
    {
        JobType jobType;
        std::string jobName;
        std::optional<std::uint32_t> jobLimit;
    };
 
    TimeoutCounter(
        Application& app,
        UInt256 const& targetHash,
        std::chrono::milliseconds timeoutInterval,
        QueueJobParameter&& jobParameter,
        beast::Journal journal);

    void
    setTimer(ScopedLockType&);

    void
    queueJob(ScopedLockType&);

    virtual void
    onTimer(bool progress, ScopedLockType&) = 0;

    virtual std::weak_ptr<TimeoutCounter>
    pmDowncast() = 0;
 
    bool
    isDone() const
    {
        return complete_ || failed_;
    }
 
    // Used in this class for access to boost::asio::io_context and
    // xrpl::Overlay. Used in subtypes for the kitchen sink.
    Application& app_;
    beast::Journal journal_;
    mutable std::recursive_mutex mtx_;

    UInt256 const hash_;
    int timeouts_{0};
    bool complete_{false};
    bool failed_{false};
    bool progress_{false};
    std::chrono::milliseconds timerInterval_;
 
    QueueJobParameter queueJobParameter_;
 
private:
    void
    invokeOnTimer();
 
    boost::asio::basic_waitable_timer<std::chrono::steady_clock> timer_;
};
 
}  // namespace xrpl