TimeKeeper.h

#pragma once
 
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/clock/abstract_clock.h>
 
#include <atomic>
#include <chrono>
 
namespace xrpl {

class TimeKeeper : public beast::AbstractClock<NetClock>
{
private:
    std::atomic<std::chrono::seconds> closeOffset_;
 
    // Adjust system_clock::time_point for NetClock epoch
    static constexpr time_point
    adjust(std::chrono::system_clock::time_point when)
    {
        return time_point(
            std::chrono::duration_cast<duration>(when.time_since_epoch() - kEpochOffset));
    }
 
public:
    ~TimeKeeper() override = default;

    [[nodiscard]] time_point
    now() const override
    {
        return adjust(std::chrono::system_clock::now());
    }

    [[nodiscard]] time_point
    closeTime() const
    {
        return now() + closeOffset_.load();
    }
 
    // This may return a negative value
    [[nodiscard]] std::chrono::seconds
    closeOffset() const
    {
        return closeOffset_.load();
    }

    std::chrono::seconds
    adjustCloseTime(std::chrono::seconds by)
    {
        using namespace std::chrono_literals;
 
        auto offset = closeOffset_.load();
 
        if (by == 0s && offset == 0s)
            return offset;
 
        // The close time adjustment is serialized externally to this
        // code. The compare/exchange only serves as a weak check and
        // should not fail. Even if it does, it's safe to simply just
        // skip the adjustment.
        closeOffset_.compare_exchange_strong(offset, [by, offset]() {
            // Ignore small offsets and push the close time
            // towards our wall time.
            if (by > 1s)
                return offset + ((by + 3s) / 4);
 
            if (by < -1s)
                return offset + ((by - 3s) / 4);
 
            return (offset * 3) / 4;
        }());
 
        return closeOffset_.load();
    }
};
 
}  // namespace xrpl