172 KiB
172 KiB
<html lang="en">
<head>
</head>
</html>
LCOV - code coverage report | ||||||||||||||||||||||
![]() | ||||||||||||||||||||||
|
||||||||||||||||||||||
![]() |
Line data Source code 1 : // chrono::duration and chrono::time_point -*- C++ -*- 2 : 3 : // Copyright (C) 2008-2023 Free Software Foundation, Inc. 4 : // 5 : // This file is part of the GNU ISO C++ Library. This library is free 6 : // software; you can redistribute it and/or modify it under the 7 : // terms of the GNU General Public License as published by the 8 : // Free Software Foundation; either version 3, or (at your option) 9 : // any later version. 10 : 11 : // This library is distributed in the hope that it will be useful, 12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 : // GNU General Public License for more details. 15 : 16 : // Under Section 7 of GPL version 3, you are granted additional 17 : // permissions described in the GCC Runtime Library Exception, version 18 : // 3.1, as published by the Free Software Foundation. 19 : 20 : // You should have received a copy of the GNU General Public License and 21 : // a copy of the GCC Runtime Library Exception along with this program; 22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 : // <http://www.gnu.org/licenses/>. 24 : 25 : /** @file include/bits/chrono.h 26 : * This is an internal header file, included by other library headers. 27 : * Do not attempt to use it directly. @headername{chrono} 28 : */ 29 : 30 : #ifndef _GLIBCXX_CHRONO_H 31 : #define _GLIBCXX_CHRONO_H 1 32 : 33 : #pragma GCC system_header 34 : 35 : #if __cplusplus >= 201103L 36 : 37 : #include <ratio> 38 : #include <type_traits> 39 : #include <limits> 40 : #include <ctime> 41 : #include <bits/parse_numbers.h> // for literals support. 42 : #if __cplusplus >= 202002L 43 : # include <concepts> 44 : # include <compare> 45 : #endif 46 : 47 : namespace std _GLIBCXX_VISIBILITY(default) 48 : { 49 : _GLIBCXX_BEGIN_NAMESPACE_VERSION 50 : 51 : #if __cplusplus >= 201703L 52 : namespace filesystem { struct __file_clock; }; 53 : #endif 54 : 55 : namespace chrono 56 : { 57 : /// @addtogroup chrono 58 : /// @{ 59 : 60 : /// `chrono::duration` represents a distance between two points in time 61 : template<typename _Rep, typename _Period = ratio<1>> 62 : class duration; 63 : 64 : /// `chrono::time_point` represents a point in time as measured by a clock 65 : template<typename _Clock, typename _Dur = typename _Clock::duration> 66 : class time_point; 67 : /// @} 68 : } 69 : 70 : /// @addtogroup chrono 71 : /// @{ 72 : 73 : // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) 74 : 75 : /// @cond undocumented 76 : 77 : template<typename _CT, typename _Period1, typename _Period2, typename = void> 78 : struct __duration_common_type 79 : { }; 80 : 81 : template<typename _CT, typename _Period1, typename _Period2> 82 : struct __duration_common_type<_CT, _Period1, _Period2, 83 : __void_t<typename _CT::type>> 84 : { 85 : private: 86 : using __gcd_num = __static_gcd<_Period1::num, _Period2::num>; 87 : using __gcd_den = __static_gcd<_Period1::den, _Period2::den>; 88 : using __cr = typename _CT::type; 89 : using __r = ratio<__gcd_num::value, 90 : (_Period1::den / __gcd_den::value) * _Period2::den>; 91 : 92 : public: 93 : using type = chrono::duration<__cr, typename __r::type>; 94 : }; 95 : 96 : /// @endcond 97 : 98 : /// @{ 99 : /// @relates chrono::duration 100 : 101 : /// Specialization of common_type for chrono::duration types. 102 : template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> 103 : struct common_type<chrono::duration<_Rep1, _Period1>, 104 : chrono::duration<_Rep2, _Period2>> 105 : : __duration_common_type<common_type<_Rep1, _Rep2>, 106 : typename _Period1::type, 107 : typename _Period2::type> 108 : { }; 109 : 110 : /// Specialization of common_type for two identical chrono::duration types. 111 : template<typename _Rep, typename _Period> 112 : struct common_type<chrono::duration<_Rep, _Period>, 113 : chrono::duration<_Rep, _Period>> 114 : { 115 : using type = chrono::duration<typename common_type<_Rep>::type, 116 : typename _Period::type>; 117 : }; 118 : 119 : /// Specialization of common_type for one chrono::duration type. 120 : template<typename _Rep, typename _Period> 121 : struct common_type<chrono::duration<_Rep, _Period>> 122 : { 123 : using type = chrono::duration<typename common_type<_Rep>::type, 124 : typename _Period::type>; 125 : }; 126 : /// @} 127 : 128 : // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly) 129 : 130 : /// @cond undocumented 131 : 132 : template<typename _CT, typename _Clock, typename = void> 133 : struct __timepoint_common_type 134 : { }; 135 : 136 : template<typename _CT, typename _Clock> 137 : struct __timepoint_common_type<_CT, _Clock, __void_t<typename _CT::type>> 138 : { 139 : using type = chrono::time_point<_Clock, typename _CT::type>; 140 : }; 141 : 142 : /// @endcond 143 : 144 : /// @{ 145 : /// @relates chrono::time_point 146 : 147 : /// Specialization of common_type for chrono::time_point types. 148 : template<typename _Clock, typename _Duration1, typename _Duration2> 149 : struct common_type<chrono::time_point<_Clock, _Duration1>, 150 : chrono::time_point<_Clock, _Duration2>> 151 : : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock> 152 : { }; 153 : 154 : /// Specialization of common_type for two identical chrono::time_point types. 155 : template<typename _Clock, typename _Duration> 156 : struct common_type<chrono::time_point<_Clock, _Duration>, 157 : chrono::time_point<_Clock, _Duration>> 158 : { using type = chrono::time_point<_Clock, _Duration>; }; 159 : 160 : /// Specialization of common_type for one chrono::time_point type. 161 : template<typename _Clock, typename _Duration> 162 : struct common_type<chrono::time_point<_Clock, _Duration>> 163 : { using type = chrono::time_point<_Clock, _Duration>; }; 164 : /// @} 165 : 166 : /// @} group chrono 167 : 168 : namespace chrono 169 : { 170 : /// @addtogroup chrono 171 : /// @{ 172 : 173 : /// @cond undocumented 174 : 175 : // Primary template for duration_cast impl. 176 : template<typename _ToDur, typename _CF, typename _CR, 177 : bool _NumIsOne = false, bool _DenIsOne = false> 178 : struct __duration_cast_impl 179 : { 180 : template<typename _Rep, typename _Period> 181 : static constexpr _ToDur 182 : __cast(const duration<_Rep, _Period>& __d) 183 : { 184 : typedef typename _ToDur::rep __to_rep; 185 : return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) 186 : * static_cast<_CR>(_CF::num) 187 : / static_cast<_CR>(_CF::den))); 188 : } 189 : }; 190 : 191 : template<typename _ToDur, typename _CF, typename _CR> 192 : struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> 193 : { 194 : template<typename _Rep, typename _Period> 195 : static constexpr _ToDur 196 : __cast(const duration<_Rep, _Period>& __d) 197 : { 198 : typedef typename _ToDur::rep __to_rep; 199 : return _ToDur(static_cast<__to_rep>(__d.count())); 200 : } 201 : }; 202 : 203 : template<typename _ToDur, typename _CF, typename _CR> 204 : struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> 205 : { 206 : template<typename _Rep, typename _Period> 207 : static constexpr _ToDur 208 3564 : __cast(const duration<_Rep, _Period>& __d) 209 : { 210 : typedef typename _ToDur::rep __to_rep; 211 7128 : return _ToDur(static_cast<__to_rep>( 212 3564 : static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); 213 : } 214 : }; 215 : 216 : template<typename _ToDur, typename _CF, typename _CR> 217 : struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> 218 : { 219 : template<typename _Rep, typename _Period> 220 : static constexpr _ToDur 221 0 : __cast(const duration<_Rep, _Period>& __d) 222 : { 223 : typedef typename _ToDur::rep __to_rep; 224 0 : return _ToDur(static_cast<__to_rep>( 225 0 : static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); 226 : } 227 : }; 228 : 229 : template<typename _Tp> 230 : struct __is_duration 231 : : std::false_type 232 : { }; 233 : 234 : template<typename _Rep, typename _Period> 235 : struct __is_duration<duration<_Rep, _Period>> 236 : : std::true_type 237 : { }; 238 : 239 : template<typename _Tp> 240 : using __enable_if_is_duration 241 : = typename enable_if<__is_duration<_Tp>::value, _Tp>::type; 242 : 243 : template<typename _Tp> 244 : using __disable_if_is_duration 245 : = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type; 246 : 247 : #if __cplusplus >= 201703L 248 : template<typename _Tp> 249 : inline constexpr bool __is_duration_v = false; 250 : template<typename _Rep, typename _Period> 251 : inline constexpr bool __is_duration_v<duration<_Rep, _Period>> = true; 252 : template<typename _Tp> 253 : inline constexpr bool __is_time_point_v = false; 254 : template<typename _Clock, typename _Dur> 255 : inline constexpr bool __is_time_point_v<time_point<_Clock, _Dur>> = true; 256 : #endif 257 : 258 : /// @endcond 259 : 260 : /** Convert a `duration` to type `ToDur`. 261 : * 262 : * If the duration cannot be represented accurately in the result type, 263 : * returns the result of integer truncation (i.e., rounded towards zero). 264 : * 265 : * @tparam _ToDur The result type must be a `duration`. 266 : * @param __d A duration. 267 : * @return The value of `__d` converted to type `_ToDur`. 268 : * @since C++11 269 : */ 270 : template<typename _ToDur, typename _Rep, typename _Period> 271 : _GLIBCXX_NODISCARD 272 : constexpr __enable_if_is_duration<_ToDur> 273 5900 : duration_cast(const duration<_Rep, _Period>& __d) 274 : { 275 : #if __cpp_inline_variables && __cpp_if_constexpr 276 : if constexpr (is_same_v<_ToDur, duration<_Rep, _Period>>) 277 2336 : return __d; 278 : else 279 : { 280 : #endif 281 : using __to_period = typename _ToDur::period; 282 : using __to_rep = typename _ToDur::rep; 283 : using __cf = ratio_divide<_Period, __to_period>; 284 : using __cr = typename common_type<__to_rep, _Rep, intmax_t>::type; 285 : using __dc = __duration_cast_impl<_ToDur, __cf, __cr, 286 : __cf::num == 1, __cf::den == 1>; 287 3564 : return __dc::__cast(__d); 288 : #if __cpp_inline_variables && __cpp_if_constexpr 289 : } 290 : #endif 291 : } 292 : 293 : /** Trait indicating whether to treat a type as a floating-point type. 294 : * 295 : * The chrono library uses this trait to tell whether a `duration` can 296 : * represent fractional values of the given precision, or only integral 297 : * values. 298 : * 299 : * You should specialize this trait for your own numeric types that are 300 : * used with `duration` and can represent non-integral values. 301 : * 302 : * @since C++11 303 : */ 304 : template<typename _Rep> 305 : struct treat_as_floating_point 306 : : is_floating_point<_Rep> 307 : { }; 308 : 309 : #if __cplusplus > 201402L 310 : template <typename _Rep> 311 : inline constexpr bool treat_as_floating_point_v = 312 : treat_as_floating_point<_Rep>::value; 313 : 314 : template<> 315 : inline constexpr bool treat_as_floating_point_v<int> = false; 316 : template<> 317 : inline constexpr bool treat_as_floating_point_v<long> = false; 318 : template<> 319 : inline constexpr bool treat_as_floating_point_v<long long> = false; 320 : template<> 321 : inline constexpr bool treat_as_floating_point_v<float> = true; 322 : template<> 323 : inline constexpr bool treat_as_floating_point_v<double> = true; 324 : template<> 325 : inline constexpr bool treat_as_floating_point_v<long double> = true; 326 : #endif // C++17 327 : 328 : #if __cplusplus > 201703L 329 : #if __cpp_lib_concepts 330 : template<typename _Tp> 331 : inline constexpr bool is_clock_v = false; 332 : 333 : template<typename _Tp> 334 : requires requires { 335 : typename _Tp::rep; 336 : typename _Tp::period; 337 : typename _Tp::duration; 338 : typename _Tp::time_point::clock; 339 : typename _Tp::time_point::duration; 340 : { &_Tp::is_steady } -> same_as<const bool*>; 341 : { _Tp::now() } -> same_as<typename _Tp::time_point>; 342 : requires same_as<typename _Tp::duration, 343 : duration<typename _Tp::rep, typename _Tp::period>>; 344 : requires same_as<typename _Tp::time_point::duration, 345 : typename _Tp::duration>; 346 : } 347 : inline constexpr bool is_clock_v<_Tp> = true; 348 : #else 349 : template<typename _Tp, typename = void> 350 : inline constexpr bool is_clock_v = false; 351 : 352 : template<typename _Tp> 353 : inline constexpr bool 354 : is_clock_v<_Tp, void_t<typename _Tp::rep, typename _Tp::period, 355 : typename _Tp::duration, 356 : typename _Tp::time_point::duration, 357 : decltype(_Tp::is_steady), 358 : decltype(_Tp::now())>> 359 : = __and_v<is_same<typename _Tp::duration, 360 : duration<typename _Tp::rep, typename _Tp::period>>, 361 : is_same<typename _Tp::time_point::duration, 362 : typename _Tp::duration>, 363 : is_same<decltype(&_Tp::is_steady), const bool*>, 364 : is_same<decltype(_Tp::now()), typename _Tp::time_point>>; 365 : #endif 366 : 367 : template<typename _Tp> 368 : struct is_clock 369 : : bool_constant<is_clock_v<_Tp>> 370 : { }; 371 : #endif // C++20 372 : 373 : #if __cplusplus >= 201703L 374 : # define __cpp_lib_chrono 201611L 375 : 376 : /** Convert a `duration` to type `ToDur` and round down. 377 : * 378 : * If the duration cannot be represented exactly in the result type, 379 : * returns the closest value that is less than the argument. 380 : * 381 : * @tparam _ToDur The result type must be a `duration`. 382 : * @param __d A duration. 383 : * @return The value of `__d` converted to type `_ToDur`. 384 : * @since C++17 385 : */ 386 : template<typename _ToDur, typename _Rep, typename _Period> 387 : [[nodiscard]] constexpr __enable_if_is_duration<_ToDur> 388 : floor(const duration<_Rep, _Period>& __d) 389 : { 390 : auto __to = chrono::duration_cast<_ToDur>(__d); 391 : if (__to > __d) 392 : return __to - _ToDur{1}; 393 : return __to; 394 : } 395 : 396 : /** Convert a `duration` to type `ToDur` and round up. 397 : * 398 : * If the duration cannot be represented exactly in the result type, 399 : * returns the closest value that is greater than the argument. 400 : * 401 : * @tparam _ToDur The result type must be a `duration`. 402 : * @param __d A duration. 403 : * @return The value of `__d` converted to type `_ToDur`. 404 : * @since C++17 405 : */ 406 : template<typename _ToDur, typename _Rep, typename _Period> 407 : [[nodiscard]] constexpr __enable_if_is_duration<_ToDur> 408 : ceil(const duration<_Rep, _Period>& __d) 409 : { 410 : auto __to = chrono::duration_cast<_ToDur>(__d); 411 : if (__to < __d) 412 : return __to + _ToDur{1}; 413 : return __to; 414 : } 415 : 416 : /** Convert a `duration` to type `ToDur` and round to the closest value. 417 : * 418 : * If the duration cannot be represented exactly in the result type, 419 : * returns the closest value, rounding ties to even. 420 : * 421 : * @tparam _ToDur The result type must be a `duration` with a 422 : * non-floating-point `rep` type. 423 : * @param __d A duration. 424 : * @return The value of `__d` converted to type `_ToDur`. 425 : * @since C++17 426 : */ 427 : template <typename _ToDur, typename _Rep, typename _Period> 428 : [[nodiscard]] constexpr 429 : enable_if_t< 430 : __and_<__is_duration<_ToDur>, 431 : __not_<treat_as_floating_point<typename _ToDur::rep>>>::value, 432 : _ToDur> 433 : round(const duration<_Rep, _Period>& __d) 434 : { 435 : _ToDur __t0 = chrono::floor<_ToDur>(__d); 436 : _ToDur __t1 = __t0 + _ToDur{1}; 437 : auto __diff0 = __d - __t0; 438 : auto __diff1 = __t1 - __d; 439 : if (__diff0 == __diff1) 440 : { 441 : if (__t0.count() & 1) 442 : return __t1; 443 : return __t0; 444 : } 445 : else if (__diff0 < __diff1) 446 : return __t0; 447 : return __t1; 448 : } 449 : 450 : /** The absolute (non-negative) value of a duration. 451 : * 452 : * @param __d A duration with a signed `rep` type. 453 : * @return A duration of the same type as the argument, with value |d|. 454 : * @since C++17 455 : */ 456 : template<typename _Rep, typename _Period> 457 : [[nodiscard]] constexpr 458 : enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>> 459 : abs(duration<_Rep, _Period> __d) 460 : { 461 : if (__d >= __d.zero()) 462 : return __d; 463 : return -__d; 464 : } 465 : 466 : // Make chrono::ceil<D> also usable as chrono::__detail::ceil<D>. 467 : namespace __detail { using chrono::ceil; } 468 : 469 : #else // ! C++17 470 : 471 : // We want to use ceil even when compiling for earlier standards versions. 472 : // C++11 only allows a single statement in a constexpr function, so we 473 : // need to move the comparison into a separate function, __ceil_impl. 474 : namespace __detail 475 : { 476 : template<typename _Tp, typename _Up> 477 : constexpr _Tp 478 : __ceil_impl(const _Tp& __t, const _Up& __u) 479 : { 480 : return (__t < __u) ? (__t + _Tp{1}) : __t; 481 : } 482 : 483 : // C++11-friendly version of std::chrono::ceil<D> for internal use. 484 : template<typename _ToDur, typename _Rep, typename _Period> 485 : constexpr _ToDur 486 : ceil(const duration<_Rep, _Period>& __d) 487 : { 488 : return __detail::__ceil_impl(chrono::duration_cast<_ToDur>(__d), __d); 489 : } 490 : } 491 : #endif // C++17 492 : 493 : /// duration_values 494 : template<typename _Rep> 495 : struct duration_values 496 : { 497 : static constexpr _Rep 498 0 : zero() noexcept 499 0 : { return _Rep(0); } 500 : 501 : static constexpr _Rep 502 : max() noexcept 503 : { return numeric_limits<_Rep>::max(); } 504 : 505 : static constexpr _Rep 506 : min() noexcept 507 : { return numeric_limits<_Rep>::lowest(); } 508 : }; 509 : 510 : template<typename _Rep, typename _Period> 511 : class duration 512 : { 513 : static_assert(!__is_duration<_Rep>::value, 514 : "rep cannot be a std::chrono::duration"); 515 : static_assert(__is_ratio<_Period>::value, 516 : "period must be a specialization of std::ratio"); 517 : static_assert(_Period::num > 0, "period must be positive"); 518 : 519 : template<typename _Rep2> 520 : using __is_float = treat_as_floating_point<_Rep2>; 521 : 522 : static constexpr intmax_t 523 : _S_gcd(intmax_t __m, intmax_t __n) noexcept 524 : { 525 : // Duration only allows positive periods so we don't need to 526 : // handle negative values here (unlike __static_gcd and std::gcd). 527 : #if __cplusplus >= 201402L 528 : do 529 : { 530 : intmax_t __rem = __m % __n; 531 : __m = __n; 532 : __n = __rem; 533 : } 534 : while (__n != 0); 535 : return __m; 536 : #else 537 : // C++11 doesn't allow loops in constexpr functions, but this 538 : // recursive version can be more expensive to evaluate. 539 : return (__n == 0) ? __m : _S_gcd(__n, __m % __n); 540 : #endif 541 : } 542 : 543 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 544 : // 2094. overflow shouldn't participate in overload resolution 545 : // 3090. What is [2094] intended to mean? 546 : // This only produces a valid type if no overflow occurs. 547 : template<typename _R1, typename _R2, 548 : intmax_t __gcd1 = _S_gcd(_R1::num, _R2::num), 549 : intmax_t __gcd2 = _S_gcd(_R1::den, _R2::den)> 550 : using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2), 551 : (_R1::den / __gcd2) * (_R2::num / __gcd1)>; 552 : 553 : // _Period2 is an exact multiple of _Period 554 : template<typename _Period2> 555 : using __is_harmonic 556 : = __bool_constant<__divide<_Period2, _Period>::den == 1>; 557 : 558 : public: 559 : 560 : using rep = _Rep; 561 : using period = typename _Period::type; 562 : 563 : // 20.11.5.1 construction / copy / destroy 564 : constexpr duration() = default; 565 : 566 : duration(const duration&) = default; 567 : 568 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 569 : // 3050. Conversion specification problem in chrono::duration 570 : template<typename _Rep2, typename = _Require< 571 : is_convertible<const _Rep2&, rep>, 572 : __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>> 573 5346 : constexpr explicit duration(const _Rep2& __rep) 574 5346 : : __r(static_cast<rep>(__rep)) { } 575 : 576 : template<typename _Rep2, typename _Period2, typename = _Require< 577 : is_convertible<const _Rep2&, rep>, 578 : __or_<__is_float<rep>, 579 : __and_<__is_harmonic<_Period2>, 580 : __not_<__is_float<_Rep2>>>>>> 581 0 : constexpr duration(const duration<_Rep2, _Period2>& __d) 582 0 : : __r(duration_cast<duration>(__d).count()) { } 583 : 584 : ~duration() = default; 585 : duration& operator=(const duration&) = default; 586 : 587 : // 20.11.5.2 observer 588 : constexpr rep 589 13028 : count() const 590 13028 : { return __r; } 591 : 592 : // 20.11.5.3 arithmetic 593 : 594 : constexpr duration<typename common_type<rep>::type, period> 595 : operator+() const 596 : { return duration<typename common_type<rep>::type, period>(__r); } 597 : 598 : constexpr duration<typename common_type<rep>::type, period> 599 : operator-() const 600 : { return duration<typename common_type<rep>::type, period>(-__r); } 601 : 602 : _GLIBCXX17_CONSTEXPR duration& 603 : operator++() 604 : { 605 : ++__r; 606 : return *this; 607 : } 608 : 609 : _GLIBCXX17_CONSTEXPR duration 610 : operator++(int) 611 : { return duration(__r++); } 612 : 613 : _GLIBCXX17_CONSTEXPR duration& 614 : operator--() 615 : { 616 : --__r; 617 : return *this; 618 : } 619 : 620 : _GLIBCXX17_CONSTEXPR duration 621 : operator--(int) 622 : { return duration(__r--); } 623 : 624 : _GLIBCXX17_CONSTEXPR duration& 625 : operator+=(const duration& __d) 626 : { 627 : __r += __d.count(); 628 : return *this; 629 : } 630 : 631 : _GLIBCXX17_CONSTEXPR duration& 632 : operator-=(const duration& __d) 633 : { 634 : __r -= __d.count(); 635 : return *this; 636 : } 637 : 638 : _GLIBCXX17_CONSTEXPR duration& 639 : operator*=(const rep& __rhs) 640 : { 641 : __r *= __rhs; 642 : return *this; 643 : } 644 : 645 : _GLIBCXX17_CONSTEXPR duration& 646 : operator/=(const rep& __rhs) 647 : { 648 : __r /= __rhs; 649 : return *this; 650 : } 651 : 652 : // DR 934. 653 : template<typename _Rep2 = rep> 654 : _GLIBCXX17_CONSTEXPR 655 : __enable_if_t<!treat_as_floating_point<_Rep2>::value, duration&> 656 : operator%=(const rep& __rhs) 657 : { 658 : __r %= __rhs; 659 : return *this; 660 : } 661 : 662 : template<typename _Rep2 = rep> 663 : _GLIBCXX17_CONSTEXPR 664 : __enable_if_t<!treat_as_floating_point<_Rep2>::value, duration&> 665 : operator%=(const duration& __d) 666 : { 667 : __r %= __d.count(); 668 : return *this; 669 : } 670 : 671 : // 20.11.5.4 special values 672 : static constexpr duration 673 0 : zero() noexcept 674 0 : { return duration(duration_values<rep>::zero()); } 675 : 676 : static constexpr duration 677 : min() noexcept 678 : { return duration(duration_values<rep>::min()); } 679 : 680 : static constexpr duration 681 : max() noexcept 682 : { return duration(duration_values<rep>::max()); } 683 : 684 : private: 685 : rep __r; 686 : }; 687 : 688 : /// @{ 689 : /// @relates std::chrono::duration 690 : 691 : /// The sum of two durations. 692 : template<typename _Rep1, typename _Period1, 693 : typename _Rep2, typename _Period2> 694 : constexpr typename common_type<duration<_Rep1, _Period1>, 695 : duration<_Rep2, _Period2>>::type 696 : operator+(const duration<_Rep1, _Period1>& __lhs, 697 : const duration<_Rep2, _Period2>& __rhs) 698 : { 699 : typedef duration<_Rep1, _Period1> __dur1; 700 : typedef duration<_Rep2, _Period2> __dur2; 701 : typedef typename common_type<__dur1,__dur2>::type __cd; 702 : return __cd(__cd(__lhs).count() + __cd(__rhs).count()); 703 : } 704 : 705 : /// The difference between two durations. 706 : template<typename _Rep1, typename _Period1, 707 : typename _Rep2, typename _Period2> 708 : constexpr typename common_type<duration<_Rep1, _Period1>, 709 : duration<_Rep2, _Period2>>::type 710 1782 : operator-(const duration<_Rep1, _Period1>& __lhs, 711 : const duration<_Rep2, _Period2>& __rhs) 712 : { 713 : typedef duration<_Rep1, _Period1> __dur1; 714 : typedef duration<_Rep2, _Period2> __dur2; 715 : typedef typename common_type<__dur1,__dur2>::type __cd; 716 1782 : return __cd(__cd(__lhs).count() - __cd(__rhs).count()); 717 : } 718 : 719 : /// @} 720 : 721 : /// @cond undocumented 722 : 723 : // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2 724 : // is implicitly convertible to it. 725 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 726 : // 3050. Conversion specification problem in chrono::duration constructor 727 : template<typename _Rep1, typename _Rep2, 728 : typename _CRep = typename common_type<_Rep1, _Rep2>::type> 729 : using __common_rep_t = typename 730 : enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type; 731 : 732 : /// @endcond 733 : 734 : /** @{ 735 : * Arithmetic operators for chrono::duration 736 : * @relates std::chrono::duration 737 : */ 738 : 739 : template<typename _Rep1, typename _Period, typename _Rep2> 740 : constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period> 741 : operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 742 : { 743 : typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 744 : __cd; 745 : return __cd(__cd(__d).count() * __s); 746 : } 747 : 748 : template<typename _Rep1, typename _Rep2, typename _Period> 749 : constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period> 750 : operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 751 : { return __d * __s; } 752 : 753 : template<typename _Rep1, typename _Period, typename _Rep2> 754 : constexpr 755 : duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> 756 : operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 757 : { 758 : typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 759 : __cd; 760 : return __cd(__cd(__d).count() / __s); 761 : } 762 : 763 : template<typename _Rep1, typename _Period1, 764 : typename _Rep2, typename _Period2> 765 : constexpr typename common_type<_Rep1, _Rep2>::type 766 : operator/(const duration<_Rep1, _Period1>& __lhs, 767 : const duration<_Rep2, _Period2>& __rhs) 768 : { 769 : typedef duration<_Rep1, _Period1> __dur1; 770 : typedef duration<_Rep2, _Period2> __dur2; 771 : typedef typename common_type<__dur1,__dur2>::type __cd; 772 : return __cd(__lhs).count() / __cd(__rhs).count(); 773 : } 774 : 775 : // DR 934. 776 : template<typename _Rep1, typename _Period, typename _Rep2> 777 : constexpr 778 : duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> 779 : operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 780 : { 781 : typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 782 : __cd; 783 : return __cd(__cd(__d).count() % __s); 784 : } 785 : 786 : template<typename _Rep1, typename _Period1, 787 : typename _Rep2, typename _Period2> 788 : constexpr typename common_type<duration<_Rep1, _Period1>, 789 : duration<_Rep2, _Period2>>::type 790 : operator%(const duration<_Rep1, _Period1>& __lhs, 791 : const duration<_Rep2, _Period2>& __rhs) 792 : { 793 : typedef duration<_Rep1, _Period1> __dur1; 794 : typedef duration<_Rep2, _Period2> __dur2; 795 : typedef typename common_type<__dur1,__dur2>::type __cd; 796 : return __cd(__cd(__lhs).count() % __cd(__rhs).count()); 797 : } 798 : /// @} 799 : 800 : // comparisons 801 : 802 : /** @{ 803 : * Comparisons for chrono::duration 804 : * @relates std::chrono::duration 805 : */ 806 : 807 : template<typename _Rep1, typename _Period1, 808 : typename _Rep2, typename _Period2> 809 : constexpr bool 810 : operator==(const duration<_Rep1, _Period1>& __lhs, 811 : const duration<_Rep2, _Period2>& __rhs) 812 : { 813 : typedef duration<_Rep1, _Period1> __dur1; 814 : typedef duration<_Rep2, _Period2> __dur2; 815 : typedef typename common_type<__dur1,__dur2>::type __ct; 816 : return __ct(__lhs).count() == __ct(__rhs).count(); 817 : } 818 : 819 : template<typename _Rep1, typename _Period1, 820 : typename _Rep2, typename _Period2> 821 : constexpr bool 822 0 : operator<(const duration<_Rep1, _Period1>& __lhs, 823 : const duration<_Rep2, _Period2>& __rhs) 824 : { 825 : typedef duration<_Rep1, _Period1> __dur1; 826 : typedef duration<_Rep2, _Period2> __dur2; 827 : typedef typename common_type<__dur1,__dur2>::type __ct; 828 0 : return __ct(__lhs).count() < __ct(__rhs).count(); 829 : } 830 : 831 : #if __cpp_lib_three_way_comparison 832 : template<typename _Rep1, typename _Period1, 833 : typename _Rep2, typename _Period2> 834 : requires three_way_comparable<common_type_t<_Rep1, _Rep2>> 835 : constexpr auto 836 : operator<=>(const duration<_Rep1, _Period1>& __lhs, 837 : const duration<_Rep2, _Period2>& __rhs) 838 : { 839 : using __ct = common_type_t<duration<_Rep1, _Period1>, 840 : duration<_Rep2, _Period2>>; 841 : return __ct(__lhs).count() <=> __ct(__rhs).count(); 842 : } 843 : #else 844 : template<typename _Rep1, typename _Period1, 845 : typename _Rep2, typename _Period2> 846 : constexpr bool 847 : operator!=(const duration<_Rep1, _Period1>& __lhs, 848 : const duration<_Rep2, _Period2>& __rhs) 849 : { return !(__lhs == __rhs); } 850 : #endif 851 : 852 : template<typename _Rep1, typename _Period1, 853 : typename _Rep2, typename _Period2> 854 : constexpr bool 855 0 : operator<=(const duration<_Rep1, _Period1>& __lhs, 856 : const duration<_Rep2, _Period2>& __rhs) 857 0 : { return !(__rhs < __lhs); } 858 : 859 : template<typename _Rep1, typename _Period1, 860 : typename _Rep2, typename _Period2> 861 : constexpr bool 862 : operator>(const duration<_Rep1, _Period1>& __lhs, 863 : const duration<_Rep2, _Period2>& __rhs) 864 : { return __rhs < __lhs; } 865 : 866 : template<typename _Rep1, typename _Period1, 867 : typename _Rep2, typename _Period2> 868 : constexpr bool 869 : operator>=(const duration<_Rep1, _Period1>& __lhs, 870 : const duration<_Rep2, _Period2>& __rhs) 871 : { return !(__lhs < __rhs); } 872 : 873 : /// @} 874 : 875 : /// @cond undocumented 876 : #ifdef _GLIBCXX_USE_C99_STDINT_TR1 877 : # define _GLIBCXX_CHRONO_INT64_T int64_t 878 : #elif defined __INT64_TYPE__ 879 : # define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__ 880 : #else 881 : static_assert(std::numeric_limits<unsigned long long>::digits >= 64, 882 : "Representation type for nanoseconds must have at least 64 bits"); 883 : # define _GLIBCXX_CHRONO_INT64_T long long 884 : #endif 885 : /// @endcond 886 : 887 : /// nanoseconds 888 : using nanoseconds = duration<_GLIBCXX_CHRONO_INT64_T, nano>; 889 : 890 : /// microseconds 891 : using microseconds = duration<_GLIBCXX_CHRONO_INT64_T, micro>; 892 : 893 : /// milliseconds 894 : using milliseconds = duration<_GLIBCXX_CHRONO_INT64_T, milli>; 895 : 896 : /// seconds 897 : using seconds = duration<_GLIBCXX_CHRONO_INT64_T>; 898 : 899 : /// minutes 900 : using minutes = duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>>; 901 : 902 : /// hours 903 : using hours = duration<_GLIBCXX_CHRONO_INT64_T, ratio<3600>>; 904 : 905 : #if __cplusplus > 201703L 906 : /// days 907 : using days = duration<_GLIBCXX_CHRONO_INT64_T, ratio<86400>>; 908 : 909 : /// weeks 910 : using weeks = duration<_GLIBCXX_CHRONO_INT64_T, ratio<604800>>; 911 : 912 : /// years 913 : using years = duration<_GLIBCXX_CHRONO_INT64_T, ratio<31556952>>; 914 : 915 : /// months 916 : using months = duration<_GLIBCXX_CHRONO_INT64_T, ratio<2629746>>; 917 : #endif // C++20 918 : 919 : #undef _GLIBCXX_CHRONO_INT64_T 920 : 921 : template<typename _Clock, typename _Dur> 922 : class time_point 923 : { 924 : static_assert(__is_duration<_Dur>::value, 925 : "duration must be a specialization of std::chrono::duration"); 926 : 927 : public: 928 : typedef _Clock clock; 929 : typedef _Dur duration; 930 : typedef typename duration::rep rep; 931 : typedef typename duration::period period; 932 : 933 : constexpr time_point() : __d(duration::zero()) 934 : { } 935 : 936 : constexpr explicit time_point(const duration& __dur) 937 : : __d(__dur) 938 : { } 939 : 940 : // conversions 941 : template<typename _Dur2, 942 : typename = _Require<is_convertible<_Dur2, _Dur>>> 943 : constexpr time_point(const time_point<clock, _Dur2>& __t) 944 : : __d(__t.time_since_epoch()) 945 : { } 946 : 947 : // observer 948 : constexpr duration 949 7682 : time_since_epoch() const 950 7682 : { return __d; } 951 : 952 : #if __cplusplus > 201703L 953 : constexpr time_point& 954 : operator++() 955 : { 956 : ++__d; 957 : return *this; 958 : } 959 : 960 : constexpr time_point 961 : operator++(int) 962 : { return time_point{__d++}; } 963 : 964 : constexpr time_point& 965 : operator--() 966 : { 967 : --__d; 968 : return *this; 969 : } 970 : 971 : constexpr time_point 972 : operator--(int) 973 : { return time_point{__d--}; } 974 : #endif 975 : 976 : // arithmetic 977 : _GLIBCXX17_CONSTEXPR time_point& 978 : operator+=(const duration& __dur) 979 : { 980 : __d += __dur; 981 : return *this; 982 : } 983 : 984 : _GLIBCXX17_CONSTEXPR time_point& 985 : operator-=(const duration& __dur) 986 : { 987 : __d -= __dur; 988 : return *this; 989 : } 990 : 991 : // special values 992 : static constexpr time_point 993 : min() noexcept 994 : { return time_point(duration::min()); } 995 : 996 : static constexpr time_point 997 : max() noexcept 998 : { return time_point(duration::max()); } 999 : 1000 : private: 1001 : duration __d; 1002 : }; 1003 : 1004 : /** Convert a `time_point` to use `duration` type `ToDur`. 1005 : * 1006 : * The result is the same time point as measured by the same clock, but 1007 : * using the specified `duration` to represent the time. 1008 : * If the time point cannot be represented accurately in the result type, 1009 : * returns the result of integer truncation (i.e., rounded towards zero). 1010 : * 1011 : * @tparam _ToDur The `duration` type to use for the result. 1012 : * @param __t A time point. 1013 : * @return The value of `__t` converted to use type `_ToDur`. 1014 : * @since C++11 1015 : */ 1016 : template<typename _ToDur, typename _Clock, typename _Dur> 1017 : _GLIBCXX_NODISCARD constexpr 1018 : __enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> 1019 : time_point_cast(const time_point<_Clock, _Dur>& __t) 1020 : { 1021 : typedef time_point<_Clock, _ToDur> __time_point; 1022 : return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); 1023 : } 1024 : 1025 : #if __cplusplus > 201402L 1026 : /** Convert a `time_point` to type `ToDur` and round down. 1027 : * 1028 : * The result is the same time point as measured by the same clock, but 1029 : * using the specified `duration` to represent the time. 1030 : * If the time point cannot be represented exactly in the result type, 1031 : * returns the closest value that is less than the argument. 1032 : * 1033 : * @tparam _ToDur The `duration` type to use for the result. 1034 : * @param __t A time point. 1035 : * @return The value of `__d` converted to type `_ToDur`. 1036 : * @since C++17 1037 : */ 1038 : template<typename _ToDur, typename _Clock, typename _Dur> 1039 : [[nodiscard]] constexpr 1040 : enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>> 1041 : floor(const time_point<_Clock, _Dur>& __tp) 1042 : { 1043 : return time_point<_Clock, _ToDur>{ 1044 : chrono::floor<_ToDur>(__tp.time_since_epoch())}; 1045 : } 1046 : 1047 : /** Convert a `time_point` to type `ToDur` and round up. 1048 : * 1049 : * The result is the same time point as measured by the same clock, but 1050 : * using the specified `duration` to represent the time. 1051 : * If the time point cannot be represented exactly in the result type, 1052 : * returns the closest value that is greater than the argument. 1053 : * 1054 : * @tparam _ToDur The `duration` type to use for the result. 1055 : * @param __t A time point. 1056 : * @return The value of `__d` converted to type `_ToDur`. 1057 : * @since C++17 1058 : */ 1059 : template<typename _ToDur, typename _Clock, typename _Dur> 1060 : [[nodiscard]] constexpr 1061 : enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>> 1062 : ceil(const time_point<_Clock, _Dur>& __tp) 1063 : { 1064 : return time_point<_Clock, _ToDur>{ 1065 : chrono::ceil<_ToDur>(__tp.time_since_epoch())}; 1066 : } 1067 : 1068 : /** Convert a `time_point` to type `ToDur` and round to the closest value. 1069 : * 1070 : * The result is the same time point as measured by the same clock, but 1071 : * using the specified `duration` to represent the time. 1072 : * If the time point cannot be represented exactly in the result type, 1073 : * returns the closest value, rounding ties to even. 1074 : * 1075 : * @tparam _ToDur The `duration` type to use for the result, 1076 : * which must have a non-floating-point `rep` type. 1077 : * @param __t A time point. 1078 : * @return The value of `__d` converted to type `_ToDur`. 1079 : * @since C++17 1080 : */ 1081 : template<typename _ToDur, typename _Clock, typename _Dur> 1082 : [[nodiscard]] constexpr 1083 : enable_if_t<__is_duration_v<_ToDur> 1084 : && !treat_as_floating_point_v<typename _ToDur::rep>, 1085 : time_point<_Clock, _ToDur>> 1086 : round(const time_point<_Clock, _Dur>& __tp) 1087 : { 1088 : return time_point<_Clock, _ToDur>{ 1089 : chrono::round<_ToDur>(__tp.time_since_epoch())}; 1090 : } 1091 : #endif // C++17 1092 : 1093 : /// @{ 1094 : /// @relates time_point 1095 : 1096 : /// Adjust a time point forwards by the given duration. 1097 : template<typename _Clock, typename _Dur1, 1098 : typename _Rep2, typename _Period2> 1099 : constexpr time_point<_Clock, 1100 : typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 1101 : operator+(const time_point<_Clock, _Dur1>& __lhs, 1102 : const duration<_Rep2, _Period2>& __rhs) 1103 : { 1104 : typedef duration<_Rep2, _Period2> __dur2; 1105 : typedef typename common_type<_Dur1,__dur2>::type __ct; 1106 : typedef time_point<_Clock, __ct> __time_point; 1107 : return __time_point(__lhs.time_since_epoch() + __rhs); 1108 : } 1109 : 1110 : /// Adjust a time point forwards by the given duration. 1111 : template<typename _Rep1, typename _Period1, 1112 : typename _Clock, typename _Dur2> 1113 : constexpr time_point<_Clock, 1114 : typename common_type<duration<_Rep1, _Period1>, _Dur2>::type> 1115 : operator+(const duration<_Rep1, _Period1>& __lhs, 1116 : const time_point<_Clock, _Dur2>& __rhs) 1117 : { 1118 : typedef duration<_Rep1, _Period1> __dur1; 1119 : typedef typename common_type<__dur1,_Dur2>::type __ct; 1120 : typedef time_point<_Clock, __ct> __time_point; 1121 : return __time_point(__rhs.time_since_epoch() + __lhs); 1122 : } 1123 : 1124 : /// Adjust a time point backwards by the given duration. 1125 : template<typename _Clock, typename _Dur1, 1126 : typename _Rep2, typename _Period2> 1127 : constexpr time_point<_Clock, 1128 : typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 1129 : operator-(const time_point<_Clock, _Dur1>& __lhs, 1130 : const duration<_Rep2, _Period2>& __rhs) 1131 : { 1132 : typedef duration<_Rep2, _Period2> __dur2; 1133 : typedef typename common_type<_Dur1,__dur2>::type __ct; 1134 : typedef time_point<_Clock, __ct> __time_point; 1135 : return __time_point(__lhs.time_since_epoch() -__rhs); 1136 : } 1137 : 1138 : /// The difference between two time points (as a duration) 1139 : template<typename _Clock, typename _Dur1, typename _Dur2> 1140 : constexpr typename common_type<_Dur1, _Dur2>::type 1141 1782 : operator-(const time_point<_Clock, _Dur1>& __lhs, 1142 : const time_point<_Clock, _Dur2>& __rhs) 1143 1782 : { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } 1144 : /// @} 1145 : 1146 : /** @{ 1147 : * Comparisons for time_point 1148 : * @relates chrono::time_point 1149 : */ 1150 : 1151 : template<typename _Clock, typename _Dur1, typename _Dur2> 1152 : constexpr bool 1153 : operator==(const time_point<_Clock, _Dur1>& __lhs, 1154 : const time_point<_Clock, _Dur2>& __rhs) 1155 : { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } 1156 : 1157 : #if __cpp_lib_three_way_comparison 1158 : template<typename _Clock, typename _Dur1, 1159 : three_way_comparable_with<_Dur1> _Dur2> 1160 : constexpr auto 1161 : operator<=>(const time_point<_Clock, _Dur1>& __lhs, 1162 : const time_point<_Clock, _Dur2>& __rhs) 1163 : { return __lhs.time_since_epoch() <=> __rhs.time_since_epoch(); } 1164 : #else 1165 : template<typename _Clock, typename _Dur1, typename _Dur2> 1166 : constexpr bool 1167 : operator!=(const time_point<_Clock, _Dur1>& __lhs, 1168 : const time_point<_Clock, _Dur2>& __rhs) 1169 : { return !(__lhs == __rhs); } 1170 : #endif 1171 : 1172 : template<typename _Clock, typename _Dur1, typename _Dur2> 1173 : constexpr bool 1174 : operator<(const time_point<_Clock, _Dur1>& __lhs, 1175 : const time_point<_Clock, _Dur2>& __rhs) 1176 : { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } 1177 : 1178 : template<typename _Clock, typename _Dur1, typename _Dur2> 1179 : constexpr bool 1180 : operator<=(const time_point<_Clock, _Dur1>& __lhs, 1181 : const time_point<_Clock, _Dur2>& __rhs) 1182 : { return !(__rhs < __lhs); } 1183 : 1184 : template<typename _Clock, typename _Dur1, typename _Dur2> 1185 : constexpr bool 1186 : operator>(const time_point<_Clock, _Dur1>& __lhs, 1187 : const time_point<_Clock, _Dur2>& __rhs) 1188 : { return __rhs < __lhs; } 1189 : 1190 : template<typename _Clock, typename _Dur1, typename _Dur2> 1191 : constexpr bool 1192 : operator>=(const time_point<_Clock, _Dur1>& __lhs, 1193 : const time_point<_Clock, _Dur2>& __rhs) 1194 : { return !(__lhs < __rhs); } 1195 : 1196 : /// @} 1197 : /// @} group chrono 1198 : 1199 : // Clocks. 1200 : 1201 : // Why nanosecond resolution as the default? 1202 : // Why have std::system_clock always count in the highest 1203 : // resolution (ie nanoseconds), even if on some OSes the low 3 1204 : // or 9 decimal digits will be always zero? This allows later 1205 : // implementations to change the system_clock::now() 1206 : // implementation any time to provide better resolution without 1207 : // changing function signature or units. 1208 : 1209 : // To support the (forward) evolution of the library's defined 1210 : // clocks, wrap inside inline namespace so that the current 1211 : // defintions of system_clock, steady_clock, and 1212 : // high_resolution_clock types are uniquely mangled. This way, new 1213 : // code can use the latests clocks, while the library can contain 1214 : // compatibility definitions for previous versions. At some 1215 : // point, when these clocks settle down, the inlined namespaces 1216 : // can be removed. XXX GLIBCXX_ABI Deprecated 1217 : _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) 1218 : 1219 : /** 1220 : * @brief System clock. 1221 : * 1222 : * Time returned represents wall time from the system-wide clock. 1223 : * @ingroup chrono 1224 : */ 1225 : struct system_clock 1226 : { 1227 : typedef chrono::nanoseconds duration; 1228 : typedef duration::rep rep; 1229 : typedef duration::period period; 1230 : typedef chrono::time_point<system_clock, duration> time_point; 1231 : 1232 : static_assert(system_clock::duration::min() 1233 : < system_clock::duration::zero(), 1234 : "a clock's minimum duration cannot be less than its epoch"); 1235 : 1236 : static constexpr bool is_steady = false; 1237 : 1238 : static time_point 1239 : now() noexcept; 1240 : 1241 : // Map to C API 1242 : static std::time_t 1243 : to_time_t(const time_point& __t) noexcept 1244 : { 1245 : return std::time_t(duration_cast<chrono::seconds> 1246 : (__t.time_since_epoch()).count()); 1247 : } 1248 : 1249 : static time_point 1250 : from_time_t(std::time_t __t) noexcept 1251 : { 1252 : typedef chrono::time_point<system_clock, seconds> __from; 1253 : return time_point_cast<system_clock::duration> 1254 : (__from(chrono::seconds(__t))); 1255 : } 1256 : }; 1257 : 1258 : 1259 : /** 1260 : * @brief Monotonic clock 1261 : * 1262 : * Time returned has the property of only increasing at a uniform rate. 1263 : * @ingroup chrono 1264 : */ 1265 : struct steady_clock 1266 : { 1267 : typedef chrono::nanoseconds duration; 1268 : typedef duration::rep rep; 1269 : typedef duration::period period; 1270 : typedef chrono::time_point<steady_clock, duration> time_point; 1271 : 1272 : static constexpr bool is_steady = true; 1273 : 1274 : static time_point 1275 : now() noexcept; 1276 : }; 1277 : 1278 : 1279 : /** 1280 : * @brief Highest-resolution clock 1281 : * 1282 : * This is the clock "with the shortest tick period." Alias to 1283 : * std::system_clock until higher-than-nanosecond definitions 1284 : * become feasible. 1285 : * @ingroup chrono 1286 : */ 1287 : using high_resolution_clock = system_clock; 1288 : 1289 : _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) 1290 : 1291 : #if __cplusplus >= 202002L 1292 : /// @addtogroup chrono 1293 : /// @{ 1294 : template<typename _Duration> 1295 : using sys_time = time_point<system_clock, _Duration>; 1296 : using sys_seconds = sys_time<seconds>; 1297 : using sys_days = sys_time<days>; 1298 : 1299 : using file_clock = ::std::filesystem::__file_clock; 1300 : 1301 : template<typename _Duration> 1302 : using file_time = time_point<file_clock, _Duration>; 1303 : 1304 : template<> struct is_clock<system_clock> : true_type { }; 1305 : template<> struct is_clock<steady_clock> : true_type { }; 1306 : template<> struct is_clock<file_clock> : true_type { }; 1307 : 1308 : template<> inline constexpr bool is_clock_v<system_clock> = true; 1309 : template<> inline constexpr bool is_clock_v<steady_clock> = true; 1310 : template<> inline constexpr bool is_clock_v<file_clock> = true; 1311 : /// @} 1312 : #endif // C++20 1313 : } // namespace chrono 1314 : 1315 : #if __cplusplus >= 201402L 1316 : #define __cpp_lib_chrono_udls 201304L 1317 : 1318 : inline namespace literals 1319 : { 1320 : /** ISO C++ 2014 namespace for suffixes for duration literals. 1321 : * 1322 : * These suffixes can be used to create `chrono::duration` values with 1323 : * tick periods of hours, minutes, seconds, milliseconds, microseconds 1324 : * or nanoseconds. For example, `std::chrono::seconds(5)` can be written 1325 : * as `5s` after making the suffix visible in the current scope. 1326 : * The suffixes can be made visible by a using-directive or 1327 : * using-declaration such as: 1328 : * - `using namespace std::chrono_literals;` 1329 : * - `using namespace std::literals;` 1330 : * - `using namespace std::chrono;` 1331 : * - `using namespace std;` 1332 : * - `using std::chrono_literals::operator""s;` 1333 : * 1334 : * The result of these suffixes on an integer literal is one of the 1335 : * standard typedefs such as `std::chrono::hours`. 1336 : * The result on a floating-point literal is a duration type with the 1337 : * specified tick period and an unspecified floating-point representation, 1338 : * for example `1.5e2ms` might be equivalent to 1339 : * `chrono::duration<long double, chrono::milli>(1.5e2)`. 1340 : * 1341 : * @since C+14 1342 : * @ingroup chrono 1343 : */ 1344 : inline namespace chrono_literals 1345 : { 1346 : /// @addtogroup chrono 1347 : /// @{ 1348 : 1349 : #pragma GCC diagnostic push 1350 : #pragma GCC diagnostic ignored "-Wliteral-suffix" 1351 : /// @cond undocumented 1352 : template<typename _Dur, char... _Digits> 1353 : constexpr _Dur __check_overflow() 1354 : { 1355 : using _Val = __parse_int::_Parse_int<_Digits...>; 1356 : constexpr typename _Dur::rep __repval = _Val::value; 1357 : static_assert(__repval >= 0 && __repval == _Val::value, 1358 : "literal value cannot be represented by duration type"); 1359 : return _Dur(__repval); 1360 : } 1361 : /// @endcond 1362 : 1363 : /// Literal suffix for durations representing non-integer hours 1364 : constexpr chrono::duration<long double, ratio<3600,1>> 1365 : operator""h(long double __hours) 1366 : { return chrono::duration<long double, ratio<3600,1>>{__hours}; } 1367 : 1368 : /// Literal suffix for durations of type `std::chrono::hours` 1369 : template <char... _Digits> 1370 : constexpr chrono::hours 1371 : operator""h() 1372 : { return __check_overflow<chrono::hours, _Digits...>(); } 1373 : 1374 : /// Literal suffix for durations representing non-integer minutes 1375 : constexpr chrono::duration<long double, ratio<60,1>> 1376 : operator""min(long double __mins) 1377 : { return chrono::duration<long double, ratio<60,1>>{__mins}; } 1378 : 1379 : /// Literal suffix for durations of type `std::chrono::minutes` 1380 : template <char... _Digits> 1381 : constexpr chrono::minutes 1382 : operator""min() 1383 : { return __check_overflow<chrono::minutes, _Digits...>(); } 1384 : 1385 : /// Literal suffix for durations representing non-integer seconds 1386 : constexpr chrono::duration<long double> 1387 : operator""s(long double __secs) 1388 : { return chrono::duration<long double>{__secs}; } 1389 : 1390 : /// Literal suffix for durations of type `std::chrono::seconds` 1391 : template <char... _Digits> 1392 : constexpr chrono::seconds 1393 : operator""s() 1394 : { return __check_overflow<chrono::seconds, _Digits...>(); } 1395 : 1396 : /// Literal suffix for durations representing non-integer milliseconds 1397 : constexpr chrono::duration<long double, milli> 1398 : operator""ms(long double __msecs) 1399 : { return chrono::duration<long double, milli>{__msecs}; } 1400 : 1401 : /// Literal suffix for durations of type `std::chrono::milliseconds` 1402 : template <char... _Digits> 1403 : constexpr chrono::milliseconds 1404 : operator""ms() 1405 : { return __check_overflow<chrono::milliseconds, _Digits...>(); } 1406 : 1407 : /// Literal suffix for durations representing non-integer microseconds 1408 : constexpr chrono::duration<long double, micro> 1409 : operator""us(long double __usecs) 1410 : { return chrono::duration<long double, micro>{__usecs}; } 1411 : 1412 : /// Literal suffix for durations of type `std::chrono::microseconds` 1413 : template <char... _Digits> 1414 : constexpr chrono::microseconds 1415 : operator""us() 1416 : { return __check_overflow<chrono::microseconds, _Digits...>(); } 1417 : 1418 : /// Literal suffix for durations representing non-integer nanoseconds 1419 : constexpr chrono::duration<long double, nano> 1420 : operator""ns(long double __nsecs) 1421 : { return chrono::duration<long double, nano>{__nsecs}; } 1422 : 1423 : /// Literal suffix for durations of type `std::chrono::nanoseconds` 1424 : template <char... _Digits> 1425 : constexpr chrono::nanoseconds 1426 : operator""ns() 1427 : { return __check_overflow<chrono::nanoseconds, _Digits...>(); } 1428 : 1429 : #pragma GCC diagnostic pop 1430 : /// @} 1431 : } // inline namespace chrono_literals 1432 : } // inline namespace literals 1433 : 1434 : namespace chrono 1435 : { 1436 : using namespace literals::chrono_literals; 1437 : } // namespace chrono 1438 : #endif // C++14 1439 : 1440 : #if __cplusplus >= 201703L 1441 : namespace filesystem 1442 : { 1443 : struct __file_clock 1444 : { 1445 : using duration = chrono::nanoseconds; 1446 : using rep = duration::rep; 1447 : using period = duration::period; 1448 : using time_point = chrono::time_point<__file_clock>; 1449 : static constexpr bool is_steady = false; 1450 : 1451 : static time_point 1452 : now() noexcept 1453 : { return _S_from_sys(chrono::system_clock::now()); } 1454 : 1455 : #if __cplusplus > 201703L 1456 : template<typename _Dur> 1457 : static 1458 : chrono::file_time<common_type_t<_Dur, chrono::seconds>> 1459 : from_sys(const chrono::sys_time<_Dur>& __t) noexcept 1460 : { return _S_from_sys(__t); } 1461 : 1462 : // For internal use only 1463 : template<typename _Dur> 1464 : static 1465 : chrono::sys_time<common_type_t<_Dur, chrono::seconds>> 1466 : to_sys(const chrono::file_time<_Dur>& __t) noexcept 1467 : { return _S_to_sys(__t); } 1468 : #endif // C++20 1469 : 1470 : private: 1471 : using __sys_clock = chrono::system_clock; 1472 : 1473 : // This clock's (unspecified) epoch is 2174-01-01 00:00:00 UTC. 1474 : // A signed 64-bit duration with nanosecond resolution gives roughly 1475 : // +/- 292 years, which covers the 1901-2446 date range for ext4. 1476 : static constexpr chrono::seconds _S_epoch_diff{6437664000}; 1477 : 1478 : protected: 1479 : // For internal use only 1480 : template<typename _Dur> 1481 : static 1482 : chrono::time_point<__file_clock, common_type_t<_Dur, chrono::seconds>> 1483 : _S_from_sys(const chrono::time_point<__sys_clock, _Dur>& __t) noexcept 1484 : { 1485 : using _CDur = common_type_t<_Dur, chrono::seconds>; 1486 : using __file_time = chrono::time_point<__file_clock, _CDur>; 1487 : return __file_time{__t.time_since_epoch()} - _S_epoch_diff; 1488 : } 1489 : 1490 : // For internal use only 1491 : template<typename _Dur> 1492 : static 1493 : chrono::time_point<__sys_clock, common_type_t<_Dur, chrono::seconds>> 1494 : _S_to_sys(const chrono::time_point<__file_clock, _Dur>& __t) noexcept 1495 : { 1496 : using _CDur = common_type_t<_Dur, chrono::seconds>; 1497 : using __sys_time = chrono::time_point<__sys_clock, _CDur>; 1498 : return __sys_time{__t.time_since_epoch()} + _S_epoch_diff; 1499 : } 1500 : }; 1501 : } // namespace filesystem 1502 : #endif // C++17 1503 : 1504 : _GLIBCXX_END_NAMESPACE_VERSION 1505 : } // namespace std 1506 : 1507 : #endif // C++11 1508 : 1509 : #endif //_GLIBCXX_CHRONO_H |
![]() |
Generated by: LCOV version 2.0-1 |
</html>