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