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