LedgerTiming.h

#ifndef XRPL_APP_LEDGER_LEDGERTIMING_H_INCLUDED
#define XRPL_APP_LEDGER_LEDGERTIMING_H_INCLUDED
 
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
 
#include <chrono>
 
namespace ripple {
 
std::chrono::seconds constexpr ledgerPossibleTimeResolutions[] = {
    std::chrono::seconds{10},
    std::chrono::seconds{20},
    std::chrono::seconds{30},
    std::chrono::seconds{60},
    std::chrono::seconds{90},
    std::chrono::seconds{120}};
 
auto constexpr ledgerDefaultTimeResolution = ledgerPossibleTimeResolutions[2];
 
auto constexpr ledgerGenesisTimeResolution = ledgerPossibleTimeResolutions[0];
 
auto constexpr increaseLedgerTimeResolutionEvery = 8;
 
auto constexpr decreaseLedgerTimeResolutionEvery = 1;
 
template <class Rep, class Period, class Seq>
std::chrono::duration<Rep, Period>
getNextLedgerTimeResolution(
    std::chrono::duration<Rep, Period> previousResolution,
    bool previousAgree,
    Seq ledgerSeq)
{
    XRPL_ASSERT(
        ledgerSeq != Seq{0},
        "ripple:getNextLedgerTimeResolution : valid ledger sequence");
 
    using namespace std::chrono;
    // Find the current resolution:
    auto iter = std::find(
        std::begin(ledgerPossibleTimeResolutions),
        std::end(ledgerPossibleTimeResolutions),
        previousResolution);
    XRPL_ASSERT(
        iter != std::end(ledgerPossibleTimeResolutions),
        "ripple:getNextLedgerTimeResolution : found time resolution");
 
    // This should never happen, but just as a precaution
    if (iter == std::end(ledgerPossibleTimeResolutions))
        return previousResolution;
 
    // If we did not previously agree, we try to decrease the resolution to
    // improve the chance that we will agree now.
    if (!previousAgree &&
        (ledgerSeq % Seq{decreaseLedgerTimeResolutionEvery} == Seq{0}))
    {
        if (++iter != std::end(ledgerPossibleTimeResolutions))
            return *iter;
    }
 
    // If we previously agreed, we try to increase the resolution to determine
    // if we can continue to agree.
    if (previousAgree &&
        (ledgerSeq % Seq{increaseLedgerTimeResolutionEvery} == Seq{0}))
    {
        if (iter-- != std::begin(ledgerPossibleTimeResolutions))
            return *iter;
    }
 
    return previousResolution;
}
 
template <class Clock, class Duration, class Rep, class Period>
std::chrono::time_point<Clock, Duration>
roundCloseTime(
    std::chrono::time_point<Clock, Duration> closeTime,
    std::chrono::duration<Rep, Period> closeResolution)
{
    using time_point = decltype(closeTime);
    if (closeTime == time_point{})
        return closeTime;
 
    closeTime += (closeResolution / 2);
    return closeTime - (closeTime.time_since_epoch() % closeResolution);
}
 
template <class Clock, class Duration, class Rep, class Period>
std::chrono::time_point<Clock, Duration>
effCloseTime(
    std::chrono::time_point<Clock, Duration> closeTime,
    std::chrono::duration<Rep, Period> resolution,
    std::chrono::time_point<Clock, Duration> priorCloseTime)
{
    using namespace std::chrono_literals;
    using time_point = decltype(closeTime);
 
    if (closeTime == time_point{})
        return closeTime;
 
    return std::max<time_point>(
        roundCloseTime(closeTime, resolution), (priorCloseTime + 1s));
}
 
}  // namespace ripple
#endif