LCOV - code coverage report
Current view: top level - src/util - time.h (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 100.0 % 11 11
Test Date: 2025-04-16 05:11:06 Functions: 95.5 % 22 21
Branches: 37.0 % 54 20

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-present 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 <optional>
      12                 :             : #include <string>
      13                 :             : #include <string_view>
      14                 :             : 
      15                 :             : using namespace std::chrono_literals;
      16                 :             : 
      17                 :             : /** Mockable clock in the context of tests, otherwise the system clock */
      18                 :             : struct NodeClock : public std::chrono::system_clock {
      19                 :             :     using time_point = std::chrono::time_point<NodeClock>;
      20                 :             :     /** Return current system time or mocked time, if set */
      21                 :             :     static time_point now() noexcept;
      22                 :             :     static std::time_t to_time_t(const time_point&) = delete; // unused
      23                 :             :     static time_point from_time_t(std::time_t) = delete;      // unused
      24                 :             : };
      25                 :             : using NodeSeconds = std::chrono::time_point<NodeClock, std::chrono::seconds>;
      26                 :             : 
      27                 :             : using SteadyClock = std::chrono::steady_clock;
      28                 :             : using SteadySeconds = std::chrono::time_point<std::chrono::steady_clock, std::chrono::seconds>;
      29                 :             : using SteadyMilliseconds = std::chrono::time_point<std::chrono::steady_clock, std::chrono::milliseconds>;
      30                 :             : using SteadyMicroseconds = std::chrono::time_point<std::chrono::steady_clock, std::chrono::microseconds>;
      31                 :             : 
      32                 :             : using SystemClock = std::chrono::system_clock;
      33                 :             : 
      34                 :             : /**
      35                 :             :  * Version of SteadyClock that is mockable in the context of tests (set the
      36                 :             :  * current value with SetMockTime), otherwise the system steady clock.
      37                 :             :  */
      38                 :             : struct MockableSteadyClock : public std::chrono::steady_clock {
      39                 :             :     using time_point = std::chrono::time_point<MockableSteadyClock>;
      40                 :             : 
      41                 :             :     using mock_time_point = std::chrono::time_point<MockableSteadyClock, std::chrono::milliseconds>;
      42                 :             :     static constexpr mock_time_point::duration INITIAL_MOCK_TIME{1};
      43                 :             : 
      44                 :             :     /** Return current system time or mocked time, if set */
      45                 :             :     static time_point now() noexcept;
      46                 :             :     static std::time_t to_time_t(const time_point&) = delete; // unused
      47                 :             :     static time_point from_time_t(std::time_t) = delete;      // unused
      48                 :             : 
      49                 :             :     /** Set mock time for testing.
      50                 :             :      * When mocking the steady clock, start at INITIAL_MOCK_TIME and add durations to elapse time as necessary
      51                 :             :      * for testing.
      52                 :             :      * To stop mocking, call ClearMockTime().
      53                 :             :      */
      54                 :             :     static void SetMockTime(mock_time_point::duration mock_time_in);
      55                 :             : 
      56                 :             :     /** Clear mock time, go back to system steady clock. */
      57                 :             :     static void ClearMockTime();
      58                 :             : };
      59                 :             : 
      60                 :             : void UninterruptibleSleep(const std::chrono::microseconds& n);
      61                 :             : 
      62                 :             : /**
      63                 :             :  * Helper to count the seconds of a duration/time_point.
      64                 :             :  *
      65                 :             :  * All durations/time_points should be using std::chrono and calling this should generally
      66                 :             :  * be avoided in code. Though, it is still preferred to an inline t.count() to
      67                 :             :  * protect against a reliance on the exact type of t.
      68                 :             :  *
      69                 :             :  * This helper is used to convert durations/time_points before passing them over an
      70                 :             :  * interface that doesn't support std::chrono (e.g. RPC, debug log, or the GUI)
      71                 :             :  */
      72                 :             : template <typename Dur1, typename Dur2>
      73   [ +  -  +  - ]:    16614384 : constexpr auto Ticks(Dur2 d)
                 [ +  - ]
      74                 :             : {
      75   [ +  -  +  - ]:    16614384 :     return std::chrono::duration_cast<Dur1>(d).count();
                 [ +  - ]
      76                 :             : }
      77                 :             : template <typename Duration, typename Timepoint>
      78                 :     5727109 : constexpr auto TicksSinceEpoch(Timepoint t)
      79                 :             : {
      80                 :     5727109 :     return Ticks<Duration>(t.time_since_epoch());
      81                 :             : }
      82   [ +  -  +  - ]:     1016222 : constexpr int64_t count_seconds(std::chrono::seconds t) { return t.count(); }
           [ +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
           - ][ +  +  #  
          #  #  #  #  #  
          #  #  #  #  #  
           # ][ +  -  -  
                -  -  - ]
      83         [ +  - ]:      460902 : constexpr int64_t count_milliseconds(std::chrono::milliseconds t) { return t.count(); }
      84         [ +  - ]:           1 : constexpr int64_t count_microseconds(std::chrono::microseconds t) { return t.count(); }
      85                 :             : 
      86                 :             : using HoursDouble = std::chrono::duration<double, std::chrono::hours::period>;
      87                 :             : using SecondsDouble = std::chrono::duration<double, std::chrono::seconds::period>;
      88                 :             : using MillisecondsDouble = std::chrono::duration<double, std::chrono::milliseconds::period>;
      89                 :             : 
      90                 :             : /**
      91                 :             :  * DEPRECATED
      92                 :             :  * Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
      93                 :             :  * ClockType is
      94                 :             :  * - SteadyClock/std::chrono::steady_clock for steady time
      95                 :             :  * - SystemClock/std::chrono::system_clock for system time
      96                 :             :  * - NodeClock                             for mockable system time
      97                 :             :  */
      98                 :             : int64_t GetTime();
      99                 :             : 
     100                 :             : /**
     101                 :             :  * DEPRECATED
     102                 :             :  * Use SetMockTime with chrono type
     103                 :             :  *
     104                 :             :  * @param[in] nMockTimeIn Time in seconds.
     105                 :             :  */
     106                 :             : void SetMockTime(int64_t nMockTimeIn);
     107                 :             : 
     108                 :             : /** For testing. Set e.g. with the setmocktime rpc, or -mocktime argument */
     109                 :             : void SetMockTime(std::chrono::seconds mock_time_in);
     110                 :             : 
     111                 :             : /** For testing */
     112                 :             : std::chrono::seconds GetMockTime();
     113                 :             : 
     114                 :             : /**
     115                 :             :  * Return the current time point cast to the given precision. Only use this
     116                 :             :  * when an exact precision is needed, otherwise use T::clock::now() directly.
     117                 :             :  */
     118                 :             : template <typename T>
     119                 :     3060427 : T Now()
     120                 :             : {
     121                 :     3060427 :     return std::chrono::time_point_cast<typename T::duration>(T::clock::now());
     122                 :             : }
     123                 :             : /** DEPRECATED, see GetTime */
     124                 :             : template <typename T>
     125                 :     2869129 : T GetTime()
     126                 :             : {
     127                 :     2869129 :     return Now<std::chrono::time_point<NodeClock, T>>().time_since_epoch();
     128                 :             : }
     129                 :             : 
     130                 :             : /**
     131                 :             :  * ISO 8601 formatting is preferred. Use the FormatISO8601{DateTime,Date}
     132                 :             :  * helper functions if possible.
     133                 :             :  */
     134                 :             : std::string FormatISO8601DateTime(int64_t nTime);
     135                 :             : std::string FormatISO8601Date(int64_t nTime);
     136                 :             : std::optional<int64_t> ParseISO8601DateTime(std::string_view str);
     137                 :             : 
     138                 :             : /**
     139                 :             :  * Convert milliseconds to a struct timeval for e.g. select.
     140                 :             :  */
     141                 :             : struct timeval MillisToTimeval(int64_t nTimeout);
     142                 :             : 
     143                 :             : /**
     144                 :             :  * Convert milliseconds to a struct timeval for e.g. select.
     145                 :             :  */
     146                 :             : struct timeval MillisToTimeval(std::chrono::milliseconds ms);
     147                 :             : 
     148                 :             : #endif // BITCOIN_UTIL_TIME_H
        

Generated by: LCOV version 2.0-1