Line data    Source code

       1             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2             : // Copyright (c) 2009-2022 The Bitcoin Core developers
       3             : // Distributed under the MIT software license, see the accompanying
       4             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5             : 
       6             : #ifndef BITCOIN_UTIL_TIME_H
       7             : #define BITCOIN_UTIL_TIME_H
       8             : 
       9             : #include <chrono> // IWYU pragma: export
      10             : #include <cstdint>
      11             : #include <string>
      12             : 
      13             : using namespace std::chrono_literals;
      14             : 
      15             : /** Mockable clock in the context of tests, otherwise the system clock */
      16             : struct NodeClock : public std::chrono::system_clock {
      17             :     using time_point = std::chrono::time_point<NodeClock>;
      18             :     /** Return current system time or mocked time, if set */
      19             :     static time_point now() noexcept;
      20             :     static std::time_t to_time_t(const time_point&) = delete; // unused
      21             :     static time_point from_time_t(std::time_t) = delete;      // unused
      22             : };
      23             : using NodeSeconds = std::chrono::time_point<NodeClock, std::chrono::seconds>;
      24             : 
      25             : using SteadyClock = std::chrono::steady_clock;
      26             : using SteadySeconds = std::chrono::time_point<std::chrono::steady_clock, std::chrono::seconds>;
      27             : using SteadyMilliseconds = std::chrono::time_point<std::chrono::steady_clock, std::chrono::milliseconds>;
      28             : using SteadyMicroseconds = std::chrono::time_point<std::chrono::steady_clock, std::chrono::microseconds>;
      29             : 
      30             : using SystemClock = std::chrono::system_clock;
      31             : 
      32             : void UninterruptibleSleep(const std::chrono::microseconds& n);
      33             : 
      34             : /**
      35             :  * Helper to count the seconds of a duration/time_point.
      36             :  *
      37             :  * All durations/time_points should be using std::chrono and calling this should generally
      38             :  * be avoided in code. Though, it is still preferred to an inline t.count() to
      39             :  * protect against a reliance on the exact type of t.
      40             :  *
      41             :  * This helper is used to convert durations/time_points before passing them over an
      42             :  * interface that doesn't support std::chrono (e.g. RPC, debug log, or the GUI)
      43             :  */
      44             : template <typename Dur1, typename Dur2>
      45       10123 : constexpr auto Ticks(Dur2 d)
      46             : {
      47       10123 :     return std::chrono::duration_cast<Dur1>(d).count();
      48             : }
      49             : template <typename Duration, typename Timepoint>
      50       21848 : constexpr auto TicksSinceEpoch(Timepoint t)
      51             : {
      52       21848 :     return Ticks<Duration>(t.time_since_epoch());
      53             : }
      54         858 : constexpr int64_t count_seconds(std::chrono::seconds t) { return t.count(); }
      55           0 : constexpr int64_t count_milliseconds(std::chrono::milliseconds t) { return t.count(); }
      56           0 : constexpr int64_t count_microseconds(std::chrono::microseconds t) { return t.count(); }
      57             : 
      58             : using HoursDouble = std::chrono::duration<double, std::chrono::hours::period>;
      59             : using SecondsDouble = std::chrono::duration<double, std::chrono::seconds::period>;
      60             : using MillisecondsDouble = std::chrono::duration<double, std::chrono::milliseconds::period>;
      61             : 
      62             : /**
      63             :  * DEPRECATED
      64             :  * Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
      65             :  * ClockType is
      66             :  * - SteadyClock/std::chrono::steady_clock for steady time
      67             :  * - SystemClock/std::chrono::system_clock for system time
      68             :  * - NodeClock                             for mockable system time
      69             :  */
      70             : int64_t GetTime();
      71             : 
      72             : /**
      73             :  * DEPRECATED
      74             :  * Use SetMockTime with chrono type
      75             :  *
      76             :  * @param[in] nMockTimeIn Time in seconds.
      77             :  */
      78             : void SetMockTime(int64_t nMockTimeIn);
      79             : 
      80             : /** For testing. Set e.g. with the setmocktime rpc, or -mocktime argument */
      81             : void SetMockTime(std::chrono::seconds mock_time_in);
      82             : 
      83             : /** For testing */
      84             : std::chrono::seconds GetMockTime();
      85             : 
      86             : /**
      87             :  * Return the current time point cast to the given precision. Only use this
      88             :  * when an exact precision is needed, otherwise use T::clock::now() directly.
      89             :  */
      90             : template <typename T>
      91       29079 : T Now()
      92             : {
      93       29079 :     return std::chrono::time_point_cast<typename T::duration>(T::clock::now());
      94             : }
      95             : /** DEPRECATED, see GetTime */
      96             : template <typename T>
      97       27872 : T GetTime()
      98             : {
      99       27872 :     return Now<std::chrono::time_point<NodeClock, T>>().time_since_epoch();
     100             : }
     101             : 
     102             : /**
     103             :  * ISO 8601 formatting is preferred. Use the FormatISO8601{DateTime,Date}
     104             :  * helper functions if possible.
     105             :  */
     106             : std::string FormatISO8601DateTime(int64_t nTime);
     107             : std::string FormatISO8601Date(int64_t nTime);
     108             : 
     109             : /**
     110             :  * Convert milliseconds to a struct timeval for e.g. select.
     111             :  */
     112             : struct timeval MillisToTimeval(int64_t nTimeout);
     113             : 
     114             : /**
     115             :  * Convert milliseconds to a struct timeval for e.g. select.
     116             :  */
     117             : struct timeval MillisToTimeval(std::chrono::milliseconds ms);
     118             : 
     119             : /** Sanity check epoch match normal Unix epoch */
     120             : bool ChronoSanityCheck();
     121             : 
     122             : #endif // BITCOIN_UTIL_TIME_H