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