The C and C++ Include Header Files
/usr/include/c++/11/chrono
$ cat -n /usr/include/c++/11/chrono 1 //
-*- C++ -*- 2 3 // Copyright (C) 2008-2021 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 //
. 24 25 /** @file include/chrono 26 * This is a Standard C++ Library header. 27 * @ingroup chrono 28 */ 29 30 #ifndef _GLIBCXX_CHRONO 31 #define _GLIBCXX_CHRONO 1 32 33 #pragma GCC system_header 34 35 #if __cplusplus < 201103L 36 # include
37 #else 38 39 #include
40 #include
41 #include
42 #include
43 #include
// for literals support. 44 #if __cplusplus > 201703L 45 # include
46 # include
47 #endif 48 49 namespace std _GLIBCXX_VISIBILITY(default) 50 { 51 _GLIBCXX_BEGIN_NAMESPACE_VERSION 52 53 #if __cplusplus >= 201703L 54 namespace filesystem { struct __file_clock; }; 55 #endif 56 57 /** 58 * @defgroup chrono Time 59 * @ingroup utilities 60 * 61 * Classes and functions for time. 62 * 63 * @since C++11 64 */ 65 66 /** @namespace std::chrono 67 * @brief ISO C++ 2011 namespace for date and time utilities 68 * @ingroup chrono 69 */ 70 namespace chrono 71 { 72 /// @addtogroup chrono 73 /// @{ 74 75 /// `chrono::duration` represents a distance between two points in time 76 template
> 77 struct duration; 78 79 /// `chrono::time_point` represents a point in time as measured by a clock 80 template
81 struct time_point; 82 /// @} 83 } 84 85 /// @addtogroup chrono 86 /// @{ 87 88 // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) 89 90 /// @cond undocumented 91 92 template
93 struct __duration_common_type 94 { }; 95 96 template
97 struct __duration_common_type<_CT, _Period1, _Period2, 98 __void_t
> 99 { 100 private: 101 using __gcd_num = __static_gcd<_Period1::num, _Period2::num>; 102 using __gcd_den = __static_gcd<_Period1::den, _Period2::den>; 103 using __cr = typename _CT::type; 104 using __r = ratio<__gcd_num::value, 105 (_Period1::den / __gcd_den::value) * _Period2::den>; 106 107 public: 108 using type = chrono::duration<__cr, typename __r::type>; 109 }; 110 111 /// @endcond 112 113 /// @{ 114 /// @relates chrono::duration 115 116 /// Specialization of common_type for chrono::duration types. 117 template
118 struct common_type
, 119 chrono::duration<_Rep2, _Period2>> 120 : __duration_common_type
, 121 typename _Period1::type, 122 typename _Period2::type> 123 { }; 124 125 /// Specialization of common_type for two identical chrono::duration types. 126 template
127 struct common_type
, 128 chrono::duration<_Rep, _Period>> 129 { 130 using type = chrono::duration
::type, 131 typename _Period::type>; 132 }; 133 134 /// Specialization of common_type for one chrono::duration type. 135 template
136 struct common_type
> 137 { 138 using type = chrono::duration
::type, 139 typename _Period::type>; 140 }; 141 /// @} 142 143 // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly) 144 145 /// @cond undocumented 146 147 template
148 struct __timepoint_common_type 149 { }; 150 151 template
152 struct __timepoint_common_type<_CT, _Clock, __void_t
> 153 { 154 using type = chrono::time_point<_Clock, typename _CT::type>; 155 }; 156 157 /// @endcond 158 159 /// @{ 160 /// @relates chrono::time_point 161 162 /// Specialization of common_type for chrono::time_point types. 163 template
164 struct common_type
, 165 chrono::time_point<_Clock, _Duration2>> 166 : __timepoint_common_type
, _Clock> 167 { }; 168 169 /// Specialization of common_type for two identical chrono::time_point types. 170 template
171 struct common_type
, 172 chrono::time_point<_Clock, _Duration>> 173 { using type = chrono::time_point<_Clock, _Duration>; }; 174 175 /// Specialization of common_type for one chrono::time_point type. 176 template
177 struct common_type
> 178 { using type = chrono::time_point<_Clock, _Duration>; }; 179 /// @} 180 181 /// @} group chrono 182 183 namespace chrono 184 { 185 /// @addtogroup chrono 186 /// @{ 187 188 /// @cond undocumented 189 190 // Primary template for duration_cast impl. 191 template
193 struct __duration_cast_impl 194 { 195 template
196 static constexpr _ToDur 197 __cast(const duration<_Rep, _Period>& __d) 198 { 199 typedef typename _ToDur::rep __to_rep; 200 return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) 201 * static_cast<_CR>(_CF::num) 202 / static_cast<_CR>(_CF::den))); 203 } 204 }; 205 206 template
207 struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> 208 { 209 template
210 static constexpr _ToDur 211 __cast(const duration<_Rep, _Period>& __d) 212 { 213 typedef typename _ToDur::rep __to_rep; 214 return _ToDur(static_cast<__to_rep>(__d.count())); 215 } 216 }; 217 218 template
219 struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> 220 { 221 template
222 static constexpr _ToDur 223 __cast(const duration<_Rep, _Period>& __d) 224 { 225 typedef typename _ToDur::rep __to_rep; 226 return _ToDur(static_cast<__to_rep>( 227 static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); 228 } 229 }; 230 231 template
232 struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> 233 { 234 template
235 static constexpr _ToDur 236 __cast(const duration<_Rep, _Period>& __d) 237 { 238 typedef typename _ToDur::rep __to_rep; 239 return _ToDur(static_cast<__to_rep>( 240 static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); 241 } 242 }; 243 244 template
245 struct __is_duration 246 : std::false_type 247 { }; 248 249 template
250 struct __is_duration
> 251 : std::true_type 252 { }; 253 254 template
255 using __enable_if_is_duration 256 = typename enable_if<__is_duration<_Tp>::value, _Tp>::type; 257 258 template
259 using __disable_if_is_duration 260 = typename enable_if::value, _Tp>::type; 261 262 /// @endcond 263 264 /// duration_cast 265 template
266 constexpr __enable_if_is_duration<_ToDur> 267 duration_cast(const duration<_Rep, _Period>& __d) 268 { 269 typedef typename _ToDur::period __to_period; 270 typedef typename _ToDur::rep __to_rep; 271 typedef ratio_divide<_Period, __to_period> __cf; 272 typedef typename common_type<__to_rep, _Rep, intmax_t>::type 273 __cr; 274 typedef __duration_cast_impl<_ToDur, __cf, __cr, 275 __cf::num == 1, __cf::den == 1> __dc; 276 return __dc::__cast(__d); 277 } 278 279 /// treat_as_floating_point 280 template
281 struct treat_as_floating_point 282 : is_floating_point<_Rep> 283 { }; 284 285 #if __cplusplus > 201402L 286 template
287 inline constexpr bool treat_as_floating_point_v = 288 treat_as_floating_point<_Rep>::value; 289 #endif // C++17 290 291 #if __cplusplus > 201703L 292 template
293 struct is_clock; 294 295 template
296 inline constexpr bool is_clock_v = is_clock<_Tp>::value; 297 298 #if __cpp_lib_concepts 299 template
300 struct is_clock : false_type 301 { }; 302 303 template
304 requires requires { 305 typename _Tp::rep; 306 typename _Tp::period; 307 typename _Tp::duration; 308 typename _Tp::time_point::clock; 309 typename _Tp::time_point::duration; 310 { &_Tp::is_steady } -> same_as
; 311 { _Tp::now() } -> same_as
; 312 requires same_as
>; 314 requires same_as
; 316 } 317 struct is_clock<_Tp> : true_type 318 { }; 319 #else 320 template
321 struct __is_clock_impl : false_type 322 { }; 323 324 template
325 struct __is_clock_impl<_Tp, 326 void_t
> 331 : __and_
>, 333 is_same
, 335 is_same
, 336 is_same
>::type 337 { }; 338 339 template
340 struct is_clock : __is_clock_impl<_Tp>::type 341 { }; 342 #endif 343 #endif // C++20 344 345 #if __cplusplus >= 201703L 346 # define __cpp_lib_chrono 201611 347 348 template
349 constexpr __enable_if_is_duration<_ToDur> 350 floor(const duration<_Rep, _Period>& __d) 351 { 352 auto __to = chrono::duration_cast<_ToDur>(__d); 353 if (__to > __d) 354 return __to - _ToDur{1}; 355 return __to; 356 } 357 358 template
359 constexpr __enable_if_is_duration<_ToDur> 360 ceil(const duration<_Rep, _Period>& __d) 361 { 362 auto __to = chrono::duration_cast<_ToDur>(__d); 363 if (__to < __d) 364 return __to + _ToDur{1}; 365 return __to; 366 } 367 368 template
369 constexpr enable_if_t< 370 __and_<__is_duration<_ToDur>, 371 __not_
>>::value, 372 _ToDur> 373 round(const duration<_Rep, _Period>& __d) 374 { 375 _ToDur __t0 = chrono::floor<_ToDur>(__d); 376 _ToDur __t1 = __t0 + _ToDur{1}; 377 auto __diff0 = __d - __t0; 378 auto __diff1 = __t1 - __d; 379 if (__diff0 == __diff1) 380 { 381 if (__t0.count() & 1) 382 return __t1; 383 return __t0; 384 } 385 else if (__diff0 < __diff1) 386 return __t0; 387 return __t1; 388 } 389 390 template
391 constexpr 392 enable_if_t
::is_signed, duration<_Rep, _Period>> 393 abs(duration<_Rep, _Period> __d) 394 { 395 if (__d >= __d.zero()) 396 return __d; 397 return -__d; 398 } 399 400 // Make chrono::ceil
also usable as chrono::__detail::ceil
. 401 namespace __detail { using chrono::ceil; } 402 403 #else // ! C++17 404 405 // We want to use ceil even when compiling for earlier standards versions. 406 // C++11 only allows a single statement in a constexpr function, so we 407 // need to move the comparison into a separate function, __ceil_impl. 408 namespace __detail 409 { 410 template
411 constexpr _Tp 412 __ceil_impl(const _Tp& __t, const _Up& __u) 413 { 414 return (__t < __u) ? (__t + _Tp{1}) : __t; 415 } 416 417 // C++11-friendly version of std::chrono::ceil
for internal use. 418 template
419 constexpr _ToDur 420 ceil(const duration<_Rep, _Period>& __d) 421 { 422 return __detail::__ceil_impl(chrono::duration_cast<_ToDur>(__d), __d); 423 } 424 } 425 #endif // C++17 426 427 /// duration_values 428 template
429 struct duration_values 430 { 431 static constexpr _Rep 432 zero() noexcept 433 { return _Rep(0); } 434 435 static constexpr _Rep 436 max() noexcept 437 { return numeric_limits<_Rep>::max(); } 438 439 static constexpr _Rep 440 min() noexcept 441 { return numeric_limits<_Rep>::lowest(); } 442 }; 443 444 /// @cond undocumented 445 446 template
447 struct __is_ratio 448 : std::false_type 449 { }; 450 451 template
452 struct __is_ratio
> 453 : std::true_type 454 { }; 455 456 /// @endcond 457 458 template
459 struct duration 460 { 461 private: 462 template
463 using __is_float = treat_as_floating_point<_Rep2>; 464 465 static constexpr intmax_t 466 _S_gcd(intmax_t __m, intmax_t __n) noexcept 467 { 468 // Duration only allows positive periods so we don't need to 469 // handle negative values here (unlike __static_gcd and std::gcd). 470 #if __cplusplus >= 201402L 471 do 472 { 473 intmax_t __rem = __m % __n; 474 __m = __n; 475 __n = __rem; 476 } 477 while (__n != 0); 478 return __m; 479 #else 480 // C++11 doesn't allow loops in constexpr functions, but this 481 // recursive version can be more expensive to evaluate. 482 return (__n == 0) ? __m : _S_gcd(__n, __m % __n); 483 #endif 484 } 485 486 // _GLIBCXX_RESOLVE_LIB_DEFECTS 487 // 2094. overflow shouldn't participate in overload resolution 488 // 3090. What is [2094] intended to mean? 489 // This only produces a valid type if no overflow occurs. 490 template
493 using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2), 494 (_R1::den / __gcd2) * (_R2::num / __gcd1)>; 495 496 // _Period2 is an exact multiple of _Period 497 template
498 using __is_harmonic 499 = __bool_constant<__divide<_Period2, _Period>::den == 1>; 500 501 public: 502 503 using rep = _Rep; 504 using period = typename _Period::type; 505 506 static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); 507 static_assert(__is_ratio<_Period>::value, 508 "period must be a specialization of ratio"); 509 static_assert(_Period::num > 0, "period must be positive"); 510 511 // 20.11.5.1 construction / copy / destroy 512 constexpr duration() = default; 513 514 duration(const duration&) = default; 515 516 // _GLIBCXX_RESOLVE_LIB_DEFECTS 517 // 3050. Conversion specification problem in chrono::duration 518 template
, 520 __or_<__is_float
, __not_<__is_float<_Rep2>>>>> 521 constexpr explicit duration(const _Rep2& __rep) 522 : __r(static_cast
(__rep)) { } 523 524 template
, 526 __or_<__is_float
, 527 __and_<__is_harmonic<_Period2>, 528 __not_<__is_float<_Rep2>>>>>> 529 constexpr duration(const duration<_Rep2, _Period2>& __d) 530 : __r(duration_cast
(__d).count()) { } 531 532 ~duration() = default; 533 duration& operator=(const duration&) = default; 534 535 // 20.11.5.2 observer 536 constexpr rep 537 count() const 538 { return __r; } 539 540 // 20.11.5.3 arithmetic 541 542 constexpr duration
::type, period> 543 operator+() const 544 { return duration
::type, period>(__r); } 545 546 constexpr duration
::type, period> 547 operator-() const 548 { return duration
::type, period>(-__r); } 549 550 _GLIBCXX17_CONSTEXPR duration& 551 operator++() 552 { 553 ++__r; 554 return *this; 555 } 556 557 _GLIBCXX17_CONSTEXPR duration 558 operator++(int) 559 { return duration(__r++); } 560 561 _GLIBCXX17_CONSTEXPR duration& 562 operator--() 563 { 564 --__r; 565 return *this; 566 } 567 568 _GLIBCXX17_CONSTEXPR duration 569 operator--(int) 570 { return duration(__r--); } 571 572 _GLIBCXX17_CONSTEXPR duration& 573 operator+=(const duration& __d) 574 { 575 __r += __d.count(); 576 return *this; 577 } 578 579 _GLIBCXX17_CONSTEXPR duration& 580 operator-=(const duration& __d) 581 { 582 __r -= __d.count(); 583 return *this; 584 } 585 586 _GLIBCXX17_CONSTEXPR duration& 587 operator*=(const rep& __rhs) 588 { 589 __r *= __rhs; 590 return *this; 591 } 592 593 _GLIBCXX17_CONSTEXPR duration& 594 operator/=(const rep& __rhs) 595 { 596 __r /= __rhs; 597 return *this; 598 } 599 600 // DR 934. 601 template
602 _GLIBCXX17_CONSTEXPR 603 typename enable_if::value, 604 duration&>::type 605 operator%=(const rep& __rhs) 606 { 607 __r %= __rhs; 608 return *this; 609 } 610 611 template
612 _GLIBCXX17_CONSTEXPR 613 typename enable_if::value, 614 duration&>::type 615 operator%=(const duration& __d) 616 { 617 __r %= __d.count(); 618 return *this; 619 } 620 621 // 20.11.5.4 special values 622 static constexpr duration 623 zero() noexcept 624 { return duration(duration_values
::zero()); } 625 626 static constexpr duration 627 min() noexcept 628 { return duration(duration_values
::min()); } 629 630 static constexpr duration 631 max() noexcept 632 { return duration(duration_values
::max()); } 633 634 private: 635 rep __r; 636 }; 637 638 /// @{ 639 /// @relates std::chrono::duration 640 641 /// The sum of two durations. 642 template
644 constexpr typename common_type
, 645 duration<_Rep2, _Period2>>::type 646 operator+(const duration<_Rep1, _Period1>& __lhs, 647 const duration<_Rep2, _Period2>& __rhs) 648 { 649 typedef duration<_Rep1, _Period1> __dur1; 650 typedef duration<_Rep2, _Period2> __dur2; 651 typedef typename common_type<__dur1,__dur2>::type __cd; 652 return __cd(__cd(__lhs).count() + __cd(__rhs).count()); 653 } 654 655 /// The difference between two durations. 656 template
658 constexpr typename common_type
, 659 duration<_Rep2, _Period2>>::type 660 operator-(const duration<_Rep1, _Period1>& __lhs, 661 const duration<_Rep2, _Period2>& __rhs) 662 { 663 typedef duration<_Rep1, _Period1> __dur1; 664 typedef duration<_Rep2, _Period2> __dur2; 665 typedef typename common_type<__dur1,__dur2>::type __cd; 666 return __cd(__cd(__lhs).count() - __cd(__rhs).count()); 667 } 668 669 /// @} 670 671 /// @cond undocumented 672 673 // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2 674 // is implicitly convertible to it. 675 // _GLIBCXX_RESOLVE_LIB_DEFECTS 676 // 3050. Conversion specification problem in chrono::duration constructor 677 template
::type> 679 using __common_rep_t = typename 680 enable_if
::value, _CRep>::type; 681 682 /// @endcond 683 684 /** @{ 685 * Arithmetic operators for chrono::duration 686 * @relates std::chrono::duration 687 */ 688 689 template
690 constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period> 691 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 692 { 693 typedef duration
::type, _Period> 694 __cd; 695 return __cd(__cd(__d).count() * __s); 696 } 697 698 template
699 constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period> 700 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 701 { return __d * __s; } 702 703 template
704 constexpr 705 duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> 706 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 707 { 708 typedef duration
::type, _Period> 709 __cd; 710 return __cd(__cd(__d).count() / __s); 711 } 712 713 template
715 constexpr typename common_type<_Rep1, _Rep2>::type 716 operator/(const duration<_Rep1, _Period1>& __lhs, 717 const duration<_Rep2, _Period2>& __rhs) 718 { 719 typedef duration<_Rep1, _Period1> __dur1; 720 typedef duration<_Rep2, _Period2> __dur2; 721 typedef typename common_type<__dur1,__dur2>::type __cd; 722 return __cd(__lhs).count() / __cd(__rhs).count(); 723 } 724 725 // DR 934. 726 template
727 constexpr 728 duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> 729 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 730 { 731 typedef duration
::type, _Period> 732 __cd; 733 return __cd(__cd(__d).count() % __s); 734 } 735 736 template
738 constexpr typename common_type
, 739 duration<_Rep2, _Period2>>::type 740 operator%(const duration<_Rep1, _Period1>& __lhs, 741 const duration<_Rep2, _Period2>& __rhs) 742 { 743 typedef duration<_Rep1, _Period1> __dur1; 744 typedef duration<_Rep2, _Period2> __dur2; 745 typedef typename common_type<__dur1,__dur2>::type __cd; 746 return __cd(__cd(__lhs).count() % __cd(__rhs).count()); 747 } 748 /// @} 749 750 // comparisons 751 752 /** @{ 753 * Comparisons for chrono::duration 754 * @relates std::chrono::duration 755 */ 756 757 template
759 constexpr bool 760 operator==(const duration<_Rep1, _Period1>& __lhs, 761 const duration<_Rep2, _Period2>& __rhs) 762 { 763 typedef duration<_Rep1, _Period1> __dur1; 764 typedef duration<_Rep2, _Period2> __dur2; 765 typedef typename common_type<__dur1,__dur2>::type __ct; 766 return __ct(__lhs).count() == __ct(__rhs).count(); 767 } 768 769 template
771 constexpr bool 772 operator<(const duration<_Rep1, _Period1>& __lhs, 773 const duration<_Rep2, _Period2>& __rhs) 774 { 775 typedef duration<_Rep1, _Period1> __dur1; 776 typedef duration<_Rep2, _Period2> __dur2; 777 typedef typename common_type<__dur1,__dur2>::type __ct; 778 return __ct(__lhs).count() < __ct(__rhs).count(); 779 } 780 781 #if __cpp_lib_three_way_comparison 782 template
784 requires three_way_comparable
> 785 constexpr auto 786 operator<=>(const duration<_Rep1, _Period1>& __lhs, 787 const duration<_Rep2, _Period2>& __rhs) 788 { 789 using __ct = common_type_t
, 790 duration<_Rep2, _Period2>>; 791 return __ct(__lhs).count() <=> __ct(__rhs).count(); 792 } 793 #else 794 template
796 constexpr bool 797 operator!=(const duration<_Rep1, _Period1>& __lhs, 798 const duration<_Rep2, _Period2>& __rhs) 799 { return !(__lhs == __rhs); } 800 #endif 801 802 template
804 constexpr bool 805 operator<=(const duration<_Rep1, _Period1>& __lhs, 806 const duration<_Rep2, _Period2>& __rhs) 807 { return !(__rhs < __lhs); } 808 809 template
811 constexpr bool 812 operator>(const duration<_Rep1, _Period1>& __lhs, 813 const duration<_Rep2, _Period2>& __rhs) 814 { return __rhs < __lhs; } 815 816 template
818 constexpr bool 819 operator>=(const duration<_Rep1, _Period1>& __lhs, 820 const duration<_Rep2, _Period2>& __rhs) 821 { return !(__lhs < __rhs); } 822 823 /// @} 824 825 /// @cond undocumented 826 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 827 # define _GLIBCXX_CHRONO_INT64_T int64_t 828 #elif defined __INT64_TYPE__ 829 # define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__ 830 #else 831 static_assert(std::numeric_limits
::digits >= 64, 832 "Representation type for nanoseconds must have at least 64 bits"); 833 # define _GLIBCXX_CHRONO_INT64_T long long 834 #endif 835 /// @endcond 836 837 /// nanoseconds 838 using nanoseconds = duration<_GLIBCXX_CHRONO_INT64_T, nano>; 839 840 /// microseconds 841 using microseconds = duration<_GLIBCXX_CHRONO_INT64_T, micro>; 842 843 /// milliseconds 844 using milliseconds = duration<_GLIBCXX_CHRONO_INT64_T, milli>; 845 846 /// seconds 847 using seconds = duration<_GLIBCXX_CHRONO_INT64_T>; 848 849 /// minutes 850 using minutes = duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>>; 851 852 /// hours 853 using hours = duration<_GLIBCXX_CHRONO_INT64_T, ratio<3600>>; 854 855 #if __cplusplus > 201703L 856 /// days 857 using days = duration<_GLIBCXX_CHRONO_INT64_T, ratio<86400>>; 858 859 /// weeks 860 using weeks = duration<_GLIBCXX_CHRONO_INT64_T, ratio<604800>>; 861 862 /// years 863 using years = duration<_GLIBCXX_CHRONO_INT64_T, ratio<31556952>>; 864 865 /// months 866 using months = duration<_GLIBCXX_CHRONO_INT64_T, ratio<2629746>>; 867 #endif // C++20 868 869 #undef _GLIBCXX_CHRONO_INT64_T 870 871 template
872 struct time_point 873 { 874 static_assert(__is_duration<_Dur>::value, 875 "duration must be a specialization of std::chrono::duration"); 876 877 typedef _Clock clock; 878 typedef _Dur duration; 879 typedef typename duration::rep rep; 880 typedef typename duration::period period; 881 882 constexpr time_point() : __d(duration::zero()) 883 { } 884 885 constexpr explicit time_point(const duration& __dur) 886 : __d(__dur) 887 { } 888 889 // conversions 890 template
>> 892 constexpr time_point(const time_point
& __t) 893 : __d(__t.time_since_epoch()) 894 { } 895 896 // observer 897 constexpr duration 898 time_since_epoch() const 899 { return __d; } 900 901 #if __cplusplus > 201703L 902 constexpr time_point& 903 operator++() 904 { 905 ++__d; 906 return *this; 907 } 908 909 constexpr time_point 910 operator++(int) 911 { return time_point{__d++}; } 912 913 constexpr time_point& 914 operator--() 915 { 916 --__d; 917 return *this; 918 } 919 920 constexpr time_point 921 operator--(int) 922 { return time_point{__d--}; } 923 #endif 924 925 // arithmetic 926 _GLIBCXX17_CONSTEXPR time_point& 927 operator+=(const duration& __dur) 928 { 929 __d += __dur; 930 return *this; 931 } 932 933 _GLIBCXX17_CONSTEXPR time_point& 934 operator-=(const duration& __dur) 935 { 936 __d -= __dur; 937 return *this; 938 } 939 940 // special values 941 static constexpr time_point 942 min() noexcept 943 { return time_point(duration::min()); } 944 945 static constexpr time_point 946 max() noexcept 947 { return time_point(duration::max()); } 948 949 private: 950 duration __d; 951 }; 952 953 /// time_point_cast 954 template
955 constexpr typename enable_if<__is_duration<_ToDur>::value, 956 time_point<_Clock, _ToDur>>::type 957 time_point_cast(const time_point<_Clock, _Dur>& __t) 958 { 959 typedef time_point<_Clock, _ToDur> __time_point; 960 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); 961 } 962 963 #if __cplusplus > 201402L 964 template
965 constexpr 966 enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> 967 floor(const time_point<_Clock, _Dur>& __tp) 968 { 969 return time_point<_Clock, _ToDur>{ 970 chrono::floor<_ToDur>(__tp.time_since_epoch())}; 971 } 972 973 template
974 constexpr 975 enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> 976 ceil(const time_point<_Clock, _Dur>& __tp) 977 { 978 return time_point<_Clock, _ToDur>{ 979 chrono::ceil<_ToDur>(__tp.time_since_epoch())}; 980 } 981 982 template
983 constexpr enable_if_t< 984 __and_<__is_duration<_ToDur>, 985 __not_
>>::value, 986 time_point<_Clock, _ToDur>> 987 round(const time_point<_Clock, _Dur>& __tp) 988 { 989 return time_point<_Clock, _ToDur>{ 990 chrono::round<_ToDur>(__tp.time_since_epoch())}; 991 } 992 #endif // C++17 993 994 /// @{ 995 /// @relates time_point 996 997 /// Adjust a time point forwards by the given duration. 998 template
1000 constexpr time_point<_Clock, 1001 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 1002 operator+(const time_point<_Clock, _Dur1>& __lhs, 1003 const duration<_Rep2, _Period2>& __rhs) 1004 { 1005 typedef duration<_Rep2, _Period2> __dur2; 1006 typedef typename common_type<_Dur1,__dur2>::type __ct; 1007 typedef time_point<_Clock, __ct> __time_point; 1008 return __time_point(__lhs.time_since_epoch() + __rhs); 1009 } 1010 1011 /// Adjust a time point forwards by the given duration. 1012 template
1014 constexpr time_point<_Clock, 1015 typename common_type
, _Dur2>::type> 1016 operator+(const duration<_Rep1, _Period1>& __lhs, 1017 const time_point<_Clock, _Dur2>& __rhs) 1018 { 1019 typedef duration<_Rep1, _Period1> __dur1; 1020 typedef typename common_type<__dur1,_Dur2>::type __ct; 1021 typedef time_point<_Clock, __ct> __time_point; 1022 return __time_point(__rhs.time_since_epoch() + __lhs); 1023 } 1024 1025 /// Adjust a time point backwards by the given duration. 1026 template
1028 constexpr time_point<_Clock, 1029 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 1030 operator-(const time_point<_Clock, _Dur1>& __lhs, 1031 const duration<_Rep2, _Period2>& __rhs) 1032 { 1033 typedef duration<_Rep2, _Period2> __dur2; 1034 typedef typename common_type<_Dur1,__dur2>::type __ct; 1035 typedef time_point<_Clock, __ct> __time_point; 1036 return __time_point(__lhs.time_since_epoch() -__rhs); 1037 } 1038 1039 /// The difference between two time points (as a duration) 1040 template
1041 constexpr typename common_type<_Dur1, _Dur2>::type 1042 operator-(const time_point<_Clock, _Dur1>& __lhs, 1043 const time_point<_Clock, _Dur2>& __rhs) 1044 { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } 1045 /// @} 1046 1047 /** @{ 1048 * Comparisons for time_point 1049 * @relates chrono::time_point 1050 */ 1051 1052 template
1053 constexpr bool 1054 operator==(const time_point<_Clock, _Dur1>& __lhs, 1055 const time_point<_Clock, _Dur2>& __rhs) 1056 { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } 1057 1058 #if __cpp_lib_three_way_comparison 1059 template
_Dur2> 1061 constexpr auto 1062 operator<=>(const time_point<_Clock, _Dur1>& __lhs, 1063 const time_point<_Clock, _Dur2>& __rhs) 1064 { return __lhs.time_since_epoch() <=> __rhs.time_since_epoch(); } 1065 #else 1066 template
1067 constexpr bool 1068 operator!=(const time_point<_Clock, _Dur1>& __lhs, 1069 const time_point<_Clock, _Dur2>& __rhs) 1070 { return !(__lhs == __rhs); } 1071 #endif 1072 1073 template
1074 constexpr bool 1075 operator<(const time_point<_Clock, _Dur1>& __lhs, 1076 const time_point<_Clock, _Dur2>& __rhs) 1077 { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } 1078 1079 template
1080 constexpr bool 1081 operator<=(const time_point<_Clock, _Dur1>& __lhs, 1082 const time_point<_Clock, _Dur2>& __rhs) 1083 { return !(__rhs < __lhs); } 1084 1085 template
1086 constexpr bool 1087 operator>(const time_point<_Clock, _Dur1>& __lhs, 1088 const time_point<_Clock, _Dur2>& __rhs) 1089 { return __rhs < __lhs; } 1090 1091 template
1092 constexpr bool 1093 operator>=(const time_point<_Clock, _Dur1>& __lhs, 1094 const time_point<_Clock, _Dur2>& __rhs) 1095 { return !(__lhs < __rhs); } 1096 1097 /// @} 1098 1099 // Clocks. 1100 1101 // Why nanosecond resolution as the default? 1102 // Why have std::system_clock always count in the highest 1103 // resolution (ie nanoseconds), even if on some OSes the low 3 1104 // or 9 decimal digits will be always zero? This allows later 1105 // implementations to change the system_clock::now() 1106 // implementation any time to provide better resolution without 1107 // changing function signature or units. 1108 1109 // To support the (forward) evolution of the library's defined 1110 // clocks, wrap inside inline namespace so that the current 1111 // defintions of system_clock, steady_clock, and 1112 // high_resolution_clock types are uniquely mangled. This way, new 1113 // code can use the latests clocks, while the library can contain 1114 // compatibility definitions for previous versions. At some 1115 // point, when these clocks settle down, the inlined namespaces 1116 // can be removed. XXX GLIBCXX_ABI Deprecated 1117 inline namespace _V2 { 1118 1119 /** 1120 * @brief System clock. 1121 * 1122 * Time returned represents wall time from the system-wide clock. 1123 * @ingroup chrono 1124 */ 1125 struct system_clock 1126 { 1127 typedef chrono::nanoseconds duration; 1128 typedef duration::rep rep; 1129 typedef duration::period period; 1130 typedef chrono::time_point
time_point; 1131 1132 static_assert(system_clock::duration::min() 1133 < system_clock::duration::zero(), 1134 "a clock's minimum duration cannot be less than its epoch"); 1135 1136 static constexpr bool is_steady = false; 1137 1138 static time_point 1139 now() noexcept; 1140 1141 // Map to C API 1142 static std::time_t 1143 to_time_t(const time_point& __t) noexcept 1144 { 1145 return std::time_t(duration_cast
1146 (__t.time_since_epoch()).count()); 1147 } 1148 1149 static time_point 1150 from_time_t(std::time_t __t) noexcept 1151 { 1152 typedef chrono::time_point
__from; 1153 return time_point_cast
1154 (__from(chrono::seconds(__t))); 1155 } 1156 }; 1157 1158 1159 /** 1160 * @brief Monotonic clock 1161 * 1162 * Time returned has the property of only increasing at a uniform rate. 1163 * @ingroup chrono 1164 */ 1165 struct steady_clock 1166 { 1167 typedef chrono::nanoseconds duration; 1168 typedef duration::rep rep; 1169 typedef duration::period period; 1170 typedef chrono::time_point
time_point; 1171 1172 static constexpr bool is_steady = true; 1173 1174 static time_point 1175 now() noexcept; 1176 }; 1177 1178 1179 /** 1180 * @brief Highest-resolution clock 1181 * 1182 * This is the clock "with the shortest tick period." Alias to 1183 * std::system_clock until higher-than-nanosecond definitions 1184 * become feasible. 1185 * @ingroup chrono 1186 */ 1187 using high_resolution_clock = system_clock; 1188 1189 } // end inline namespace _V2 1190 1191 #if __cplusplus > 201703L 1192 template
1193 using sys_time = time_point
; 1194 using sys_seconds = sys_time
; 1195 using sys_days = sys_time
; 1196 1197 using file_clock = ::std::filesystem::__file_clock; 1198 1199 template
1200 using file_time = time_point
; 1201 1202 template<> struct is_clock
: true_type { }; 1203 template<> struct is_clock
: true_type { }; 1204 template<> struct is_clock
: true_type { }; 1205 1206 template<> inline constexpr bool is_clock_v
= true; 1207 template<> inline constexpr bool is_clock_v
= true; 1208 template<> inline constexpr bool is_clock_v
= true; 1209 1210 struct local_t { }; 1211 template
1212 using local_time = time_point
; 1213 using local_seconds = local_time
; 1214 using local_days = local_time
; 1215 1216 class utc_clock; 1217 class tai_clock; 1218 class gps_clock; 1219 1220 template
1221 using utc_time = time_point
; 1222 using utc_seconds = utc_time
; 1223 1224 template
1225 using tai_time = time_point
; 1226 using tai_seconds = tai_time
; 1227 1228 template
1229 using gps_time = time_point
; 1230 using gps_seconds = gps_time
; 1231 1232 template<> struct is_clock
: true_type { }; 1233 template<> struct is_clock
: true_type { }; 1234 template<> struct is_clock
: true_type { }; 1235 1236 template<> inline constexpr bool is_clock_v
= true; 1237 template<> inline constexpr bool is_clock_v
= true; 1238 template<> inline constexpr bool is_clock_v
= true; 1239 1240 struct leap_second_info 1241 { 1242 bool is_leap_second; 1243 seconds elapsed; 1244 }; 1245 1246 // CALENDRICAL TYPES 1247 1248 // CLASS DECLARATIONS 1249 class day; 1250 class month; 1251 class year; 1252 class weekday; 1253 class weekday_indexed; 1254 class weekday_last; 1255 class month_day; 1256 class month_day_last; 1257 class month_weekday; 1258 class month_weekday_last; 1259 class year_month; 1260 class year_month_day; 1261 class year_month_day_last; 1262 class year_month_weekday; 1263 class year_month_weekday_last; 1264 1265 struct last_spec 1266 { 1267 explicit last_spec() = default; 1268 1269 friend constexpr month_day_last 1270 operator/(int __m, last_spec) noexcept; 1271 1272 friend constexpr month_day_last 1273 operator/(last_spec, int __m) noexcept; 1274 }; 1275 1276 inline constexpr last_spec last{}; 1277 1278 namespace __detail 1279 { 1280 // Compute the remainder of the Euclidean division of __n divided by __d. 1281 // Euclidean division truncates toward negative infinity and always 1282 // produces a remainder in the range of [0,__d-1] (whereas standard 1283 // division truncates toward zero and yields a nonpositive remainder 1284 // for negative __n). 1285 constexpr unsigned 1286 __modulo(long long __n, unsigned __d) 1287 { 1288 if (__n >= 0) 1289 return __n % __d; 1290 else 1291 return (__d + (__n % __d)) % __d; 1292 } 1293 1294 inline constexpr unsigned __days_per_month[12] 1295 = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 1296 } 1297 1298 // DAY 1299 1300 class day 1301 { 1302 private: 1303 unsigned char _M_d; 1304 1305 public: 1306 day() = default; 1307 1308 explicit constexpr 1309 day(unsigned __d) noexcept 1310 : _M_d(__d) 1311 { } 1312 1313 constexpr day& 1314 operator++() noexcept 1315 { 1316 ++_M_d; 1317 return *this; 1318 } 1319 1320 constexpr day 1321 operator++(int) noexcept 1322 { 1323 auto __ret = *this; 1324 ++(*this); 1325 return __ret; 1326 } 1327 1328 constexpr day& 1329 operator--() noexcept 1330 { 1331 --_M_d; 1332 return *this; 1333 } 1334 1335 constexpr day 1336 operator--(int) noexcept 1337 { 1338 auto __ret = *this; 1339 --(*this); 1340 return __ret; 1341 } 1342 1343 constexpr day& 1344 operator+=(const days& __d) noexcept 1345 { 1346 *this = *this + __d; 1347 return *this; 1348 } 1349 1350 constexpr day& 1351 operator-=(const days& __d) noexcept 1352 { 1353 *this = *this - __d; 1354 return *this; 1355 } 1356 1357 constexpr explicit 1358 operator unsigned() const noexcept 1359 { return _M_d; } 1360 1361 constexpr bool 1362 ok() const noexcept 1363 { return 1 <= _M_d && _M_d <= 31; } 1364 1365 friend constexpr bool 1366 operator==(const day& __x, const day& __y) noexcept 1367 { return unsigned{__x} == unsigned{__y}; } 1368 1369 friend constexpr strong_ordering 1370 operator<=>(const day& __x, const day& __y) noexcept 1371 { return unsigned{__x} <=> unsigned{__y}; } 1372 1373 friend constexpr day 1374 operator+(const day& __x, const days& __y) noexcept 1375 { return day(unsigned{__x} + __y.count()); } 1376 1377 friend constexpr day 1378 operator+(const days& __x, const day& __y) noexcept 1379 { return __y + __x; } 1380 1381 friend constexpr day 1382 operator-(const day& __x, const days& __y) noexcept 1383 { return __x + -__y; } 1384 1385 friend constexpr days 1386 operator-(const day& __x, const day& __y) noexcept 1387 { return days{int(unsigned{__x}) - int(unsigned{__y})}; } 1388 1389 friend constexpr month_day 1390 operator/(const month& __m, const day& __d) noexcept; 1391 1392 friend constexpr month_day 1393 operator/(int __m, const day& __d) noexcept; 1394 1395 friend constexpr month_day 1396 operator/(const day& __d, const month& __m) noexcept; 1397 1398 friend constexpr month_day 1399 operator/(const day& __d, int __m) noexcept; 1400 1401 friend constexpr year_month_day 1402 operator/(const year_month& __ym, const day& __d) noexcept; 1403 1404 // TODO: Implement operator<<, to_stream, from_stream. 1405 }; 1406 1407 // MONTH 1408 1409 class month 1410 { 1411 private: 1412 unsigned char _M_m; 1413 1414 public: 1415 month() = default; 1416 1417 explicit constexpr 1418 month(unsigned __m) noexcept 1419 : _M_m(__m) 1420 { } 1421 1422 constexpr month& 1423 operator++() noexcept 1424 { 1425 *this += months{1}; 1426 return *this; 1427 } 1428 1429 constexpr month 1430 operator++(int) noexcept 1431 { 1432 auto __ret = *this; 1433 ++(*this); 1434 return __ret; 1435 } 1436 1437 constexpr month& 1438 operator--() noexcept 1439 { 1440 *this -= months{1}; 1441 return *this; 1442 } 1443 1444 constexpr month 1445 operator--(int) noexcept 1446 { 1447 auto __ret = *this; 1448 --(*this); 1449 return __ret; 1450 } 1451 1452 constexpr month& 1453 operator+=(const months& __m) noexcept 1454 { 1455 *this = *this + __m; 1456 return *this; 1457 } 1458 1459 constexpr month& 1460 operator-=(const months& __m) noexcept 1461 { 1462 *this = *this - __m; 1463 return *this; 1464 } 1465 1466 explicit constexpr 1467 operator unsigned() const noexcept 1468 { return _M_m; } 1469 1470 constexpr bool 1471 ok() const noexcept 1472 { return 1 <= _M_m && _M_m <= 12; } 1473 1474 friend constexpr bool 1475 operator==(const month& __x, const month& __y) noexcept 1476 { return unsigned{__x} == unsigned{__y}; } 1477 1478 friend constexpr strong_ordering 1479 operator<=>(const month& __x, const month& __y) noexcept 1480 { return unsigned{__x} <=> unsigned{__y}; } 1481 1482 friend constexpr month 1483 operator+(const month& __x, const months& __y) noexcept 1484 { 1485 auto __n = static_cast
(unsigned{__x}) + (__y.count() - 1); 1486 return month{__detail::__modulo(__n, 12) + 1}; 1487 } 1488 1489 friend constexpr month 1490 operator+(const months& __x, const month& __y) noexcept 1491 { return __y + __x; } 1492 1493 friend constexpr month 1494 operator-(const month& __x, const months& __y) noexcept 1495 { return __x + -__y; } 1496 1497 friend constexpr months 1498 operator-(const month& __x, const month& __y) noexcept 1499 { 1500 const auto __dm = int(unsigned(__x)) - int(unsigned(__y)); 1501 return months{__dm < 0 ? 12 + __dm : __dm}; 1502 } 1503 1504 friend constexpr year_month 1505 operator/(const year& __y, const month& __m) noexcept; 1506 1507 friend constexpr month_day 1508 operator/(const month& __m, int __d) noexcept; 1509 1510 friend constexpr month_day_last 1511 operator/(const month& __m, last_spec) noexcept; 1512 1513 friend constexpr month_day_last 1514 operator/(last_spec, const month& __m) noexcept; 1515 1516 friend constexpr month_weekday 1517 operator/(const month& __m, const weekday_indexed& __wdi) noexcept; 1518 1519 friend constexpr month_weekday 1520 operator/(const weekday_indexed& __wdi, const month& __m) noexcept; 1521 1522 friend constexpr month_weekday_last 1523 operator/(const month& __m, const weekday_last& __wdl) noexcept; 1524 1525 friend constexpr month_weekday_last 1526 operator/(const weekday_last& __wdl, const month& __m) noexcept; 1527 1528 // TODO: Implement operator<<, to_stream, from_stream. 1529 }; 1530 1531 inline constexpr month January{1}; 1532 inline constexpr month February{2}; 1533 inline constexpr month March{3}; 1534 inline constexpr month April{4}; 1535 inline constexpr month May{5}; 1536 inline constexpr month June{6}; 1537 inline constexpr month July{7}; 1538 inline constexpr month August{8}; 1539 inline constexpr month September{9}; 1540 inline constexpr month October{10}; 1541 inline constexpr month November{11}; 1542 inline constexpr month December{12}; 1543 1544 // YEAR 1545 1546 class year 1547 { 1548 private: 1549 short _M_y; 1550 1551 public: 1552 year() = default; 1553 1554 explicit constexpr 1555 year(int __y) noexcept 1556 : _M_y{static_cast
(__y)} 1557 { } 1558 1559 static constexpr year 1560 min() noexcept 1561 { return year{-32767}; } 1562 1563 static constexpr year 1564 max() noexcept 1565 { return year{32767}; } 1566 1567 constexpr year& 1568 operator++() noexcept 1569 { 1570 ++_M_y; 1571 return *this; 1572 } 1573 1574 constexpr year 1575 operator++(int) noexcept 1576 { 1577 auto __ret = *this; 1578 ++(*this); 1579 return __ret; 1580 } 1581 1582 constexpr year& 1583 operator--() noexcept 1584 { 1585 --_M_y; 1586 return *this; 1587 } 1588 1589 constexpr year 1590 operator--(int) noexcept 1591 { 1592 auto __ret = *this; 1593 --(*this); 1594 return __ret; 1595 } 1596 1597 constexpr year& 1598 operator+=(const years& __y) noexcept 1599 { 1600 *this = *this + __y; 1601 return *this; 1602 } 1603 1604 constexpr year& 1605 operator-=(const years& __y) noexcept 1606 { 1607 *this = *this - __y; 1608 return *this; 1609 } 1610 1611 constexpr year 1612 operator+() const noexcept 1613 { return *this; } 1614 1615 constexpr year 1616 operator-() const noexcept 1617 { return year{-_M_y}; } 1618 1619 constexpr bool 1620 is_leap() const noexcept 1621 { 1622 // Testing divisibility by 100 first gives better performance, that is, 1623 // return (_M_y % 100 != 0 || _M_y % 400 == 0) && _M_y % 4 == 0; 1624 1625 // It gets even faster if _M_y is in [-536870800, 536870999] 1626 // (which is the case here) and _M_y % 100 is replaced by 1627 // __is_multiple_of_100 below. 1628 1629 // References: 1630 // [1] https://github.com/cassioneri/calendar 1631 // [2] https://accu.org/journals/overload/28/155/overload155.pdf#page=16 1632 1633 constexpr uint32_t __multiplier = 42949673; 1634 constexpr uint32_t __bound = 42949669; 1635 constexpr uint32_t __max_dividend = 1073741799; 1636 constexpr uint32_t __offset = __max_dividend / 2 / 100 * 100; 1637 const bool __is_multiple_of_100 1638 = __multiplier * (_M_y + __offset) < __bound; 1639 return (!__is_multiple_of_100 || _M_y % 400 == 0) && _M_y % 4 == 0; 1640 } 1641 1642 explicit constexpr 1643 operator int() const noexcept 1644 { return _M_y; } 1645 1646 constexpr bool 1647 ok() const noexcept 1648 { return min()._M_y <= _M_y && _M_y <= max()._M_y; } 1649 1650 friend constexpr bool 1651 operator==(const year& __x, const year& __y) noexcept 1652 { return int{__x} == int{__y}; } 1653 1654 friend constexpr strong_ordering 1655 operator<=>(const year& __x, const year& __y) noexcept 1656 { return int{__x} <=> int{__y}; } 1657 1658 friend constexpr year 1659 operator+(const year& __x, const years& __y) noexcept 1660 { return year{int{__x} + static_cast
(__y.count())}; } 1661 1662 friend constexpr year 1663 operator+(const years& __x, const year& __y) noexcept 1664 { return __y + __x; } 1665 1666 friend constexpr year 1667 operator-(const year& __x, const years& __y) noexcept 1668 { return __x + -__y; } 1669 1670 friend constexpr years 1671 operator-(const year& __x, const year& __y) noexcept 1672 { return years{int{__x} - int{__y}}; } 1673 1674 friend constexpr year_month 1675 operator/(const year& __y, int __m) noexcept; 1676 1677 friend constexpr year_month_day 1678 operator/(const year& __y, const month_day& __md) noexcept; 1679 1680 friend constexpr year_month_day 1681 operator/(const month_day& __md, const year& __y) noexcept; 1682 1683 friend constexpr year_month_day_last 1684 operator/(const year& __y, const month_day_last& __mdl) noexcept; 1685 1686 friend constexpr year_month_day_last 1687 operator/(const month_day_last& __mdl, const year& __y) noexcept; 1688 1689 friend constexpr year_month_weekday 1690 operator/(const year& __y, const month_weekday& __mwd) noexcept; 1691 1692 friend constexpr year_month_weekday 1693 operator/(const month_weekday& __mwd, const year& __y) noexcept; 1694 1695 friend constexpr year_month_weekday_last 1696 operator/(const year& __y, const month_weekday_last& __mwdl) noexcept; 1697 1698 friend constexpr year_month_weekday_last 1699 operator/(const month_weekday_last& __mwdl, const year& __y) noexcept; 1700 1701 // TODO: Implement operator<<, to_stream, from_stream. 1702 }; 1703 1704 // WEEKDAY 1705 1706 class weekday 1707 { 1708 private: 1709 unsigned char _M_wd; 1710 1711 static constexpr weekday 1712 _S_from_days(const days& __d) 1713 { 1714 auto __n = __d.count(); 1715 return weekday(__n >= -4 ? (__n + 4) % 7 : (__n + 5) % 7 + 6); 1716 } 1717 1718 public: 1719 weekday() = default; 1720 1721 explicit constexpr 1722 weekday(unsigned __wd) noexcept 1723 : _M_wd(__wd == 7 ? 0 : __wd) // __wd % 7 ? 1724 { } 1725 1726 constexpr 1727 weekday(const sys_days& __dp) noexcept 1728 : weekday{_S_from_days(__dp.time_since_epoch())} 1729 { } 1730 1731 explicit constexpr 1732 weekday(const local_days& __dp) noexcept 1733 : weekday{sys_days{__dp.time_since_epoch()}} 1734 { } 1735 1736 constexpr weekday& 1737 operator++() noexcept 1738 { 1739 *this += days{1}; 1740 return *this; 1741 } 1742 1743 constexpr weekday 1744 operator++(int) noexcept 1745 { 1746 auto __ret = *this; 1747 ++(*this); 1748 return __ret; 1749 } 1750 1751 constexpr weekday& 1752 operator--() noexcept 1753 { 1754 *this -= days{1}; 1755 return *this; 1756 } 1757 1758 constexpr weekday 1759 operator--(int) noexcept 1760 { 1761 auto __ret = *this; 1762 --(*this); 1763 return __ret; 1764 } 1765 1766 constexpr weekday& 1767 operator+=(const days& __d) noexcept 1768 { 1769 *this = *this + __d; 1770 return *this; 1771 } 1772 1773 constexpr weekday& 1774 operator-=(const days& __d) noexcept 1775 { 1776 *this = *this - __d; 1777 return *this; 1778 } 1779 1780 constexpr unsigned 1781 c_encoding() const noexcept 1782 { return _M_wd; } 1783 1784 constexpr unsigned 1785 iso_encoding() const noexcept 1786 { return _M_wd == 0u ? 7u : _M_wd; } 1787 1788 constexpr bool 1789 ok() const noexcept 1790 { return _M_wd <= 6; } 1791 1792 constexpr weekday_indexed 1793 operator[](unsigned __index) const noexcept; 1794 1795 constexpr weekday_last 1796 operator[](last_spec) const noexcept; 1797 1798 friend constexpr bool 1799 operator==(const weekday& __x, const weekday& __y) noexcept 1800 { return __x._M_wd == __y._M_wd; } 1801 1802 friend constexpr weekday 1803 operator+(const weekday& __x, const days& __y) noexcept 1804 { 1805 auto __n = static_cast
(__x._M_wd) + __y.count(); 1806 return weekday{__detail::__modulo(__n, 7)}; 1807 } 1808 1809 friend constexpr weekday 1810 operator+(const days& __x, const weekday& __y) noexcept 1811 { return __y + __x; } 1812 1813 friend constexpr weekday 1814 operator-(const weekday& __x, const days& __y) noexcept 1815 { return __x + -__y; } 1816 1817 friend constexpr days 1818 operator-(const weekday& __x, const weekday& __y) noexcept 1819 { 1820 auto __n = static_cast
(__x._M_wd) - __y._M_wd; 1821 return days{__detail::__modulo(__n, 7)}; 1822 } 1823 1824 // TODO: operator<<, from_stream. 1825 }; 1826 1827 inline constexpr weekday Sunday{0}; 1828 inline constexpr weekday Monday{1}; 1829 inline constexpr weekday Tuesday{2}; 1830 inline constexpr weekday Wednesday{3}; 1831 inline constexpr weekday Thursday{4}; 1832 inline constexpr weekday Friday{5}; 1833 inline constexpr weekday Saturday{6}; 1834 1835 // WEEKDAY_INDEXED 1836 1837 class weekday_indexed 1838 { 1839 private: 1840 chrono::weekday _M_wd; 1841 unsigned char _M_index; 1842 1843 public: 1844 weekday_indexed() = default; 1845 1846 constexpr 1847 weekday_indexed(const chrono::weekday& __wd, unsigned __index) noexcept 1848 : _M_wd(__wd), _M_index(__index) 1849 { } 1850 1851 constexpr chrono::weekday 1852 weekday() const noexcept 1853 { return _M_wd; } 1854 1855 constexpr unsigned 1856 index() const noexcept 1857 { return _M_index; }; 1858 1859 constexpr bool 1860 ok() const noexcept 1861 { return _M_wd.ok() && 1 <= _M_index && _M_index <= 5; } 1862 1863 friend constexpr bool 1864 operator==(const weekday_indexed& __x, const weekday_indexed& __y) noexcept 1865 { return __x.weekday() == __y.weekday() && __x.index() == __y.index(); } 1866 1867 friend constexpr month_weekday 1868 operator/(const month& __m, const weekday_indexed& __wdi) noexcept; 1869 1870 friend constexpr month_weekday 1871 operator/(int __m, const weekday_indexed& __wdi) noexcept; 1872 1873 friend constexpr month_weekday 1874 operator/(const weekday_indexed& __wdi, const month& __m) noexcept; 1875 1876 friend constexpr month_weekday 1877 operator/(const weekday_indexed& __wdi, int __m) noexcept; 1878 1879 friend constexpr year_month_weekday 1880 operator/(const year_month& __ym, const weekday_indexed& __wdi) noexcept; 1881 1882 // TODO: Implement operator<<. 1883 }; 1884 1885 constexpr weekday_indexed 1886 weekday::operator[](unsigned __index) const noexcept 1887 { return {*this, __index}; } 1888 1889 // WEEKDAY_LAST 1890 1891 class weekday_last 1892 { 1893 private: 1894 chrono::weekday _M_wd; 1895 1896 public: 1897 explicit constexpr 1898 weekday_last(const chrono::weekday& __wd) noexcept 1899 : _M_wd{__wd} 1900 { } 1901 1902 constexpr chrono::weekday 1903 weekday() const noexcept 1904 { return _M_wd; } 1905 1906 constexpr bool 1907 ok() const noexcept 1908 { return _M_wd.ok(); } 1909 1910 friend constexpr bool 1911 operator==(const weekday_last& __x, const weekday_last& __y) noexcept 1912 { return __x.weekday() == __y.weekday(); } 1913 1914 friend constexpr month_weekday_last 1915 operator/(int __m, const weekday_last& __wdl) noexcept; 1916 1917 friend constexpr month_weekday_last 1918 operator/(const weekday_last& __wdl, int __m) noexcept; 1919 1920 friend constexpr year_month_weekday_last 1921 operator/(const year_month& __ym, const weekday_last& __wdl) noexcept; 1922 1923 // TODO: Implement operator<<. 1924 }; 1925 1926 constexpr weekday_last 1927 weekday::operator[](last_spec) const noexcept 1928 { return weekday_last{*this}; } 1929 1930 // MONTH_DAY 1931 1932 class month_day 1933 { 1934 private: 1935 chrono::month _M_m; 1936 chrono::day _M_d; 1937 1938 public: 1939 month_day() = default; 1940 1941 constexpr 1942 month_day(const chrono::month& __m, const chrono::day& __d) noexcept 1943 : _M_m{__m}, _M_d{__d} 1944 { } 1945 1946 constexpr chrono::month 1947 month() const noexcept 1948 { return _M_m; } 1949 1950 constexpr chrono::day 1951 day() const noexcept 1952 { return _M_d; } 1953 1954 constexpr bool 1955 ok() const noexcept 1956 { 1957 return _M_m.ok() 1958 && 1u <= unsigned(_M_d) 1959 && unsigned(_M_d) <= __detail::__days_per_month[unsigned(_M_m) - 1]; 1960 } 1961 1962 friend constexpr bool 1963 operator==(const month_day& __x, const month_day& __y) noexcept 1964 { return __x.month() == __y.month() && __x.day() == __y.day(); } 1965 1966 friend constexpr strong_ordering 1967 operator<=>(const month_day& __x, const month_day& __y) noexcept 1968 = default; 1969 1970 friend constexpr month_day 1971 operator/(const chrono::month& __m, const chrono::day& __d) noexcept 1972 { return {__m, __d}; } 1973 1974 friend constexpr month_day 1975 operator/(const chrono::month& __m, int __d) noexcept 1976 { return {__m, chrono::day(unsigned(__d))}; } 1977 1978 friend constexpr month_day 1979 operator/(int __m, const chrono::day& __d) noexcept 1980 { return {chrono::month(unsigned(__m)), __d}; } 1981 1982 friend constexpr month_day 1983 operator/(const chrono::day& __d, const chrono::month& __m) noexcept 1984 { return {__m, __d}; } 1985 1986 friend constexpr month_day 1987 operator/(const chrono::day& __d, int __m) noexcept 1988 { return {chrono::month(unsigned(__m)), __d}; } 1989 1990 friend constexpr year_month_day 1991 operator/(int __y, const month_day& __md) noexcept; 1992 1993 friend constexpr year_month_day 1994 operator/(const month_day& __md, int __y) noexcept; 1995 1996 // TODO: Implement operator<<, from_stream. 1997 }; 1998 1999 // MONTH_DAY_LAST 2000 2001 class month_day_last 2002 { 2003 private: 2004 chrono::month _M_m; 2005 2006 public: 2007 explicit constexpr 2008 month_day_last(const chrono::month& __m) noexcept 2009 : _M_m{__m} 2010 { } 2011 2012 constexpr chrono::month 2013 month() const noexcept 2014 { return _M_m; } 2015 2016 constexpr bool 2017 ok() const noexcept 2018 { return _M_m.ok(); } 2019 2020 friend constexpr bool 2021 operator==(const month_day_last& __x, const month_day_last& __y) noexcept 2022 { return __x.month() == __y.month(); } 2023 2024 friend constexpr strong_ordering 2025 operator<=>(const month_day_last& __x, const month_day_last& __y) noexcept 2026 = default; 2027 2028 friend constexpr month_day_last 2029 operator/(const chrono::month& __m, last_spec) noexcept 2030 { return month_day_last{__m}; } 2031 2032 friend constexpr month_day_last 2033 operator/(int __m, last_spec) noexcept 2034 { return chrono::month(unsigned(__m)) / last; } 2035 2036 friend constexpr month_day_last 2037 operator/(last_spec, const chrono::month& __m) noexcept 2038 { return __m / last; } 2039 2040 friend constexpr month_day_last 2041 operator/(last_spec, int __m) noexcept 2042 { return __m / last; } 2043 2044 friend constexpr year_month_day_last 2045 operator/(int __y, const month_day_last& __mdl) noexcept; 2046 2047 friend constexpr year_month_day_last 2048 operator/(const month_day_last& __mdl, int __y) noexcept; 2049 2050 // TODO: Implement operator<<. 2051 }; 2052 2053 // MONTH_WEEKDAY 2054 2055 class month_weekday 2056 { 2057 private: 2058 chrono::month _M_m; 2059 chrono::weekday_indexed _M_wdi; 2060 2061 public: 2062 constexpr 2063 month_weekday(const chrono::month& __m, 2064 const chrono::weekday_indexed& __wdi) noexcept 2065 : _M_m{__m}, _M_wdi{__wdi} 2066 { } 2067 2068 constexpr chrono::month 2069 month() const noexcept 2070 { return _M_m; } 2071 2072 constexpr chrono::weekday_indexed 2073 weekday_indexed() const noexcept 2074 { return _M_wdi; } 2075 2076 constexpr bool 2077 ok() const noexcept 2078 { return _M_m.ok() && _M_wdi.ok(); } 2079 2080 friend constexpr bool 2081 operator==(const month_weekday& __x, const month_weekday& __y) noexcept 2082 { 2083 return __x.month() == __y.month() 2084 && __x.weekday_indexed() == __y.weekday_indexed(); 2085 } 2086 2087 friend constexpr month_weekday 2088 operator/(const chrono::month& __m, 2089 const chrono::weekday_indexed& __wdi) noexcept 2090 { return {__m, __wdi}; } 2091 2092 friend constexpr month_weekday 2093 operator/(int __m, const chrono::weekday_indexed& __wdi) noexcept 2094 { return chrono::month(unsigned(__m)) / __wdi; } 2095 2096 friend constexpr month_weekday 2097 operator/(const chrono::weekday_indexed& __wdi, 2098 const chrono::month& __m) noexcept 2099 { return __m / __wdi; } 2100 2101 friend constexpr month_weekday 2102 operator/(const chrono::weekday_indexed& __wdi, int __m) noexcept 2103 { return __m / __wdi; } 2104 2105 friend constexpr year_month_weekday 2106 operator/(int __y, const month_weekday& __mwd) noexcept; 2107 2108 friend constexpr year_month_weekday 2109 operator/(const month_weekday& __mwd, int __y) noexcept; 2110 2111 // TODO: Implement operator<<. 2112 }; 2113 2114 // MONTH_WEEKDAY_LAST 2115 2116 class month_weekday_last 2117 { 2118 private: 2119 chrono::month _M_m; 2120 chrono::weekday_last _M_wdl; 2121 2122 public: 2123 constexpr 2124 month_weekday_last(const chrono::month& __m, 2125 const chrono::weekday_last& __wdl) noexcept 2126 :_M_m{__m}, _M_wdl{__wdl} 2127 { } 2128 2129 constexpr chrono::month 2130 month() const noexcept 2131 { return _M_m; } 2132 2133 constexpr chrono::weekday_last 2134 weekday_last() const noexcept 2135 { return _M_wdl; } 2136 2137 constexpr bool 2138 ok() const noexcept 2139 { return _M_m.ok() && _M_wdl.ok(); } 2140 2141 friend constexpr bool 2142 operator==(const month_weekday_last& __x, 2143 const month_weekday_last& __y) noexcept 2144 { 2145 return __x.month() == __y.month() 2146 && __x.weekday_last() == __y.weekday_last(); 2147 } 2148 2149 friend constexpr month_weekday_last 2150 operator/(const chrono::month& __m, 2151 const chrono::weekday_last& __wdl) noexcept 2152 { return {__m, __wdl}; } 2153 2154 friend constexpr month_weekday_last 2155 operator/(int __m, const chrono::weekday_last& __wdl) noexcept 2156 { return chrono::month(unsigned(__m)) / __wdl; } 2157 2158 friend constexpr month_weekday_last 2159 operator/(const chrono::weekday_last& __wdl, 2160 const chrono::month& __m) noexcept 2161 { return __m / __wdl; } 2162 2163 friend constexpr month_weekday_last 2164 operator/(const chrono::weekday_last& __wdl, int __m) noexcept 2165 { return chrono::month(unsigned(__m)) / __wdl; } 2166 2167 friend constexpr year_month_weekday_last 2168 operator/(int __y, const month_weekday_last& __mwdl) noexcept; 2169 2170 friend constexpr year_month_weekday_last 2171 operator/(const month_weekday_last& __mwdl, int __y) noexcept; 2172 2173 // TODO: Implement operator<<. 2174 }; 2175 2176 // YEAR_MONTH 2177 2178 namespace __detail 2179 { 2180 // [time.cal.ym], [time.cal.ymd], etc constrain the 'months'-based 2181 // addition/subtraction operator overloads like so: 2182 // 2183 // Constraints: if the argument supplied by the caller for the months 2184 // parameter is convertible to years, its implicit conversion sequence 2185 // to years is worse than its implicit conversion sequence to months. 2186 // 2187 // We realize this constraint by templatizing the 'months'-based 2188 // overloads (using a dummy defaulted template parameter), so that 2189 // overload resolution doesn't select the 'months'-based overload unless 2190 // the implicit conversion sequence to 'months' is better than that to 2191 // 'years'. 2192 using __months_years_conversion_disambiguator = void; 2193 } 2194 2195 class year_month 2196 { 2197 private: 2198 chrono::year _M_y; 2199 chrono::month _M_m; 2200 2201 public: 2202 year_month() = default; 2203 2204 constexpr 2205 year_month(const chrono::year& __y, const chrono::month& __m) noexcept 2206 : _M_y{__y}, _M_m{__m} 2207 { } 2208 2209 constexpr chrono::year 2210 year() const noexcept 2211 { return _M_y; } 2212 2213 constexpr chrono::month 2214 month() const noexcept 2215 { return _M_m; } 2216 2217 template
2218 constexpr year_month& 2219 operator+=(const months& __dm) noexcept 2220 { 2221 *this = *this + __dm; 2222 return *this; 2223 } 2224 2225 template
2226 constexpr year_month& 2227 operator-=(const months& __dm) noexcept 2228 { 2229 *this = *this - __dm; 2230 return *this; 2231 } 2232 2233 constexpr year_month& 2234 operator+=(const years& __dy) noexcept 2235 { 2236 *this = *this + __dy; 2237 return *this; 2238 } 2239 2240 constexpr year_month& 2241 operator-=(const years& __dy) noexcept 2242 { 2243 *this = *this - __dy; 2244 return *this; 2245 } 2246 2247 constexpr bool 2248 ok() const noexcept 2249 { return _M_y.ok() && _M_m.ok(); } 2250 2251 friend constexpr bool 2252 operator==(const year_month& __x, const year_month& __y) noexcept 2253 { return __x.year() == __y.year() && __x.month() == __y.month(); } 2254 2255 friend constexpr strong_ordering 2256 operator<=>(const year_month& __x, const year_month& __y) noexcept 2257 = default; 2258 2259 template
2260 friend constexpr year_month 2261 operator+(const year_month& __ym, const months& __dm) noexcept 2262 { 2263 // TODO: Optimize? 2264 auto __m = __ym.month() + __dm; 2265 auto __i = int(unsigned(__ym.month())) - 1 + __dm.count(); 2266 auto __y = (__i < 0 2267 ? __ym.year() + years{(__i - 11) / 12} 2268 : __ym.year() + years{__i / 12}); 2269 return __y / __m; 2270 } 2271 2272 template
2273 friend constexpr year_month 2274 operator+(const months& __dm, const year_month& __ym) noexcept 2275 { return __ym + __dm; } 2276 2277 template
2278 friend constexpr year_month 2279 operator-(const year_month& __ym, const months& __dm) noexcept 2280 { return __ym + -__dm; } 2281 2282 friend constexpr months 2283 operator-(const year_month& __x, const year_month& __y) noexcept 2284 { 2285 return (__x.year() - __y.year() 2286 + months{static_cast
(unsigned{__x.month()}) 2287 - static_cast
(unsigned{__y.month()})}); 2288 } 2289 2290 friend constexpr year_month 2291 operator+(const year_month& __ym, const years& __dy) noexcept 2292 { return (__ym.year() + __dy) / __ym.month(); } 2293 2294 friend constexpr year_month 2295 operator+(const years& __dy, const year_month& __ym) noexcept 2296 { return __ym + __dy; } 2297 2298 friend constexpr year_month 2299 operator-(const year_month& __ym, const years& __dy) noexcept 2300 { return __ym + -__dy; } 2301 2302 friend constexpr year_month 2303 operator/(const chrono::year& __y, const chrono::month& __m) noexcept 2304 { return {__y, __m}; } 2305 2306 friend constexpr year_month 2307 operator/(const chrono::year& __y, int __m) noexcept 2308 { return {__y, chrono::month(unsigned(__m))}; } 2309 2310 friend constexpr year_month_day 2311 operator/(const year_month& __ym, int __d) noexcept; 2312 2313 friend constexpr year_month_day_last 2314 operator/(const year_month& __ym, last_spec) noexcept; 2315 2316 // TODO: Implement operator<<, from_stream. 2317 }; 2318 2319 // YEAR_MONTH_DAY 2320 2321 class year_month_day 2322 { 2323 private: 2324 chrono::year _M_y; 2325 chrono::month _M_m; 2326 chrono::day _M_d; 2327 2328 static constexpr year_month_day _S_from_days(const days& __dp) noexcept; 2329 2330 constexpr days _M_days_since_epoch() const noexcept; 2331 2332 public: 2333 year_month_day() = default; 2334 2335 constexpr 2336 year_month_day(const chrono::year& __y, const chrono::month& __m, 2337 const chrono::day& __d) noexcept 2338 : _M_y{__y}, _M_m{__m}, _M_d{__d} 2339 { } 2340 2341 constexpr 2342 year_month_day(const year_month_day_last& __ymdl) noexcept; 2343 2344 constexpr 2345 year_month_day(const sys_days& __dp) noexcept 2346 : year_month_day(_S_from_days(__dp.time_since_epoch())) 2347 { } 2348 2349 explicit constexpr 2350 year_month_day(const local_days& __dp) noexcept 2351 : year_month_day(sys_days{__dp.time_since_epoch()}) 2352 { } 2353 2354 template
2355 constexpr year_month_day& 2356 operator+=(const months& __m) noexcept 2357 { 2358 *this = *this + __m; 2359 return *this; 2360 } 2361 2362 template
2363 constexpr year_month_day& 2364 operator-=(const months& __m) noexcept 2365 { 2366 *this = *this - __m; 2367 return *this; 2368 } 2369 2370 constexpr year_month_day& 2371 operator+=(const years& __y) noexcept 2372 { 2373 *this = *this + __y; 2374 return *this; 2375 } 2376 2377 constexpr year_month_day& 2378 operator-=(const years& __y) noexcept 2379 { 2380 *this = *this - __y; 2381 return *this; 2382 } 2383 2384 constexpr chrono::year 2385 year() const noexcept 2386 { return _M_y; } 2387 2388 constexpr chrono::month 2389 month() const noexcept 2390 { return _M_m; } 2391 2392 constexpr chrono::day 2393 day() const noexcept 2394 { return _M_d; } 2395 2396 constexpr 2397 operator sys_days() const noexcept 2398 { return sys_days{_M_days_since_epoch()}; } 2399 2400 explicit constexpr 2401 operator local_days() const noexcept 2402 { return local_days{sys_days{*this}.time_since_epoch()}; } 2403 2404 constexpr bool ok() const noexcept; 2405 2406 friend constexpr bool 2407 operator==(const year_month_day& __x, const year_month_day& __y) noexcept 2408 { 2409 return __x.year() == __y.year() 2410 && __x.month() == __y.month() 2411 && __x.day() == __y.day(); 2412 } 2413 2414 friend constexpr strong_ordering 2415 operator<=>(const year_month_day& __x, const year_month_day& __y) noexcept 2416 = default; 2417 2418 template
2419 friend constexpr year_month_day 2420 operator+(const year_month_day& __ymd, const months& __dm) noexcept 2421 { return (__ymd.year() / __ymd.month() + __dm) / __ymd.day(); } 2422 2423 template
2424 friend constexpr year_month_day 2425 operator+(const months& __dm, const year_month_day& __ymd) noexcept 2426 { return __ymd + __dm; } 2427 2428 friend constexpr year_month_day 2429 operator+(const year_month_day& __ymd, const years& __dy) noexcept 2430 { return (__ymd.year() + __dy) / __ymd.month() / __ymd.day(); } 2431 2432 friend constexpr year_month_day 2433 operator+(const years& __dy, const year_month_day& __ymd) noexcept 2434 { return __ymd + __dy; } 2435 2436 template
2437 friend constexpr year_month_day 2438 operator-(const year_month_day& __ymd, const months& __dm) noexcept 2439 { return __ymd + -__dm; } 2440 2441 friend constexpr year_month_day 2442 operator-(const year_month_day& __ymd, const years& __dy) noexcept 2443 { return __ymd + -__dy; } 2444 2445 friend constexpr year_month_day 2446 operator/(const year_month& __ym, const chrono::day& __d) noexcept 2447 { return {__ym.year(), __ym.month(), __d}; } 2448 2449 friend constexpr year_month_day 2450 operator/(const year_month& __ym, int __d) noexcept 2451 { return __ym / chrono::day{unsigned(__d)}; } 2452 2453 friend constexpr year_month_day 2454 operator/(const chrono::year& __y, const month_day& __md) noexcept 2455 { return __y / __md.month() / __md.day(); } 2456 2457 friend constexpr year_month_day 2458 operator/(int __y, const month_day& __md) noexcept 2459 { return chrono::year{__y} / __md; } 2460 2461 friend constexpr year_month_day 2462 operator/(const month_day& __md, const chrono::year& __y) noexcept 2463 { return __y / __md; } 2464 2465 friend constexpr year_month_day 2466 operator/(const month_day& __md, int __y) noexcept 2467 { return chrono::year(__y) / __md; } 2468 2469 // TODO: Implement operator<<, from_stream. 2470 }; 2471 2472 // Construct from days since 1970/01/01. 2473 // Proposition 6.3 of Neri and Schneider, 2474 // "Euclidean Affine Functions and Applications to Calendar Algorithms". 2475 // https://arxiv.org/abs/2102.06959 2476 constexpr year_month_day 2477 year_month_day::_S_from_days(const days& __dp) noexcept 2478 { 2479 constexpr auto __z2 = static_cast
(-1468000); 2480 constexpr auto __r2_e3 = static_cast
(536895458); 2481 2482 const auto __r0 = static_cast
(__dp.count()) + __r2_e3; 2483 2484 const auto __n1 = 4 * __r0 + 3; 2485 const auto __q1 = __n1 / 146097; 2486 const auto __r1 = __n1 % 146097 / 4; 2487 2488 constexpr auto __p32 = static_cast
(1) << 32; 2489 const auto __n2 = 4 * __r1 + 3; 2490 const auto __u2 = static_cast
(2939745) * __n2; 2491 const auto __q2 = static_cast
(__u2 / __p32); 2492 const auto __r2 = static_cast
(__u2 % __p32) / 2939745 / 4; 2493 2494 constexpr auto __p16 = static_cast
(1) << 16; 2495 const auto __n3 = 2141 * __r2 + 197913; 2496 const auto __q3 = __n3 / __p16; 2497 const auto __r3 = __n3 % __p16 / 2141; 2498 2499 const auto __y0 = 100 * __q1 + __q2; 2500 const auto __m0 = __q3; 2501 const auto __d0 = __r3; 2502 2503 const auto __j = __r2 >= 306; 2504 const auto __y1 = __y0 + __j; 2505 const auto __m1 = __j ? __m0 - 12 : __m0; 2506 const auto __d1 = __d0 + 1; 2507 2508 return year_month_day{chrono::year{static_cast
(__y1 + __z2)}, 2509 chrono::month{__m1}, chrono::day{__d1}}; 2510 } 2511 2512 // Days since 1970/01/01. 2513 // Proposition 6.2 of Neri and Schneider, 2514 // "Euclidean Affine Functions and Applications to Calendar Algorithms". 2515 // https://arxiv.org/abs/2102.06959 2516 constexpr days 2517 year_month_day::_M_days_since_epoch() const noexcept 2518 { 2519 auto constexpr __z2 = static_cast
(-1468000); 2520 auto constexpr __r2_e3 = static_cast
(536895458); 2521 2522 const auto __y1 = static_cast
(static_cast
(_M_y)) - __z2; 2523 const auto __m1 = static_cast
(static_cast
(_M_m)); 2524 const auto __d1 = static_cast
(static_cast
(_M_d)); 2525 2526 const auto __j = static_cast
(__m1 < 3); 2527 const auto __y0 = __y1 - __j; 2528 const auto __m0 = __j ? __m1 + 12 : __m1; 2529 const auto __d0 = __d1 - 1; 2530 2531 const auto __q1 = __y0 / 100; 2532 const auto __yc = 1461 * __y0 / 4 - __q1 + __q1 / 4; 2533 const auto __mc = (979 *__m0 - 2919) / 32; 2534 const auto __dc = __d0; 2535 2536 return days{static_cast
(__yc + __mc + __dc - __r2_e3)}; 2537 } 2538 2539 // YEAR_MONTH_DAY_LAST 2540 2541 class year_month_day_last 2542 { 2543 private: 2544 chrono::year _M_y; 2545 chrono::month_day_last _M_mdl; 2546 2547 public: 2548 constexpr 2549 year_month_day_last(const chrono::year& __y, 2550 const chrono::month_day_last& __mdl) noexcept 2551 : _M_y{__y}, _M_mdl{__mdl} 2552 { } 2553 2554 template
2555 constexpr year_month_day_last& 2556 operator+=(const months& __m) noexcept 2557 { 2558 *this = *this + __m; 2559 return *this; 2560 } 2561 2562 template
2563 constexpr year_month_day_last& 2564 operator-=(const months& __m) noexcept 2565 { 2566 *this = *this - __m; 2567 return *this; 2568 } 2569 2570 constexpr year_month_day_last& 2571 operator+=(const years& __y) noexcept 2572 { 2573 *this = *this + __y; 2574 return *this; 2575 } 2576 2577 constexpr year_month_day_last& 2578 operator-=(const years& __y) noexcept 2579 { 2580 *this = *this - __y; 2581 return *this; 2582 } 2583 2584 constexpr chrono::year 2585 year() const noexcept 2586 { return _M_y; } 2587 2588 constexpr chrono::month 2589 month() const noexcept 2590 { return _M_mdl.month(); } 2591 2592 constexpr chrono::month_day_last 2593 month_day_last() const noexcept 2594 { return _M_mdl; } 2595 2596 // Return A day representing the last day of this year, month pair. 2597 constexpr chrono::day 2598 day() const noexcept 2599 { 2600 const auto __m = static_cast
(month()); 2601 2602 // Excluding February, the last day of month __m is either 30 or 31 or, 2603 // in another words, it is 30 + b = 30 | b, where b is in {0, 1}. 2604 2605 // If __m in {1, 3, 4, 5, 6, 7}, then b is 1 if, and only if __m is odd. 2606 // Hence, b = __m & 1 = (__m ^ 0) & 1. 2607 2608 // If __m in {8, 9, 10, 11, 12}, then b is 1 if, and only if __m is even. 2609 // Hence, b = (__m ^ 1) & 1. 2610 2611 // Therefore, b = (__m ^ c) & 1, where c = 0, if __m < 8, or c = 1 if 2612 // __m >= 8, that is, c = __m >> 3. 2613 2614 // The above mathematically justifies this implementation whose 2615 // performance does not depend on look-up tables being on the L1 cache. 2616 return chrono::day{__m != 2 ? ((__m ^ (__m >> 3)) & 1) | 30 2617 : _M_y.is_leap() ? 29 : 28}; 2618 } 2619 2620 constexpr 2621 operator sys_days() const noexcept 2622 { return sys_days{year() / month() / day()}; } 2623 2624 explicit constexpr 2625 operator local_days() const noexcept 2626 { return local_days{sys_days{*this}.time_since_epoch()}; } 2627 2628 constexpr bool 2629 ok() const noexcept 2630 { return _M_y.ok() && _M_mdl.ok(); } 2631 2632 friend constexpr bool 2633 operator==(const year_month_day_last& __x, 2634 const year_month_day_last& __y) noexcept 2635 { 2636 return __x.year() == __y.year() 2637 && __x.month_day_last() == __y.month_day_last(); 2638 } 2639 2640 friend constexpr strong_ordering 2641 operator<=>(const year_month_day_last& __x, 2642 const year_month_day_last& __y) noexcept 2643 = default; 2644 2645 template
2646 friend constexpr year_month_day_last 2647 operator+(const year_month_day_last& __ymdl, 2648 const months& __dm) noexcept 2649 { return (__ymdl.year() / __ymdl.month() + __dm) / last; } 2650 2651 template
2652 friend constexpr year_month_day_last 2653 operator+(const months& __dm, 2654 const year_month_day_last& __ymdl) noexcept 2655 { return __ymdl + __dm; } 2656 2657 template
2658 friend constexpr year_month_day_last 2659 operator-(const year_month_day_last& __ymdl, 2660 const months& __dm) noexcept 2661 { return __ymdl + -__dm; } 2662 2663 friend constexpr year_month_day_last 2664 operator+(const year_month_day_last& __ymdl, 2665 const years& __dy) noexcept 2666 { return {__ymdl.year() + __dy, __ymdl.month_day_last()}; } 2667 2668 friend constexpr year_month_day_last 2669 operator+(const years& __dy, 2670 const year_month_day_last& __ymdl) noexcept 2671 { return __ymdl + __dy; } 2672 2673 friend constexpr year_month_day_last 2674 operator-(const year_month_day_last& __ymdl, 2675 const years& __dy) noexcept 2676 { return __ymdl + -__dy; } 2677 2678 friend constexpr year_month_day_last 2679 operator/(const year_month& __ym, last_spec) noexcept 2680 { return {__ym.year(), chrono::month_day_last{__ym.month()}}; } 2681 2682 friend constexpr year_month_day_last 2683 operator/(const chrono::year& __y, 2684 const chrono::month_day_last& __mdl) noexcept 2685 { return {__y, __mdl}; } 2686 2687 friend constexpr year_month_day_last 2688 operator/(int __y, const chrono::month_day_last& __mdl) noexcept 2689 { return chrono::year(__y) / __mdl; } 2690 2691 friend constexpr year_month_day_last 2692 operator/(const chrono::month_day_last& __mdl, 2693 const chrono::year& __y) noexcept 2694 { return __y / __mdl; } 2695 2696 friend constexpr year_month_day_last 2697 operator/(const chrono::month_day_last& __mdl, int __y) noexcept 2698 { return chrono::year(__y) / __mdl; } 2699 2700 // TODO: Implement operator<<. 2701 }; 2702 2703 // year_month_day ctor from year_month_day_last 2704 constexpr 2705 year_month_day::year_month_day(const year_month_day_last& __ymdl) noexcept 2706 : _M_y{__ymdl.year()}, _M_m{__ymdl.month()}, _M_d{__ymdl.day()} 2707 { } 2708 2709 constexpr bool 2710 year_month_day::ok() const noexcept 2711 { 2712 if (!_M_y.ok() || !_M_m.ok()) 2713 return false; 2714 return chrono::day{1} <= _M_d && _M_d <= (_M_y / _M_m / last).day(); 2715 } 2716 2717 // YEAR_MONTH_WEEKDAY 2718 2719 class year_month_weekday 2720 { 2721 private: 2722 chrono::year _M_y; 2723 chrono::month _M_m; 2724 chrono::weekday_indexed _M_wdi; 2725 2726 static constexpr year_month_weekday 2727 _S_from_sys_days(const sys_days& __dp) 2728 { 2729 year_month_day __ymd{__dp}; 2730 chrono::weekday __wd{__dp}; 2731 auto __index = __wd[(unsigned{__ymd.day()} - 1) / 7 + 1]; 2732 return {__ymd.year(), __ymd.month(), __index}; 2733 } 2734 2735 public: 2736 year_month_weekday() = default; 2737 2738 constexpr 2739 year_month_weekday(const chrono::year& __y, const chrono::month& __m, 2740 const chrono::weekday_indexed& __wdi) noexcept 2741 : _M_y{__y}, _M_m{__m}, _M_wdi{__wdi} 2742 { } 2743 2744 constexpr 2745 year_month_weekday(const sys_days& __dp) noexcept 2746 : year_month_weekday{_S_from_sys_days(__dp)} 2747 { } 2748 2749 explicit constexpr 2750 year_month_weekday(const local_days& __dp) noexcept 2751 : year_month_weekday{sys_days{__dp.time_since_epoch()}} 2752 { } 2753 2754 template
2755 constexpr year_month_weekday& 2756 operator+=(const months& __m) noexcept 2757 { 2758 *this = *this + __m; 2759 return *this; 2760 } 2761 2762 template
2763 constexpr year_month_weekday& 2764 operator-=(const months& __m) noexcept 2765 { 2766 *this = *this - __m; 2767 return *this; 2768 } 2769 2770 constexpr year_month_weekday& 2771 operator+=(const years& __y) noexcept 2772 { 2773 *this = *this + __y; 2774 return *this; 2775 } 2776 2777 constexpr year_month_weekday& 2778 operator-=(const years& __y) noexcept 2779 { 2780 *this = *this - __y; 2781 return *this; 2782 } 2783 2784 constexpr chrono::year 2785 year() const noexcept 2786 { return _M_y; } 2787 2788 constexpr chrono::month 2789 month() const noexcept 2790 { return _M_m; } 2791 2792 constexpr chrono::weekday 2793 weekday() const noexcept 2794 { return _M_wdi.weekday(); } 2795 2796 constexpr unsigned 2797 index() const noexcept 2798 { return _M_wdi.index(); } 2799 2800 constexpr chrono::weekday_indexed 2801 weekday_indexed() const noexcept 2802 { return _M_wdi; } 2803 2804 constexpr 2805 operator sys_days() const noexcept 2806 { 2807 auto __d = sys_days{year() / month() / 1}; 2808 return __d + (weekday() - chrono::weekday(__d) 2809 + days{(static_cast
(index())-1)*7}); 2810 } 2811 2812 explicit constexpr 2813 operator local_days() const noexcept 2814 { return local_days{sys_days{*this}.time_since_epoch()}; } 2815 2816 constexpr bool 2817 ok() const noexcept 2818 { 2819 if (!_M_y.ok() || !_M_m.ok() || !_M_wdi.ok()) 2820 return false; 2821 if (_M_wdi.index() <= 4) 2822 return true; 2823 days __d = (_M_wdi.weekday() 2824 - chrono::weekday{sys_days{_M_y / _M_m / 1}} 2825 + days((_M_wdi.index()-1)*7 + 1)); 2826 __glibcxx_assert(__d.count() >= 1); 2827 return __d.count() <= unsigned{(_M_y / _M_m / last).day()}; 2828 } 2829 2830 friend constexpr bool 2831 operator==(const year_month_weekday& __x, 2832 const year_month_weekday& __y) noexcept 2833 { 2834 return __x.year() == __y.year() 2835 && __x.month() == __y.month() 2836 && __x.weekday_indexed() == __y.weekday_indexed(); 2837 } 2838 2839 template
2840 friend constexpr year_month_weekday 2841 operator+(const year_month_weekday& __ymwd, const months& __dm) noexcept 2842 { 2843 return ((__ymwd.year() / __ymwd.month() + __dm) 2844 / __ymwd.weekday_indexed()); 2845 } 2846 2847 template
2848 friend constexpr year_month_weekday 2849 operator+(const months& __dm, const year_month_weekday& __ymwd) noexcept 2850 { return __ymwd + __dm; } 2851 2852 friend constexpr year_month_weekday 2853 operator+(const year_month_weekday& __ymwd, const years& __dy) noexcept 2854 { return {__ymwd.year() + __dy, __ymwd.month(), __ymwd.weekday_indexed()}; } 2855 2856 friend constexpr year_month_weekday 2857 operator+(const years& __dy, const year_month_weekday& __ymwd) noexcept 2858 { return __ymwd + __dy; } 2859 2860 template
2861 friend constexpr year_month_weekday 2862 operator-(const year_month_weekday& __ymwd, const months& __dm) noexcept 2863 { return __ymwd + -__dm; } 2864 2865 friend constexpr year_month_weekday 2866 operator-(const year_month_weekday& __ymwd, const years& __dy) noexcept 2867 { return __ymwd + -__dy; } 2868 2869 friend constexpr year_month_weekday 2870 operator/(const year_month& __ym, 2871 const chrono::weekday_indexed& __wdi) noexcept 2872 { return {__ym.year(), __ym.month(), __wdi}; } 2873 2874 friend constexpr year_month_weekday 2875 operator/(const chrono::year& __y, const month_weekday& __mwd) noexcept 2876 { return {__y, __mwd.month(), __mwd.weekday_indexed()}; } 2877 2878 friend constexpr year_month_weekday 2879 operator/(int __y, const month_weekday& __mwd) noexcept 2880 { return chrono::year(__y) / __mwd; } 2881 2882 friend constexpr year_month_weekday 2883 operator/(const month_weekday& __mwd, const chrono::year& __y) noexcept 2884 { return __y / __mwd; } 2885 2886 friend constexpr year_month_weekday 2887 operator/(const month_weekday& __mwd, int __y) noexcept 2888 { return chrono::year(__y) / __mwd; } 2889 2890 // TODO: Implement operator<<. 2891 }; 2892 2893 // YEAR_MONTH_WEEKDAY_LAST 2894 2895 class year_month_weekday_last 2896 { 2897 private: 2898 chrono::year _M_y; 2899 chrono::month _M_m; 2900 chrono::weekday_last _M_wdl; 2901 2902 public: 2903 constexpr 2904 year_month_weekday_last(const chrono::year& __y, const chrono::month& __m, 2905 const chrono::weekday_last& __wdl) noexcept 2906 : _M_y{__y}, _M_m{__m}, _M_wdl{__wdl} 2907 { } 2908 2909 template
2910 constexpr year_month_weekday_last& 2911 operator+=(const months& __m) noexcept 2912 { 2913 *this = *this + __m; 2914 return *this; 2915 } 2916 2917 template
2918 constexpr year_month_weekday_last& 2919 operator-=(const months& __m) noexcept 2920 { 2921 *this = *this - __m; 2922 return *this; 2923 } 2924 2925 constexpr year_month_weekday_last& 2926 operator+=(const years& __y) noexcept 2927 { 2928 *this = *this + __y; 2929 return *this; 2930 } 2931 2932 constexpr year_month_weekday_last& 2933 operator-=(const years& __y) noexcept 2934 { 2935 *this = *this - __y; 2936 return *this; 2937 } 2938 2939 constexpr chrono::year 2940 year() const noexcept 2941 { return _M_y; } 2942 2943 constexpr chrono::month 2944 month() const noexcept 2945 { return _M_m; } 2946 2947 constexpr chrono::weekday 2948 weekday() const noexcept 2949 { return _M_wdl.weekday(); } 2950 2951 constexpr chrono::weekday_last 2952 weekday_last() const noexcept 2953 { return _M_wdl; } 2954 2955 constexpr 2956 operator sys_days() const noexcept 2957 { 2958 const auto __d = sys_days{_M_y / _M_m / last}; 2959 return sys_days{(__d - (chrono::weekday{__d} 2960 - _M_wdl.weekday())).time_since_epoch()}; 2961 } 2962 2963 explicit constexpr 2964 operator local_days() const noexcept 2965 { return local_days{sys_days{*this}.time_since_epoch()}; } 2966 2967 constexpr bool 2968 ok() const noexcept 2969 { return _M_y.ok() && _M_m.ok() && _M_wdl.ok(); } 2970 2971 friend constexpr bool 2972 operator==(const year_month_weekday_last& __x, 2973 const year_month_weekday_last& __y) noexcept 2974 { 2975 return __x.year() == __y.year() 2976 && __x.month() == __y.month() 2977 && __x.weekday_last() == __y.weekday_last(); 2978 } 2979 2980 template
2981 friend constexpr year_month_weekday_last 2982 operator+(const year_month_weekday_last& __ymwdl, 2983 const months& __dm) noexcept 2984 { 2985 return ((__ymwdl.year() / __ymwdl.month() + __dm) 2986 / __ymwdl.weekday_last()); 2987 } 2988 2989 template
2990 friend constexpr year_month_weekday_last 2991 operator+(const months& __dm, 2992 const year_month_weekday_last& __ymwdl) noexcept 2993 { return __ymwdl + __dm; } 2994 2995 friend constexpr year_month_weekday_last 2996 operator+(const year_month_weekday_last& __ymwdl, 2997 const years& __dy) noexcept 2998 { return {__ymwdl.year() + __dy, __ymwdl.month(), __ymwdl.weekday_last()}; } 2999 3000 friend constexpr year_month_weekday_last 3001 operator+(const years& __dy, 3002 const year_month_weekday_last& __ymwdl) noexcept 3003 { return __ymwdl + __dy; } 3004 3005 template
3006 friend constexpr year_month_weekday_last 3007 operator-(const year_month_weekday_last& __ymwdl, 3008 const months& __dm) noexcept 3009 { return __ymwdl + -__dm; } 3010 3011 friend constexpr year_month_weekday_last 3012 operator-(const year_month_weekday_last& __ymwdl, 3013 const years& __dy) noexcept 3014 { return __ymwdl + -__dy; } 3015 3016 friend constexpr year_month_weekday_last 3017 operator/(const year_month& __ym, 3018 const chrono::weekday_last& __wdl) noexcept 3019 { return {__ym.year(), __ym.month(), __wdl}; } 3020 3021 friend constexpr year_month_weekday_last 3022 operator/(const chrono::year& __y, 3023 const chrono::month_weekday_last& __mwdl) noexcept 3024 { return {__y, __mwdl.month(), __mwdl.weekday_last()}; } 3025 3026 friend constexpr year_month_weekday_last 3027 operator/(int __y, const chrono::month_weekday_last& __mwdl) noexcept 3028 { return chrono::year(__y) / __mwdl; } 3029 3030 friend constexpr year_month_weekday_last 3031 operator/(const chrono::month_weekday_last& __mwdl, 3032 const chrono::year& __y) noexcept 3033 { return __y / __mwdl; } 3034 3035 friend constexpr year_month_weekday_last 3036 operator/(const chrono::month_weekday_last& __mwdl, int __y) noexcept 3037 { return chrono::year(__y) / __mwdl; } 3038 3039 // TODO: Implement operator<<. 3040 }; 3041 3042 // HH_MM_SS 3043 3044 namespace __detail 3045 { 3046 consteval long long 3047 __pow10(unsigned __n) 3048 { 3049 long long __r = 1; 3050 while (__n-- > 0) 3051 __r *= 10; 3052 return __r; 3053 } 3054 } 3055 3056 template
3057 class hh_mm_ss 3058 { 3059 private: 3060 static constexpr int 3061 _S_fractional_width() 3062 { 3063 int __multiplicity_2 = 0; 3064 int __multiplicity_5 = 0; 3065 auto __den = _Duration::period::den; 3066 while ((__den % 2) == 0) 3067 { 3068 ++__multiplicity_2; 3069 __den /= 2; 3070 } 3071 while ((__den % 5) == 0) 3072 { 3073 ++__multiplicity_5; 3074 __den /= 5; 3075 } 3076 if (__den != 1) 3077 return 6; 3078 3079 int __width = (__multiplicity_2 > __multiplicity_5 3080 ? __multiplicity_2 : __multiplicity_5); 3081 if (__width > 18) 3082 __width = 18; 3083 return __width; 3084 } 3085 3086 constexpr 3087 hh_mm_ss(_Duration __d, bool __is_neg) 3088 : _M_is_neg(__is_neg), 3089 _M_h (duration_cast
(__d)), 3090 _M_m (duration_cast
(__d - hours())), 3091 _M_s (duration_cast
(__d - hours() - minutes())) 3092 { 3093 auto __ss = __d - hours() - minutes() - seconds(); 3094 if constexpr (treat_as_floating_point_v
) 3095 _M_ss = __ss; 3096 else 3097 _M_ss = duration_cast
(__ss); 3098 } 3099 3100 static constexpr _Duration 3101 _S_abs(_Duration __d) 3102 { 3103 if constexpr (numeric_limits
::is_signed) 3104 return chrono::abs(__d); 3105 else 3106 return __d; 3107 } 3108 3109 public: 3110 static constexpr unsigned fractional_width = {_S_fractional_width()}; 3111 3112 using precision 3113 = duration
, 3115 ratio<1, __detail::__pow10(fractional_width)>>; 3116 3117 constexpr 3118 hh_mm_ss() noexcept 3119 : hh_mm_ss{_Duration::zero()} 3120 { } 3121 3122 constexpr explicit 3123 hh_mm_ss(_Duration __d) 3124 : hh_mm_ss(_S_abs(__d), __d < _Duration::zero()) 3125 { } 3126 3127 constexpr bool 3128 is_negative() const noexcept 3129 { return _M_is_neg; } 3130 3131 constexpr chrono::hours 3132 hours() const noexcept 3133 { return _M_h; } 3134 3135 constexpr chrono::minutes 3136 minutes() const noexcept 3137 { return _M_m; } 3138 3139 constexpr chrono::seconds 3140 seconds() const noexcept 3141 { return _M_s; } 3142 3143 constexpr precision 3144 subseconds() const noexcept 3145 { return _M_ss; } 3146 3147 constexpr explicit 3148 operator precision() const noexcept 3149 { return to_duration(); } 3150 3151 constexpr precision 3152 to_duration() const noexcept 3153 { 3154 if (_M_is_neg) 3155 return -(_M_h + _M_m + _M_s + _M_ss); 3156 else 3157 return _M_h + _M_m + _M_s + _M_ss; 3158 } 3159 3160 // TODO: Implement operator<<. 3161 3162 private: 3163 bool _M_is_neg; 3164 chrono::hours _M_h; 3165 chrono::minutes _M_m; 3166 chrono::seconds _M_s; 3167 precision _M_ss; 3168 }; 3169 #endif // C++20 3170 3171 /// @} group chrono 3172 } // namespace chrono 3173 3174 #if __cplusplus > 201103L 3175 3176 #define __cpp_lib_chrono_udls 201304 3177 3178 inline namespace literals 3179 { 3180 /** ISO C++ 2014 namespace for suffixes for duration literals. 3181 * 3182 * These suffixes can be used to create `chrono::duration` values with 3183 * tick periods of hours, minutes, seconds, milliseconds, microseconds 3184 * or nanoseconds. For example, `std::chrono::seconds(5)` can be written 3185 * as `5s` after making the suffix visible in the current scope. 3186 * The suffixes can be made visible by a using-directive or 3187 * using-declaration such as: 3188 * - `using namespace std::chrono_literals;` 3189 * - `using namespace std::literals;` 3190 * - `using namespace std::chrono;` 3191 * - `using namespace std;` 3192 * - `using std::chrono_literals::operator""s;` 3193 * 3194 * The result of these suffixes on an integer literal is one of the 3195 * standard typedefs such as `std::chrono::hours`. 3196 * The result on a floating-point literal is a duration type with the 3197 * specified tick period and an unspecified floating-point representation, 3198 * for example `1.5e2ms` might be equivalent to 3199 * `chrono::duration
(1.5e2)`. 3200 * 3201 * @ingroup chrono 3202 */ 3203 inline namespace chrono_literals 3204 { 3205 /// @addtogroup chrono 3206 /// @{ 3207 3208 #pragma GCC diagnostic push 3209 #pragma GCC diagnostic ignored "-Wliteral-suffix" 3210 /// @cond undocumented 3211 template
3212 constexpr _Dur __check_overflow() 3213 { 3214 using _Val = __parse_int::_Parse_int<_Digits...>; 3215 constexpr typename _Dur::rep __repval = _Val::value; 3216 static_assert(__repval >= 0 && __repval == _Val::value, 3217 "literal value cannot be represented by duration type"); 3218 return _Dur(__repval); 3219 } 3220 /// @endcond 3221 3222 /// Literal suffix for durations representing non-integer hours 3223 constexpr chrono::duration
> 3224 operator""h(long double __hours) 3225 { return chrono::duration
>{__hours}; } 3226 3227 /// Literal suffix for durations of type `std::chrono::hours` 3228 template
3229 constexpr chrono::hours 3230 operator""h() 3231 { return __check_overflow
(); } 3232 3233 /// Literal suffix for durations representing non-integer minutes 3234 constexpr chrono::duration
> 3235 operator""min(long double __mins) 3236 { return chrono::duration
>{__mins}; } 3237 3238 /// Literal suffix for durations of type `std::chrono::minutes` 3239 template
3240 constexpr chrono::minutes 3241 operator""min() 3242 { return __check_overflow
(); } 3243 3244 /// Literal suffix for durations representing non-integer seconds 3245 constexpr chrono::duration
3246 operator""s(long double __secs) 3247 { return chrono::duration
{__secs}; } 3248 3249 /// Literal suffix for durations of type `std::chrono::seconds` 3250 template