libstdc++
chrono_io.h
Go to the documentation of this file.
1 // <chrono> Formatting -*- C++ -*-
2 
3 // Copyright The GNU Toolchain Authors.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/bits/chrono_io.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{chrono}
28  */
29 
30 #ifndef _GLIBCXX_CHRONO_IO_H
31 #define _GLIBCXX_CHRONO_IO_H 1
32 
33 #ifdef _GLIBCXX_SYSHDR
34 #pragma GCC system_header
35 #endif
36 
37 #if __cplusplus >= 202002L
38 
39 #include <sstream> // ostringstream
40 #include <iomanip> // setw, setfill
41 #include <format>
42 #include <charconv> // from_chars
43 #include <stdexcept> // __sso_string
44 
45 #include <bits/streambuf_iterator.h>
46 #include <bits/unique_ptr.h>
47 
48 namespace std _GLIBCXX_VISIBILITY(default)
49 {
50 _GLIBCXX_BEGIN_NAMESPACE_VERSION
51 
52 namespace chrono
53 {
54 /// @addtogroup chrono
55 /// @{
56 
57 /// @cond undocumented
58 namespace __detail
59 {
60 #define _GLIBCXX_WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
61 #define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
62 
63  template<typename _Period, typename _CharT>
64  constexpr basic_string_view<_CharT>
65  __units_suffix() noexcept
66  {
67  // The standard say these are all narrow strings, which would need to
68  // be widened at run-time when inserted into a wide stream. We use
69  // STATICALLY-WIDEN to widen at compile-time.
70 #define _GLIBCXX_UNITS_SUFFIX(period, suffix) \
71  if constexpr (is_same_v<_Period, period>) \
72  return _GLIBCXX_WIDEN(suffix); \
73  else
74 
75  _GLIBCXX_UNITS_SUFFIX(atto, "as")
76  _GLIBCXX_UNITS_SUFFIX(femto, "fs")
77  _GLIBCXX_UNITS_SUFFIX(pico, "ps")
78  _GLIBCXX_UNITS_SUFFIX(nano, "ns")
79  _GLIBCXX_UNITS_SUFFIX(milli, "ms")
80 #if _GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX
81  // Deciding this at compile-time is wrong, maybe use nl_langinfo(CODESET)
82  // to check runtime environment and return u8"\u00b5s", "\xb5s", or "us".
83  _GLIBCXX_UNITS_SUFFIX(micro, "\u00b5s")
84 #else
85  _GLIBCXX_UNITS_SUFFIX(micro, "us")
86 #endif
87  _GLIBCXX_UNITS_SUFFIX(centi, "cs")
88  _GLIBCXX_UNITS_SUFFIX(deci, "ds")
89  _GLIBCXX_UNITS_SUFFIX(ratio<1>, "s")
90  _GLIBCXX_UNITS_SUFFIX(deca, "das")
91  _GLIBCXX_UNITS_SUFFIX(hecto, "hs")
92  _GLIBCXX_UNITS_SUFFIX(kilo, "ks")
93  _GLIBCXX_UNITS_SUFFIX(mega, "Ms")
94  _GLIBCXX_UNITS_SUFFIX(giga, "Gs")
95  _GLIBCXX_UNITS_SUFFIX(tera, "Ts")
96  _GLIBCXX_UNITS_SUFFIX(tera, "Ts")
97  _GLIBCXX_UNITS_SUFFIX(peta, "Ps")
98  _GLIBCXX_UNITS_SUFFIX(exa, "Es")
99  _GLIBCXX_UNITS_SUFFIX(ratio<60>, "min")
100  _GLIBCXX_UNITS_SUFFIX(ratio<3600>, "h")
101  _GLIBCXX_UNITS_SUFFIX(ratio<86400>, "d")
102 #undef _GLIBCXX_UNITS_SUFFIX
103  return {};
104  }
105 
106  template<typename _Period, typename _CharT, typename _Out>
107  inline _Out
108  __fmt_units_suffix(_Out __out) noexcept
109  {
110  if (auto __s = __detail::__units_suffix<_Period, _CharT>(); __s.size())
111  return __format::__write(std::move(__out), __s);
112  else if constexpr (_Period::den == 1)
113  return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}]s"),
114  (uintmax_t)_Period::num);
115  else
116  return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}/{}]s"),
117  (uintmax_t)_Period::num,
118  (uintmax_t)_Period::den);
119  }
120 } // namespace __detail
121 /// @endcond
122 
123  /** Write a `chrono::duration` to an ostream.
124  *
125  * @since C++20
126  */
127  template<typename _CharT, typename _Traits,
128  typename _Rep, typename _Period>
129  inline basic_ostream<_CharT, _Traits>&
130  operator<<(std::basic_ostream<_CharT, _Traits>& __os,
131  const duration<_Rep, _Period>& __d)
132  {
133  using _Out = ostreambuf_iterator<_CharT, _Traits>;
134  using period = typename _Period::type;
135  std::basic_ostringstream<_CharT, _Traits> __s;
136  __s.flags(__os.flags());
137  __s.imbue(__os.getloc());
138  __s.precision(__os.precision());
139  // _GLIBCXX_RESOLVE_LIB_DEFECTS
140  // 4118. How should duration formatters format custom rep types?
141  __s << +__d.count();
142  __detail::__fmt_units_suffix<period, _CharT>(_Out(__s));
143  __os << std::move(__s).str();
144  return __os;
145  }
146 
147 /// @cond undocumented
148 namespace __detail
149 {
150  // An unspecified type returned by `chrono::local_time_format`.
151  // This is called `local-time-format-t` in the standard.
152  template<typename _Duration>
153  struct __local_time_fmt
154  {
155  local_time<_Duration> _M_time;
156  const string* _M_abbrev;
157  const seconds* _M_offset_sec;
158  };
159 
160  // _GLIBCXX_RESOLVE_LIB_DEFECTS
161  // 4124. Cannot format zoned_time with resolution coarser than seconds
162  template<typename _Duration>
163  using __local_time_fmt_for
164  = __local_time_fmt<common_type_t<_Duration, seconds>>;
165 }
166 /// @endcond
167 
168  /** Return an object that asssociates timezone info with a local time.
169  *
170  * A `chrono::local_time` object has no timezone associated with it. This
171  * function creates an object that allows formatting a `local_time` as
172  * though it refers to a timezone with the given abbreviated name and
173  * offset from UTC.
174  *
175  * @since C++20
176  */
177  template<typename _Duration>
178  inline __detail::__local_time_fmt<_Duration>
179  local_time_format(local_time<_Duration> __time,
180  const string* __abbrev = nullptr,
181  const seconds* __offset_sec = nullptr)
182  { return {__time, __abbrev, __offset_sec}; }
183 
184  /// @}
185 } // namespace chrono
186 
187 /// @cond undocumented
188 namespace __format
189 {
190  [[noreturn,__gnu__::__always_inline__]]
191  inline void
192  __no_timezone_available()
193  { __throw_format_error("format error: no timezone available for %Z or %z"); }
194 
195  [[noreturn,__gnu__::__always_inline__]]
196  inline void
197  __not_valid_for_duration()
198  { __throw_format_error("format error: chrono-format-spec not valid for "
199  "chrono::duration"); }
200 
201  [[noreturn,__gnu__::__always_inline__]]
202  inline void
203  __invalid_chrono_spec()
204  { __throw_format_error("format error: chrono-format-spec not valid for "
205  "argument type"); }
206 
207  template<typename _CharT>
208  struct _ChronoSpec : _Spec<_CharT>
209  {
210  basic_string_view<_CharT> _M_chrono_specs;
211 
212  // Use one of the reserved bits in __format::_Spec<C>.
213  // This indicates that a locale-dependent conversion specifier such as
214  // %a is used in the chrono-specs. This is not the same as the
215  // _Spec<C>::_M_localized member which indicates that "L" was present
216  // in the format-spec, e.g. "{:L%a}" is localized and locale-specific,
217  // but "{:L}" is only localized and "{:%a}" is only locale-specific.
218  constexpr bool
219  _M_locale_specific() const noexcept
220  { return this->_M_reserved; }
221 
222  constexpr void
223  _M_locale_specific(bool __b) noexcept
224  { this->_M_reserved = __b; }
225  };
226 
227  // Represents the information provided by a chrono type.
228  // e.g. month_weekday has month and weekday but no year or time of day,
229  // hh_mm_ss has time of day but no date, sys_time is time_point+timezone.
230  enum _ChronoParts {
231  _Year = 1, _Month = 2, _Day = 4, _Weekday = 8, _TimeOfDay = 16,
232  _TimeZone = 32,
233  _Date = _Year | _Month | _Day | _Weekday,
234  _DateTime = _Date | _TimeOfDay,
235  _ZonedDateTime = _DateTime | _TimeZone,
236  _Duration = 128 // special case
237  };
238 
239  constexpr _ChronoParts
240  operator|(_ChronoParts __x, _ChronoParts __y) noexcept
241  { return static_cast<_ChronoParts>((int)__x | (int)__y); }
242 
243  constexpr _ChronoParts&
244  operator|=(_ChronoParts& __x, _ChronoParts __y) noexcept
245  { return __x = __x | __y; }
246 
247  // TODO rename this to chrono::__formatter? or chrono::__detail::__formatter?
248  template<typename _CharT>
249  struct __formatter_chrono
250  {
251  using __string_view = basic_string_view<_CharT>;
252  using __string = basic_string<_CharT>;
253 
254  template<typename _ParseContext>
255  constexpr typename _ParseContext::iterator
256  _M_parse(_ParseContext& __pc, _ChronoParts __parts)
257  {
258  auto __first = __pc.begin();
259  auto __last = __pc.end();
260 
261  _ChronoSpec<_CharT> __spec{};
262 
263  auto __finalize = [this, &__spec] {
264  _M_spec = __spec;
265  };
266 
267  auto __finished = [&] {
268  if (__first == __last || *__first == '}')
269  {
270  __finalize();
271  return true;
272  }
273  return false;
274  };
275 
276  if (__finished())
277  return __first;
278 
279  __first = __spec._M_parse_fill_and_align(__first, __last);
280  if (__finished())
281  return __first;
282 
283  __first = __spec._M_parse_width(__first, __last, __pc);
284  if (__finished())
285  return __first;
286 
287  if (__parts & _ChronoParts::_Duration)
288  {
289  __first = __spec._M_parse_precision(__first, __last, __pc);
290  if (__finished())
291  return __first;
292  }
293 
294  __first = __spec._M_parse_locale(__first, __last);
295  if (__finished())
296  return __first;
297 
298  // Everything up to the end of the string or the first '}' is a
299  // chrono-specs string. Check it is valid.
300  {
301  __string_view __str(__first, __last - __first);
302  auto __end = __str.find('}');
303  if (__end != __str.npos)
304  {
305  __str.remove_suffix(__str.length() - __end);
306  __last = __first + __end;
307  }
308  if (__str.find('{') != __str.npos)
309  __throw_format_error("chrono format error: '{' in chrono-specs");
310  }
311 
312  // Parse chrono-specs in [first,last), checking each conversion-spec
313  // against __parts (so fail for %Y if no year in parts).
314  // Save range in __spec._M_chrono_specs.
315 
316  const auto __chrono_specs = __first++; // Skip leading '%'
317  if (*__chrono_specs != '%')
318  __throw_format_error("chrono format error: no '%' at start of "
319  "chrono-specs");
320 
321  _CharT __mod{};
322  bool __conv = true;
323  int __needed = 0;
324  bool __locale_specific = false;
325 
326  while (__first != __last)
327  {
328  enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
329  _Mods __allowed_mods = _Mod_none;
330 
331  _CharT __c = *__first++;
332  switch (__c)
333  {
334  case 'a':
335  case 'A':
336  __needed = _Weekday;
337  __locale_specific = true;
338  break;
339  case 'b':
340  case 'h':
341  case 'B':
342  __needed = _Month;
343  __locale_specific = true;
344  break;
345  case 'c':
346  __needed = _DateTime;
347  __allowed_mods = _Mod_E;
348  __locale_specific = true;
349  break;
350  case 'C':
351  __needed = _Year;
352  __allowed_mods = _Mod_E;
353  break;
354  case 'd':
355  case 'e':
356  __needed = _Day;
357  __allowed_mods = _Mod_O;
358  break;
359  case 'D':
360  case 'F':
361  __needed = _Date;
362  break;
363  case 'g':
364  case 'G':
365  __needed = _Date;
366  break;
367  case 'H':
368  case 'I':
369  __needed = _TimeOfDay;
370  __allowed_mods = _Mod_O;
371  break;
372  case 'j':
373  if (!(__parts & _Duration))
374  __needed = _Date;
375  break;
376  case 'm':
377  __needed = _Month;
378  __allowed_mods = _Mod_O;
379  break;
380  case 'M':
381  __needed = _TimeOfDay;
382  __allowed_mods = _Mod_O;
383  break;
384  case 'p':
385  case 'r':
386  __locale_specific = true;
387  [[fallthrough]];
388  case 'R':
389  case 'T':
390  __needed = _TimeOfDay;
391  break;
392  case 'q':
393  case 'Q':
394  __needed = _Duration;
395  break;
396  case 'S':
397  __needed = _TimeOfDay;
398  __allowed_mods = _Mod_O;
399  break;
400  case 'u':
401  case 'w':
402  __needed = _Weekday;
403  __allowed_mods = _Mod_O;
404  break;
405  case 'U':
406  case 'V':
407  case 'W':
408  __needed = _Date;
409  __allowed_mods = _Mod_O;
410  break;
411  case 'x':
412  __needed = _Date;
413  __locale_specific = true;
414  __allowed_mods = _Mod_E;
415  break;
416  case 'X':
417  __needed = _TimeOfDay;
418  __locale_specific = true;
419  __allowed_mods = _Mod_E;
420  break;
421  case 'y':
422  __needed = _Year;
423  __allowed_mods = _Mod_E_O;
424  break;
425  case 'Y':
426  __needed = _Year;
427  __allowed_mods = _Mod_E;
428  break;
429  case 'z':
430  __needed = _TimeZone;
431  __allowed_mods = _Mod_E_O;
432  break;
433  case 'Z':
434  __needed = _TimeZone;
435  break;
436  case 'n':
437  case 't':
438  case '%':
439  break;
440  case 'O':
441  case 'E':
442  if (__mod) [[unlikely]]
443  {
444  __allowed_mods = _Mod_none;
445  break;
446  }
447  __mod = __c;
448  continue;
449  default:
450  __throw_format_error("chrono format error: invalid "
451  " specifier in chrono-specs");
452  }
453 
454  if ((__mod == 'E' && !(__allowed_mods & _Mod_E))
455  || (__mod == 'O' && !(__allowed_mods & _Mod_O)))
456  __throw_format_error("chrono format error: invalid "
457  " modifier in chrono-specs");
458  if (__mod && __c != 'z')
459  __locale_specific = true;
460  __mod = _CharT();
461 
462  if ((__parts & __needed) != __needed)
463  __throw_format_error("chrono format error: format argument "
464  "does not contain the information "
465  "required by the chrono-specs");
466 
467  // Scan for next '%', ignoring literal-chars before it.
468  size_t __pos = __string_view(__first, __last - __first).find('%');
469  if (__pos == 0)
470  ++__first;
471  else
472  {
473  if (__pos == __string_view::npos)
474  {
475  __first = __last;
476  __conv = false;
477  }
478  else
479  __first += __pos + 1;
480  }
481  }
482 
483  // Check for a '%' conversion-spec without a type.
484  if (__conv || __mod != _CharT())
485  __throw_format_error("chrono format error: unescaped '%' in "
486  "chrono-specs");
487 
488  _M_spec = __spec;
489  _M_spec._M_chrono_specs
490  = __string_view(__chrono_specs, __first - __chrono_specs);
491  _M_spec._M_locale_specific(__locale_specific);
492 
493  return __first;
494  }
495 
496  // TODO this function template is instantiated for every different _Tp.
497  // Consider creating a polymorphic interface for calendar types so
498  // that we instantiate fewer different specializations. Similar to
499  // _Sink_iter for std::format. Replace each _S_year, _S_day etc. with
500  // member functions of that type.
501  template<typename _Tp, typename _FormatContext>
502  typename _FormatContext::iterator
503  _M_format(const _Tp& __t, _FormatContext& __fc,
504  bool __is_neg = false) const
505  {
506  auto __first = _M_spec._M_chrono_specs.begin();
507  const auto __last = _M_spec._M_chrono_specs.end();
508  if (__first == __last)
509  return _M_format_to_ostream(__t, __fc, __is_neg);
510 
511 #if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
512  // _GLIBCXX_RESOLVE_LIB_DEFECTS
513  // 3565. Handling of encodings in localized formatting
514  // of chrono types is underspecified
515  if constexpr (is_same_v<_CharT, char>)
516  if constexpr (__unicode::__literal_encoding_is_utf8())
517  if (_M_spec._M_localized && _M_spec._M_locale_specific())
518  {
519  extern locale __with_encoding_conversion(const locale&);
520 
521  // Allocate and cache the necessary state to convert strings
522  // in the locale's encoding to UTF-8.
523  locale __loc = __fc.locale();
524  if (__loc != locale::classic())
525  __fc._M_loc = __with_encoding_conversion(__loc);
526  }
527 #endif
528 
529  _Sink_iter<_CharT> __out;
530  __format::_Str_sink<_CharT> __sink;
531  bool __write_direct = false;
532  if constexpr (is_same_v<typename _FormatContext::iterator,
533  _Sink_iter<_CharT>>)
534  {
535  if (_M_spec._M_width_kind == __format::_WP_none)
536  {
537  __out = __fc.out();
538  __write_direct = true;
539  }
540  else
541  __out = __sink.out();
542  }
543  else
544  __out = __sink.out();
545 
546  // formatter<duration> passes the correct value of __is_neg
547  // for durations but for hh_mm_ss we decide it here.
548  if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
549  __is_neg = __t.is_negative();
550 
551  auto __print_sign = [&__is_neg, &__out] {
552  if constexpr (chrono::__is_duration_v<_Tp>
553  || __is_specialization_of<_Tp, chrono::hh_mm_ss>)
554  if (__is_neg)
555  {
556  *__out++ = _S_plus_minus[1];
557  __is_neg = false;
558  }
559  return std::move(__out);
560  };
561 
562  // Characters to output for "%n", "%t" and "%%" specifiers.
563  constexpr const _CharT* __literals = _GLIBCXX_WIDEN("\n\t%");
564 
565  ++__first; // Skip leading '%' at start of chrono-specs.
566 
567  _CharT __mod{};
568  do
569  {
570  _CharT __c = *__first++;
571  switch (__c)
572  {
573  case 'a':
574  case 'A':
575  __out = _M_a_A(__t, std::move(__out), __fc, __c == 'A');
576  break;
577  case 'b':
578  case 'h':
579  case 'B':
580  __out = _M_b_B(__t, std::move(__out), __fc, __c == 'B');
581  break;
582  case 'c':
583  case 'r':
584  case 'x':
585  case 'X':
586  __out = _M_c_r_x_X(__t, std::move(__out), __fc, __c, __mod);
587  break;
588  case 'C':
589  case 'y':
590  case 'Y':
591  __out = _M_C_y_Y(__t, std::move(__out), __fc, __c, __mod);
592  break;
593  case 'd':
594  case 'e':
595  __out = _M_d_e(__t, std::move(__out), __fc, __c, __mod == 'O');
596  break;
597  case 'D':
598  __out = _M_D(__t, std::move(__out), __fc);
599  break;
600  case 'F':
601  __out = _M_F(__t, std::move(__out), __fc);
602  break;
603  case 'g':
604  case 'G':
605  __out = _M_g_G(__t, std::move(__out), __fc, __c == 'G');
606  break;
607  case 'H':
608  case 'I':
609  __out = _M_H_I(__t, __print_sign(), __fc, __c, __mod == 'O');
610  break;
611  case 'j':
612  __out = _M_j(__t, __print_sign(), __fc);
613  break;
614  case 'm':
615  __out = _M_m(__t, std::move(__out), __fc, __mod == 'O');
616  break;
617  case 'M':
618  __out = _M_M(__t, __print_sign(), __fc, __mod == 'O');
619  break;
620  case 'p':
621  __out = _M_p(__t, std::move(__out), __fc);
622  break;
623  case 'q':
624  __out = _M_q(__t, std::move(__out), __fc);
625  break;
626  case 'Q':
627  // %Q The duration's numeric value.
628  if constexpr (chrono::__is_duration_v<_Tp>)
629  // _GLIBCXX_RESOLVE_LIB_DEFECTS
630  // 4118. How should duration formatters format custom rep?
631  __out = std::format_to(__print_sign(), _S_empty_spec,
632  +__t.count());
633  else
634  __throw_format_error("chrono format error: argument is "
635  "not a duration");
636  break;
637  case 'R':
638  case 'T':
639  __out = _M_R_T(__t, __print_sign(), __fc, __c == 'T');
640  break;
641  case 'S':
642  __out = _M_S(__t, __print_sign(), __fc, __mod == 'O');
643  break;
644  case 'u':
645  case 'w':
646  __out = _M_u_w(__t, std::move(__out), __fc, __c, __mod == 'O');
647  break;
648  case 'U':
649  case 'V':
650  case 'W':
651  __out = _M_U_V_W(__t, std::move(__out), __fc, __c,
652  __mod == 'O');
653  break;
654  case 'z':
655  __out = _M_z(__t, std::move(__out), __fc, (bool)__mod);
656  break;
657  case 'Z':
658  __out = _M_Z(__t, std::move(__out), __fc);
659  break;
660  case 'n':
661  *__out++ = __literals[0];
662  break;
663  case 't':
664  *__out++ = __literals[1];
665  break;
666  case '%':
667  *__out++ = __literals[2];
668  break;
669  case 'O':
670  case 'E':
671  __mod = __c;
672  continue;
673  case '}':
674  __first = __last;
675  break;
676  }
677  __mod = _CharT();
678  // Scan for next '%' and write out everything before it.
679  __string_view __str(__first, __last - __first);
680  size_t __pos = __str.find('%');
681  if (__pos == 0)
682  ++__first;
683  else
684  {
685  if (__pos == __str.npos)
686  __first = __last;
687  else
688  {
689  __str.remove_suffix(__str.length() - __pos);
690  __first += __pos + 1;
691  }
692  __out = __format::__write(std::move(__out), __str);
693  }
694  }
695  while (__first != __last);
696 
697  if constexpr (is_same_v<typename _FormatContext::iterator,
698  _Sink_iter<_CharT>>)
699  if (__write_direct)
700  return __out;
701 
702  auto __span = __sink.view();
703  __string_view __str(__span.data(), __span.size());
704  size_t __width;
705  if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
706  __width = __unicode::__field_width(__str);
707  else
708  __width = __str.size();
709  return __format::__write_padded_as_spec(__str, __width,
710  __fc, _M_spec);
711  }
712 
713  _ChronoSpec<_CharT> _M_spec;
714 
715  private:
716  // Return the formatting locale.
717  template<typename _FormatContext>
718  std::locale
719  _M_locale(_FormatContext& __fc) const
720  {
721  if (!_M_spec._M_localized)
722  return std::locale::classic();
723  else
724  return __fc.locale();
725  }
726 
727  // Format for empty chrono-specs, e.g. "{}" (C++20 [time.format] p6).
728  // TODO: consider moving body of every operator<< into this function
729  // and use std::format("{}", t) to implement those operators. That
730  // would avoid std::format("{}", t) calling operator<< which calls
731  // std::format again.
732  template<typename _Tp, typename _FormatContext>
733  typename _FormatContext::iterator
734  _M_format_to_ostream(const _Tp& __t, _FormatContext& __fc,
735  bool __is_neg) const
736  {
737  using ::std::chrono::__detail::__utc_leap_second;
738  using ::std::chrono::__detail::__local_time_fmt;
739 
740  basic_ostringstream<_CharT> __os;
741  __os.imbue(_M_locale(__fc));
742 
743  if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
744  {
745  // Format as "{:L%F %T}"
746  auto __days = chrono::floor<chrono::days>(__t._M_time);
747  __os << chrono::year_month_day(__days) << ' '
748  << chrono::hh_mm_ss(__t._M_time - __days);
749 
750  // For __local_time_fmt the __is_neg flags says whether to
751  // append " %Z" to the result.
752  if (__is_neg)
753  {
754  if (!__t._M_abbrev) [[unlikely]]
755  __format::__no_timezone_available();
756  else if constexpr (is_same_v<_CharT, char>)
757  __os << ' ' << *__t._M_abbrev;
758  else
759  {
760  __os << L' ';
761  for (char __c : *__t._M_abbrev)
762  __os << __c;
763  }
764  }
765  }
766  else
767  {
768  if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
769  __os << __t._M_date << ' ' << __t._M_time;
770  else if constexpr (chrono::__is_time_point_v<_Tp>)
771  {
772  // Need to be careful here because not all specializations
773  // of chrono::sys_time can be written to an ostream.
774  // For the specializations of time_point that can be
775  // formatted with an empty chrono-specs, either it's a
776  // sys_time with period greater or equal to days:
777  if constexpr (is_convertible_v<_Tp, chrono::sys_days>)
778  __os << _S_date(__t);
779  // Or a local_time with period greater or equal to days:
780  else if constexpr (is_convertible_v<_Tp, chrono::local_days>)
781  __os << _S_date(__t);
782  else // Or it's formatted as "{:L%F %T}":
783  {
784  auto __days = chrono::floor<chrono::days>(__t);
785  __os << chrono::year_month_day(__days) << ' '
786  << chrono::hh_mm_ss(__t - __days);
787  }
788  }
789  else
790  {
791  if constexpr (chrono::__is_duration_v<_Tp>)
792  if (__is_neg) [[unlikely]]
793  __os << _S_plus_minus[1];
794  __os << __t;
795  }
796  }
797 
798  auto __str = std::move(__os).str();
799  return __format::__write_padded_as_spec(__str, __str.size(),
800  __fc, _M_spec);
801  }
802 
803  static constexpr const _CharT* _S_chars
804  = _GLIBCXX_WIDEN("0123456789+-:/ {}");
805  static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
806  static constexpr _CharT _S_colon = _S_chars[12];
807  static constexpr _CharT _S_slash = _S_chars[13];
808  static constexpr _CharT _S_space = _S_chars[14];
809  static constexpr const _CharT* _S_empty_spec = _S_chars + 15;
810 
811  template<typename _OutIter>
812  _OutIter
813  _M_write(_OutIter __out, const locale& __loc, __string_view __s) const
814  {
815 #if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
816  __sso_string __buf;
817  // _GLIBCXX_RESOLVE_LIB_DEFECTS
818  // 3565. Handling of encodings in localized formatting
819  // of chrono types is underspecified
820  if constexpr (is_same_v<_CharT, char>)
821  if constexpr (__unicode::__literal_encoding_is_utf8())
822  if (_M_spec._M_localized && _M_spec._M_locale_specific()
823  && __loc != locale::classic())
824  {
825  extern string_view
826  __locale_encoding_to_utf8(const locale&, string_view, void*);
827 
828  __s = __locale_encoding_to_utf8(__loc, __s, &__buf);
829  }
830 #endif
831  return __format::__write(std::move(__out), __s);
832  }
833 
834  template<typename _Tp, typename _FormatContext>
835  typename _FormatContext::iterator
836  _M_a_A(const _Tp& __t, typename _FormatContext::iterator __out,
837  _FormatContext& __ctx, bool __full) const
838  {
839  // %a Locale's abbreviated weekday name.
840  // %A Locale's full weekday name.
841  chrono::weekday __wd = _S_weekday(__t);
842  if (!__wd.ok())
843  __throw_format_error("format error: invalid weekday");
844 
845  locale __loc = _M_locale(__ctx);
846  const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
847  const _CharT* __days[7];
848  if (__full)
849  __tp._M_days(__days);
850  else
851  __tp._M_days_abbreviated(__days);
852  __string_view __str(__days[__wd.c_encoding()]);
853  return _M_write(std::move(__out), __loc, __str);
854  }
855 
856  template<typename _Tp, typename _FormatContext>
857  typename _FormatContext::iterator
858  _M_b_B(const _Tp& __t, typename _FormatContext::iterator __out,
859  _FormatContext& __ctx, bool __full) const
860  {
861  // %b Locale's abbreviated month name.
862  // %B Locale's full month name.
863  chrono::month __m = _S_month(__t);
864  if (!__m.ok())
865  __throw_format_error("format error: invalid month");
866  locale __loc = _M_locale(__ctx);
867  const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
868  const _CharT* __months[12];
869  if (__full)
870  __tp._M_months(__months);
871  else
872  __tp._M_months_abbreviated(__months);
873  __string_view __str(__months[(unsigned)__m - 1]);
874  return _M_write(std::move(__out), __loc, __str);
875  }
876 
877  template<typename _Tp, typename _FormatContext>
878  typename _FormatContext::iterator
879  _M_c_r_x_X(const _Tp& __t, typename _FormatContext::iterator __out,
880  _FormatContext& __ctx, _CharT __conv, _CharT __mod) const
881  {
882  // %c Locale's date and time representation.
883  // %Ec Locale's alternate date and time representation.
884  // %r Locale's 12-hour clock time.
885  // %x Locale's date rep
886  // %Ex Locale's alternative date representation.
887  // %X Locale's time rep
888  // %EX Locale's alternative time representation.
889 
890  using namespace chrono;
891  using ::std::chrono::__detail::__utc_leap_second;
892  using ::std::chrono::__detail::__local_time_fmt;
893 
894  struct tm __tm{};
895 
896  // Some locales use %Z in their %c format but we don't want strftime
897  // to use the system's local time zone (from /etc/localtime or $TZ)
898  // as the output for %Z. Setting tm_isdst to -1 says there is no
899  // time zone info available for the time in __tm.
900  __tm.tm_isdst = -1;
901 
902 #ifdef _GLIBCXX_USE_STRUCT_TM_TM_ZONE
903  // POSIX.1-2024 adds tm.tm_zone which will be used for %Z.
904  // BSD has had tm_zone since 1987 but as char* so cast away const.
905  if constexpr (__is_time_point_v<_Tp>)
906  {
907  // One of sys_time, utc_time, or local_time.
908  if constexpr (!is_same_v<typename _Tp::clock, local_t>)
909  __tm.tm_zone = const_cast<char*>("UTC");
910  }
911  else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
912  {
913  // local-time-format-t is used to provide time zone info for
914  // one of zoned_time, tai_time, gps_time, or local_time.
915  if (__t._M_abbrev)
916  __tm.tm_zone = const_cast<char*>(__t._M_abbrev->c_str());
917  }
918  else
919  __tm.tm_zone = const_cast<char*>("UTC");
920 #endif
921 
922  if (__conv == 'c' || __conv == 'x')
923  {
924  auto __d = _S_days(__t); // Either sys_days or local_days.
925  using _TDays = decltype(__d);
926  const year_month_day __ymd(__d);
927  const auto __y = __ymd.year();
928 
929  __tm.tm_year = (int)__y - 1900;
930  __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
931  __tm.tm_mon = (unsigned)__ymd.month() - 1;
932  __tm.tm_mday = (unsigned)__ymd.day();
933  __tm.tm_wday = weekday(__d).c_encoding();
934  }
935 
936  if (__conv != 'x')
937  {
938  const auto __hms = _S_hms(__t);
939  __tm.tm_hour = __hms.hours().count();
940  __tm.tm_min = __hms.minutes().count();
941  __tm.tm_sec = __hms.seconds().count();
942  }
943 
944  return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
945  __conv, __mod);
946  }
947 
948  template<typename _Tp, typename _FormatContext>
949  typename _FormatContext::iterator
950  _M_C_y_Y(const _Tp& __t, typename _FormatContext::iterator __out,
951  _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0) const
952  {
953  // %C Year divided by 100 using floored division.
954  // %EC Locale's alternative preresentation of the century (era name).
955  // %y Last two decimal digits of the year.
956  // %Oy Locale's alternative representation.
957  // %Ey Locale's alternative representation of offset from %EC.
958  // %Y Year as a decimal number.
959  // %EY Locale's alternative full year representation.
960 
961  chrono::year __y = _S_year(__t);
962 
963  if (__mod && _M_spec._M_localized) [[unlikely]]
964  if (auto __loc = __ctx.locale(); __loc != locale::classic())
965  {
966  struct tm __tm{};
967  __tm.tm_year = (int)__y - 1900;
968  return _M_locale_fmt(std::move(__out), __loc, __tm,
969  __conv, __mod);
970  }
971 
972  basic_string<_CharT> __s;
973  int __yi = (int)__y;
974  const bool __is_neg = __yi < 0;
975  __yi = __builtin_abs(__yi);
976 
977  if (__conv == 'Y' || __conv == 'C')
978  {
979  int __ci = __yi / 100;
980  if (__is_neg) [[unlikely]]
981  {
982  __s.assign(1, _S_plus_minus[1]);
983  // For floored division -123//100 is -2 and -100//100 is -1
984  if (__conv == 'C' && (__ci * 100) != __yi)
985  ++__ci;
986  }
987  if (__ci >= 100) [[unlikely]]
988  {
989  __s += std::format(_S_empty_spec, __ci / 100);
990  __ci %= 100;
991  }
992  __s += _S_two_digits(__ci);
993  }
994 
995  if (__conv == 'Y' || __conv == 'y')
996  __s += _S_two_digits(__yi % 100);
997 
998  return __format::__write(std::move(__out), __string_view(__s));
999  }
1000 
1001  template<typename _Tp, typename _FormatContext>
1002  typename _FormatContext::iterator
1003  _M_D(const _Tp& __t, typename _FormatContext::iterator __out,
1004  _FormatContext&) const
1005  {
1006  auto __ymd = _S_date(__t);
1007  basic_string<_CharT> __s;
1008 #if ! _GLIBCXX_USE_CXX11_ABI
1009  __s.reserve(8);
1010 #endif
1011  __s = _S_two_digits((unsigned)__ymd.month());
1012  __s += _S_slash;
1013  __s += _S_two_digits((unsigned)__ymd.day());
1014  __s += _S_slash;
1015  __s += _S_two_digits(__builtin_abs((int)__ymd.year()) % 100);
1016  return __format::__write(std::move(__out), __string_view(__s));
1017  }
1018 
1019  template<typename _Tp, typename _FormatContext>
1020  typename _FormatContext::iterator
1021  _M_d_e(const _Tp& __t, typename _FormatContext::iterator __out,
1022  _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
1023  {
1024  // %d The day of month as a decimal number.
1025  // %Od Locale's alternative representation.
1026  // %e Day of month as decimal number, padded with space.
1027  // %Oe Locale's alternative digits.
1028 
1029  chrono::day __d = _S_day(__t);
1030  unsigned __i = (unsigned)__d;
1031 
1032  if (__mod && _M_spec._M_localized) [[unlikely]]
1033  if (auto __loc = __ctx.locale(); __loc != locale::classic())
1034  {
1035  struct tm __tm{};
1036  __tm.tm_mday = __i;
1037  return _M_locale_fmt(std::move(__out), __loc, __tm,
1038  (char)__conv, 'O');
1039  }
1040 
1041  auto __sv = _S_two_digits(__i);
1042  _CharT __buf[2];
1043  if (__conv == _CharT('e') && __i < 10)
1044  {
1045  __buf[0] = _S_space;
1046  __buf[1] = __sv[1];
1047  __sv = {__buf, 2};
1048  }
1049  return __format::__write(std::move(__out), __sv);
1050  }
1051 
1052  template<typename _Tp, typename _FormatContext>
1053  typename _FormatContext::iterator
1054  _M_F(const _Tp& __t, typename _FormatContext::iterator __out,
1055  _FormatContext&) const
1056  {
1057  auto __ymd = _S_date(__t);
1058  auto __s = std::format(_GLIBCXX_WIDEN("{:04d}- - "),
1059  (int)__ymd.year());
1060  auto __sv = _S_two_digits((unsigned)__ymd.month());
1061  __s[__s.size() - 5] = __sv[0];
1062  __s[__s.size() - 4] = __sv[1];
1063  __sv = _S_two_digits((unsigned)__ymd.day());
1064  __s[__s.size() - 2] = __sv[0];
1065  __s[__s.size() - 1] = __sv[1];
1066  __sv = __s;
1067  return __format::__write(std::move(__out), __sv);
1068  }
1069 
1070  template<typename _Tp, typename _FormatContext>
1071  typename _FormatContext::iterator
1072  _M_g_G(const _Tp& __t, typename _FormatContext::iterator __out,
1073  _FormatContext& __ctx, bool __full) const
1074  {
1075  // %g last two decimal digits of the ISO week-based year.
1076  // %G ISO week-based year.
1077  using namespace chrono;
1078  auto __d = _S_days(__t);
1079  // Move to nearest Thursday:
1080  __d -= (weekday(__d) - Monday) - days(3);
1081  // ISO week-based year is the year that contains that Thursday:
1082  year __y = year_month_day(__d).year();
1083  return _M_C_y_Y(__y, std::move(__out), __ctx, "yY"[__full]);
1084  }
1085 
1086  template<typename _Tp, typename _FormatContext>
1087  typename _FormatContext::iterator
1088  _M_H_I(const _Tp& __t, typename _FormatContext::iterator __out,
1089  _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
1090  {
1091  // %H The hour (24-hour clock) as a decimal number.
1092  // %OH Locale's alternative representation.
1093  // %I The hour (12-hour clock) as a decimal number.
1094  // %OI Locale's alternative representation.
1095 
1096  const auto __hms = _S_hms(__t);
1097  int __i = __hms.hours().count();
1098 
1099  if (__mod && _M_spec._M_localized) [[unlikely]]
1100  if (auto __loc = __ctx.locale(); __loc != locale::classic())
1101  {
1102  struct tm __tm{};
1103  __tm.tm_hour = __i;
1104  return _M_locale_fmt(std::move(__out), __loc, __tm,
1105  (char)__conv, 'O');
1106  }
1107 
1108  if (__conv == _CharT('I'))
1109  {
1110  if (__i == 0)
1111  __i = 12;
1112  else if (__i > 12)
1113  __i -= 12;
1114  }
1115  return __format::__write(std::move(__out), _S_two_digits(__i));
1116  }
1117 
1118  template<typename _Tp, typename _FormatContext>
1119  typename _FormatContext::iterator
1120  _M_j(const _Tp& __t, typename _FormatContext::iterator __out,
1121  _FormatContext&) const
1122  {
1123  if constexpr (chrono::__is_duration_v<_Tp>)
1124  {
1125  // Decimal number of days, without padding.
1126  unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
1127  return std::format_to(std::move(__out), _S_empty_spec, __d);
1128  }
1129  else
1130  {
1131  // Day of the year as a decimal number, padding with zero.
1132  using namespace chrono;
1133  auto __day = _S_days(__t);
1134  auto __ymd = _S_date(__t);
1135  days __d;
1136  // See "Calculating Ordinal Dates" at
1137  // https://github.com/HowardHinnant/date/wiki/Examples-and-Recipes
1138  if constexpr (is_same_v<typename decltype(__day)::clock, local_t>)
1139  __d = __day - local_days(__ymd.year()/January/0);
1140  else
1141  __d = __day - sys_days(__ymd.year()/January/0);
1142  return std::format_to(std::move(__out), _GLIBCXX_WIDEN("{:03d}"),
1143  __d.count());
1144  }
1145  }
1146 
1147  template<typename _Tp, typename _FormatContext>
1148  typename _FormatContext::iterator
1149  _M_m(const _Tp& __t, typename _FormatContext::iterator __out,
1150  _FormatContext& __ctx, bool __mod) const
1151  {
1152  // %m month as a decimal number.
1153  // %Om Locale's alternative representation.
1154 
1155  auto __m = _S_month(__t);
1156  auto __i = (unsigned)__m;
1157 
1158  if (__mod && _M_spec._M_localized) [[unlikely]] // %Om
1159  if (auto __loc = __ctx.locale(); __loc != locale::classic())
1160  {
1161  struct tm __tm{};
1162  __tm.tm_mon = __i - 1;
1163  return _M_locale_fmt(std::move(__out), __loc, __tm,
1164  'm', 'O');
1165  }
1166 
1167  return __format::__write(std::move(__out), _S_two_digits(__i));
1168  }
1169 
1170  template<typename _Tp, typename _FormatContext>
1171  typename _FormatContext::iterator
1172  _M_M(const _Tp& __t, typename _FormatContext::iterator __out,
1173  _FormatContext& __ctx, bool __mod) const
1174  {
1175  // %M The minute as a decimal number.
1176  // %OM Locale's alternative representation.
1177 
1178  auto __m = _S_hms(__t).minutes();
1179  auto __i = __m.count();
1180 
1181  if (__mod && _M_spec._M_localized) [[unlikely]] // %OM
1182  if (auto __loc = __ctx.locale(); __loc != locale::classic())
1183  {
1184  struct tm __tm{};
1185  __tm.tm_min = __i;
1186  return _M_locale_fmt(std::move(__out), __loc, __tm,
1187  'M', 'O');
1188  }
1189 
1190  return __format::__write(std::move(__out), _S_two_digits(__i));
1191  }
1192 
1193  template<typename _Tp, typename _FormatContext>
1194  typename _FormatContext::iterator
1195  _M_p(const _Tp& __t, typename _FormatContext::iterator __out,
1196  _FormatContext& __ctx) const
1197  {
1198  // %p The locale's equivalent of the AM/PM designations.
1199  auto __hms = _S_hms(__t);
1200  locale __loc = _M_locale(__ctx);
1201  const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1202  const _CharT* __ampm[2];
1203  __tp._M_am_pm(__ampm);
1204  return _M_write(std::move(__out), __loc,
1205  __ampm[__hms.hours().count() >= 12]);
1206  }
1207 
1208  template<typename _Tp, typename _FormatContext>
1209  typename _FormatContext::iterator
1210  _M_q(const _Tp&, typename _FormatContext::iterator __out,
1211  _FormatContext&) const
1212  {
1213  // %q The duration's unit suffix
1214  if constexpr (!chrono::__is_duration_v<_Tp>)
1215  __throw_format_error("format error: argument is not a duration");
1216  else
1217  {
1218  namespace __d = chrono::__detail;
1219  using period = typename _Tp::period;
1220  return __d::__fmt_units_suffix<period, _CharT>(std::move(__out));
1221  }
1222  }
1223 
1224  // %Q handled in _M_format
1225 
1226  template<typename _Tp, typename _FormatContext>
1227  typename _FormatContext::iterator
1228  _M_R_T(const _Tp& __t, typename _FormatContext::iterator __out,
1229  _FormatContext& __ctx, bool __secs) const
1230  {
1231  // %R Equivalent to %H:%M
1232  // %T Equivalent to %H:%M:%S
1233  auto __hms = _S_hms(__t);
1234 
1235  auto __s = std::format(_GLIBCXX_WIDEN("{:02d}:00"),
1236  __hms.hours().count());
1237  auto __sv = _S_two_digits(__hms.minutes().count());
1238  __s[__s.size() - 2] = __sv[0];
1239  __s[__s.size() - 1] = __sv[1];
1240  __sv = __s;
1241  __out = __format::__write(std::move(__out), __sv);
1242  if (__secs)
1243  {
1244  *__out++ = _S_colon;
1245  __out = _M_S(__hms, std::move(__out), __ctx);
1246  }
1247  return __out;
1248  }
1249 
1250  template<typename _Tp, typename _FormatContext>
1251  typename _FormatContext::iterator
1252  _M_S(const _Tp& __t, typename _FormatContext::iterator __out,
1253  _FormatContext& __ctx, bool __mod = false) const
1254  {
1255  // %S Seconds as a decimal number.
1256  // %OS The locale's alternative representation.
1257  auto __hms = _S_hms(__t);
1258  auto __s = __hms.seconds();
1259 
1260  if (__mod) [[unlikely]] // %OS
1261  {
1262  if (_M_spec._M_localized)
1263  if (auto __loc = __ctx.locale(); __loc != locale::classic())
1264  {
1265  struct tm __tm{};
1266  __tm.tm_sec = (int)__s.count();
1267  return _M_locale_fmt(std::move(__out), __loc, __tm,
1268  'S', 'O');
1269  }
1270 
1271  // %OS formats don't include subseconds, so just format that:
1272  return __format::__write(std::move(__out),
1273  _S_two_digits(__s.count()));
1274  }
1275 
1276  if constexpr (__hms.fractional_width == 0)
1277  __out = __format::__write(std::move(__out),
1278  _S_two_digits(__s.count()));
1279  else
1280  {
1281  locale __loc = _M_locale(__ctx);
1282  auto __ss = __hms.subseconds();
1283  using rep = typename decltype(__ss)::rep;
1284  if constexpr (is_floating_point_v<rep>)
1285  {
1286  chrono::duration<rep> __fs = __s + __ss;
1287  __out = std::format_to(std::move(__out), __loc,
1288  _GLIBCXX_WIDEN("{:#0{}.{}Lf}"),
1289  __fs.count(),
1290  3 + __hms.fractional_width,
1291  __hms.fractional_width);
1292  }
1293  else
1294  {
1295  const auto& __np
1296  = use_facet<numpunct<_CharT>>(__loc);
1297  __out = __format::__write(std::move(__out),
1298  _S_two_digits(__s.count()));
1299  *__out++ = __np.decimal_point();
1300  if constexpr (is_integral_v<rep>)
1301  __out = std::format_to(std::move(__out),
1302  _GLIBCXX_WIDEN("{:0{}}"),
1303  __ss.count(),
1304  __hms.fractional_width);
1305  else
1306  {
1307  auto __str = std::format(_S_empty_spec, __ss.count());
1308  __out = std::format_to(std::move(__out),
1309  _GLIBCXX_WIDEN("{:0>{}s}"),
1310  __str,
1311  __hms.fractional_width);
1312  }
1313  }
1314  }
1315  return __out;
1316  }
1317 
1318  // %t handled in _M_format
1319 
1320  template<typename _Tp, typename _FormatContext>
1321  typename _FormatContext::iterator
1322  _M_u_w(const _Tp& __t, typename _FormatContext::iterator __out,
1323  _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
1324  {
1325  // %u ISO weekday as a decimal number (1-7), where Monday is 1.
1326  // %Ou Locale's alternative numeric rep.
1327  // %w Weekday as a decimal number (0-6), where Sunday is 0.
1328  // %Ow Locale's alternative numeric rep.
1329 
1330  chrono::weekday __wd = _S_weekday(__t);
1331 
1332  if (__mod && _M_spec._M_localized) [[unlikely]]
1333  if (auto __loc = __ctx.locale(); __loc != locale::classic())
1334  {
1335  struct tm __tm{};
1336  __tm.tm_wday = __wd.c_encoding();
1337  return _M_locale_fmt(std::move(__out), __loc, __tm,
1338  (char)__conv, 'O');
1339  }
1340 
1341  unsigned __wdi = __conv == 'u' ? __wd.iso_encoding()
1342  : __wd.c_encoding();
1343  const _CharT __d = _S_digit(__wdi);
1344  return __format::__write(std::move(__out), __string_view(&__d, 1));
1345  }
1346 
1347  template<typename _Tp, typename _FormatContext>
1348  typename _FormatContext::iterator
1349  _M_U_V_W(const _Tp& __t, typename _FormatContext::iterator __out,
1350  _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
1351  {
1352  // %U Week number of the year as a decimal number, from first Sunday.
1353  // %OU Locale's alternative numeric rep.
1354  // %V ISO week-based week number as a decimal number.
1355  // %OV Locale's alternative numeric rep.
1356  // %W Week number of the year as a decimal number, from first Monday.
1357  // %OW Locale's alternative numeric rep.
1358  using namespace chrono;
1359  auto __d = _S_days(__t);
1360  using _TDays = decltype(__d); // Either sys_days or local_days.
1361 
1362  if (__mod && _M_spec._M_localized) [[unlikely]]
1363  if (auto __loc = __ctx.locale(); __loc != locale::classic())
1364  {
1365  const year_month_day __ymd(__d);
1366  const year __y = __ymd.year();
1367  struct tm __tm{};
1368  __tm.tm_year = (int)__y - 1900;
1369  __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
1370  __tm.tm_wday = weekday(__d).c_encoding();
1371  return _M_locale_fmt(std::move(__out), __loc, __tm,
1372  (char)__conv, 'O');
1373  }
1374 
1375  _TDays __first; // First day of week 1.
1376  if (__conv == 'V') // W01 begins on Monday before first Thursday.
1377  {
1378  // Move to nearest Thursday:
1379  __d -= (weekday(__d) - Monday) - days(3);
1380  // ISO week of __t is number of weeks since January 1 of the
1381  // same year as that nearest Thursday.
1382  __first = _TDays(year_month_day(__d).year()/January/1);
1383  }
1384  else
1385  {
1386  year __y;
1387  if constexpr (requires { __t.year(); })
1388  __y = __t.year();
1389  else
1390  __y = year_month_day(__d).year();
1391  const weekday __weekstart = __conv == 'U' ? Sunday : Monday;
1392  __first = _TDays(__y/January/__weekstart[1]);
1393  }
1394  auto __weeks = chrono::floor<weeks>(__d - __first);
1395  __string_view __sv = _S_two_digits(__weeks.count() + 1);
1396  return __format::__write(std::move(__out), __sv);
1397  }
1398 
1399  template<typename _Tp, typename _FormatContext>
1400  typename _FormatContext::iterator
1401  _M_z(const _Tp& __t, typename _FormatContext::iterator __out,
1402  _FormatContext&, bool __mod = false) const
1403  {
1404  using ::std::chrono::__detail::__utc_leap_second;
1405  using ::std::chrono::__detail::__local_time_fmt;
1406 
1407  auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN("+00:00"), 6)
1408  : __string_view(_GLIBCXX_WIDEN("+0000"), 5);
1409 
1410  if constexpr (chrono::__is_time_point_v<_Tp>)
1411  {
1412  if constexpr (is_same_v<typename _Tp::clock,
1413  chrono::system_clock>)
1414  return __format::__write(std::move(__out), __utc);
1415  }
1416  else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1417  {
1418  if (__t._M_offset_sec)
1419  {
1420  auto __sv = __utc;
1421  basic_string<_CharT> __s;
1422  if (*__t._M_offset_sec != 0s)
1423  {
1424  chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
1425  __s = _S_plus_minus[__hms.is_negative()];
1426  __s += _S_two_digits(__hms.hours().count());
1427  if (__mod)
1428  __s += _S_colon;
1429  __s += _S_two_digits(__hms.minutes().count());
1430  __sv = __s;
1431  }
1432  return __format::__write(std::move(__out), __sv);
1433  }
1434  }
1435  else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1436  return __format::__write(std::move(__out), __utc);
1437 
1438  __no_timezone_available();
1439  }
1440 
1441  template<typename _Tp, typename _FormatContext>
1442  typename _FormatContext::iterator
1443  _M_Z(const _Tp& __t, typename _FormatContext::iterator __out,
1444  _FormatContext& __ctx) const
1445  {
1446  using ::std::chrono::__detail::__utc_leap_second;
1447  using ::std::chrono::__detail::__local_time_fmt;
1448 
1449  __string_view __utc(_GLIBCXX_WIDEN("UTC"), 3);
1450  if constexpr (chrono::__is_time_point_v<_Tp>)
1451  {
1452  if constexpr (is_same_v<typename _Tp::clock,
1453  chrono::system_clock>)
1454  return __format::__write(std::move(__out), __utc);
1455  }
1456  else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1457  {
1458  if (__t._M_abbrev)
1459  {
1460  string_view __sv = *__t._M_abbrev;
1461  if constexpr (is_same_v<_CharT, char>)
1462  return __format::__write(std::move(__out), __sv);
1463  else
1464  {
1465  // TODO use resize_and_overwrite
1466  basic_string<_CharT> __ws(__sv.size(), _CharT());
1467  auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
1468  __ct.widen(__sv.begin(), __sv.end(), __ws.data());
1469  __string_view __wsv = __ws;
1470  return __format::__write(std::move(__out), __wsv);
1471  }
1472  }
1473  }
1474  else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1475  return __format::__write(std::move(__out), __utc);
1476 
1477  __no_timezone_available();
1478  }
1479 
1480  // %% handled in _M_format
1481 
1482  // A single digit character in the range '0'..'9'.
1483  static _CharT
1484  _S_digit(int __n) noexcept
1485  {
1486  // Extra 9s avoid past-the-end read on bad input.
1487  return _GLIBCXX_WIDEN("0123456789999999")[__n & 0xf];
1488  }
1489 
1490  // A string view of two digit characters, "00".."99".
1491  static basic_string_view<_CharT>
1492  _S_two_digits(int __n) noexcept
1493  {
1494  return {
1495  _GLIBCXX_WIDEN("0001020304050607080910111213141516171819"
1496  "2021222324252627282930313233343536373839"
1497  "4041424344454647484950515253545556575859"
1498  "6061626364656667686970717273747576777879"
1499  "8081828384858687888990919293949596979899"
1500  "9999999999999999999999999999999999999999"
1501  "9999999999999999") + 2 * (__n & 0x7f),
1502  2
1503  };
1504  }
1505 
1506  // Accessors for the components of chrono types:
1507 
1508  // Returns a hh_mm_ss.
1509  template<typename _Tp>
1510  static decltype(auto)
1511  _S_hms(const _Tp& __t)
1512  {
1513  using ::std::chrono::__detail::__utc_leap_second;
1514  using ::std::chrono::__detail::__local_time_fmt;
1515 
1516  if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1517  return __t;
1518  else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1519  return __t._M_time;
1520  else if constexpr (chrono::__is_duration_v<_Tp>)
1521  return chrono::hh_mm_ss<_Tp>(__t);
1522  else if constexpr (chrono::__is_time_point_v<_Tp>)
1523  return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
1524  else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1525  return _S_hms(__t._M_time);
1526  else
1527  {
1528  __invalid_chrono_spec();
1529  return chrono::hh_mm_ss<chrono::seconds>();
1530  }
1531  }
1532 
1533  // Returns a sys_days or local_days.
1534  template<typename _Tp>
1535  static auto
1536  _S_days(const _Tp& __t)
1537  {
1538  using namespace chrono;
1539  using ::std::chrono::__detail::__utc_leap_second;
1540  using ::std::chrono::__detail::__local_time_fmt;
1541 
1542  if constexpr (__is_time_point_v<_Tp>)
1543  return chrono::floor<days>(__t);
1544  else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1545  return __t._M_date;
1546  else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1547  return chrono::floor<days>(__t._M_time);
1548  else if constexpr (is_same_v<_Tp, year_month_day>
1549  || is_same_v<_Tp, year_month_day_last>
1550  || is_same_v<_Tp, year_month_weekday>
1551  || is_same_v<_Tp, year_month_weekday_last>)
1552  return sys_days(__t);
1553  else
1554  {
1555  if constexpr (__is_duration_v<_Tp>)
1556  __not_valid_for_duration();
1557  else
1558  __invalid_chrono_spec();
1559  return chrono::sys_days();
1560  }
1561  }
1562 
1563  // Returns a year_month_day.
1564  template<typename _Tp>
1565  static chrono::year_month_day
1566  _S_date(const _Tp& __t)
1567  {
1568  if constexpr (is_same_v<_Tp, chrono::year_month_day>)
1569  return __t;
1570  else
1571  return chrono::year_month_day(_S_days(__t));
1572  }
1573 
1574  template<typename _Tp>
1575  static chrono::day
1576  _S_day(const _Tp& __t)
1577  {
1578  using namespace chrono;
1579 
1580  if constexpr (is_same_v<_Tp, day>)
1581  return __t;
1582  else if constexpr (requires { __t.day(); })
1583  return __t.day();
1584  else
1585  return _S_date(__t).day();
1586  }
1587 
1588  template<typename _Tp>
1589  static chrono::month
1590  _S_month(const _Tp& __t)
1591  {
1592  using namespace chrono;
1593 
1594  if constexpr (is_same_v<_Tp, month>)
1595  return __t;
1596  else if constexpr (requires { __t.month(); })
1597  return __t.month();
1598  else
1599  return _S_date(__t).month();
1600  }
1601 
1602  template<typename _Tp>
1603  static chrono::year
1604  _S_year(const _Tp& __t)
1605  {
1606  using namespace chrono;
1607 
1608  if constexpr (is_same_v<_Tp, year>)
1609  return __t;
1610  else if constexpr (requires { __t.year(); })
1611  return __t.year();
1612  else
1613  return _S_date(__t).year();
1614  }
1615 
1616  template<typename _Tp>
1617  static chrono::weekday
1618  _S_weekday(const _Tp& __t)
1619  {
1620  using namespace ::std::chrono;
1621  using ::std::chrono::__detail::__local_time_fmt;
1622 
1623  if constexpr (is_same_v<_Tp, weekday>)
1624  return __t;
1625  else if constexpr (requires { __t.weekday(); })
1626  return __t.weekday();
1627  else if constexpr (is_same_v<_Tp, month_weekday>)
1628  return __t.weekday_indexed().weekday();
1629  else if constexpr (is_same_v<_Tp, month_weekday_last>)
1630  return __t.weekday_last().weekday();
1631  else
1632  return weekday(_S_days(__t));
1633  }
1634 
1635  // Remove subsecond precision from a time_point.
1636  template<typename _Tp>
1637  static auto
1638  _S_floor_seconds(const _Tp& __t)
1639  {
1640  using chrono::__detail::__local_time_fmt;
1641  if constexpr (chrono::__is_time_point_v<_Tp>
1642  || chrono::__is_duration_v<_Tp>)
1643  {
1644  if constexpr (_Tp::period::den != 1)
1645  return chrono::floor<chrono::seconds>(__t);
1646  else
1647  return __t;
1648  }
1649  else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1650  {
1651  if constexpr (_Tp::fractional_width != 0)
1652  return chrono::floor<chrono::seconds>(__t.to_duration());
1653  else
1654  return __t;
1655  }
1656  else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1657  return _S_floor_seconds(__t._M_time);
1658  else
1659  return __t;
1660  }
1661 
1662  // Use the formatting locale's std::time_put facet to produce
1663  // a locale-specific representation.
1664  template<typename _Iter>
1665  _Iter
1666  _M_locale_fmt(_Iter __out, const locale& __loc, const struct tm& __tm,
1667  char __fmt, char __mod) const
1668  {
1669  basic_ostringstream<_CharT> __os;
1670  __os.imbue(__loc);
1671  const auto& __tp = use_facet<time_put<_CharT>>(__loc);
1672  __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
1673  if (__os)
1674  __out = _M_write(std::move(__out), __loc, __os.view());
1675  return __out;
1676  }
1677  };
1678 
1679 } // namespace __format
1680 /// @endcond
1681 
1682  template<typename _Rep, typename _Period, typename _CharT>
1683  requires __format::__formattable_impl<_Rep, _CharT>
1684  struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1685  {
1686  constexpr typename basic_format_parse_context<_CharT>::iterator
1687  parse(basic_format_parse_context<_CharT>& __pc)
1688  {
1689  using namespace __format;
1690  auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1691  if constexpr (!is_floating_point_v<_Rep>)
1692  if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1693  __throw_format_error("format error: invalid precision for duration");
1694  return __it;
1695  }
1696 
1697  template<typename _Out>
1698  typename basic_format_context<_Out, _CharT>::iterator
1699  format(const chrono::duration<_Rep, _Period>& __d,
1700  basic_format_context<_Out, _CharT>& __fc) const
1701  {
1702  if constexpr (numeric_limits<_Rep>::is_signed)
1703  if (__d < __d.zero()) [[unlikely]]
1704  {
1705  if constexpr (is_integral_v<_Rep>)
1706  {
1707  // -d is undefined for the most negative integer.
1708  // Convert duration to corresponding unsigned rep.
1709  using _URep = make_unsigned_t<_Rep>;
1710  auto __ucnt = -static_cast<_URep>(__d.count());
1711  auto __ud = chrono::duration<_URep, _Period>(__ucnt);
1712  return _M_f._M_format(__ud, __fc, true);
1713  }
1714  else
1715  return _M_f._M_format(-__d, __fc, true);
1716  }
1717  return _M_f._M_format(__d, __fc, false);
1718  }
1719 
1720  private:
1721  __format::__formatter_chrono<_CharT> _M_f;
1722  };
1723 
1724  template<__format::__char _CharT>
1725  struct formatter<chrono::day, _CharT>
1726  {
1727  constexpr typename basic_format_parse_context<_CharT>::iterator
1728  parse(basic_format_parse_context<_CharT>& __pc)
1729  { return _M_f._M_parse(__pc, __format::_Day); }
1730 
1731  template<typename _Out>
1732  typename basic_format_context<_Out, _CharT>::iterator
1733  format(const chrono::day& __t,
1734  basic_format_context<_Out, _CharT>& __fc) const
1735  { return _M_f._M_format(__t, __fc); }
1736 
1737  private:
1738  __format::__formatter_chrono<_CharT> _M_f;
1739  };
1740 
1741  template<__format::__char _CharT>
1742  struct formatter<chrono::month, _CharT>
1743  {
1744  constexpr typename basic_format_parse_context<_CharT>::iterator
1745  parse(basic_format_parse_context<_CharT>& __pc)
1746  { return _M_f._M_parse(__pc, __format::_Month); }
1747 
1748  template<typename _Out>
1749  typename basic_format_context<_Out, _CharT>::iterator
1750  format(const chrono::month& __t,
1751  basic_format_context<_Out, _CharT>& __fc) const
1752  { return _M_f._M_format(__t, __fc); }
1753 
1754  private:
1755  __format::__formatter_chrono<_CharT> _M_f;
1756  };
1757 
1758  template<__format::__char _CharT>
1759  struct formatter<chrono::year, _CharT>
1760  {
1761  constexpr typename basic_format_parse_context<_CharT>::iterator
1762  parse(basic_format_parse_context<_CharT>& __pc)
1763  { return _M_f._M_parse(__pc, __format::_Year); }
1764 
1765  template<typename _Out>
1766  typename basic_format_context<_Out, _CharT>::iterator
1767  format(const chrono::year& __t,
1768  basic_format_context<_Out, _CharT>& __fc) const
1769  { return _M_f._M_format(__t, __fc); }
1770 
1771  private:
1772  __format::__formatter_chrono<_CharT> _M_f;
1773  };
1774 
1775  template<__format::__char _CharT>
1776  struct formatter<chrono::weekday, _CharT>
1777  {
1778  constexpr typename basic_format_parse_context<_CharT>::iterator
1779  parse(basic_format_parse_context<_CharT>& __pc)
1780  { return _M_f._M_parse(__pc, __format::_Weekday); }
1781 
1782  template<typename _Out>
1783  typename basic_format_context<_Out, _CharT>::iterator
1784  format(const chrono::weekday& __t,
1785  basic_format_context<_Out, _CharT>& __fc) const
1786  { return _M_f._M_format(__t, __fc); }
1787 
1788  private:
1789  __format::__formatter_chrono<_CharT> _M_f;
1790  };
1791 
1792  template<__format::__char _CharT>
1793  struct formatter<chrono::weekday_indexed, _CharT>
1794  {
1795  constexpr typename basic_format_parse_context<_CharT>::iterator
1796  parse(basic_format_parse_context<_CharT>& __pc)
1797  { return _M_f._M_parse(__pc, __format::_Weekday); }
1798 
1799  template<typename _Out>
1800  typename basic_format_context<_Out, _CharT>::iterator
1801  format(const chrono::weekday_indexed& __t,
1802  basic_format_context<_Out, _CharT>& __fc) const
1803  { return _M_f._M_format(__t, __fc); }
1804 
1805  private:
1806  __format::__formatter_chrono<_CharT> _M_f;
1807  };
1808 
1809  template<__format::__char _CharT>
1810  struct formatter<chrono::weekday_last, _CharT>
1811  {
1812  constexpr typename basic_format_parse_context<_CharT>::iterator
1813  parse(basic_format_parse_context<_CharT>& __pc)
1814  { return _M_f._M_parse(__pc, __format::_Weekday); }
1815 
1816  template<typename _Out>
1817  typename basic_format_context<_Out, _CharT>::iterator
1818  format(const chrono::weekday_last& __t,
1819  basic_format_context<_Out, _CharT>& __fc) const
1820  { return _M_f._M_format(__t, __fc); }
1821 
1822  private:
1823  __format::__formatter_chrono<_CharT> _M_f;
1824  };
1825 
1826  template<__format::__char _CharT>
1827  struct formatter<chrono::month_day, _CharT>
1828  {
1829  constexpr typename basic_format_parse_context<_CharT>::iterator
1830  parse(basic_format_parse_context<_CharT>& __pc)
1831  { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1832 
1833  template<typename _Out>
1834  typename basic_format_context<_Out, _CharT>::iterator
1835  format(const chrono::month_day& __t,
1836  basic_format_context<_Out, _CharT>& __fc) const
1837  { return _M_f._M_format(__t, __fc); }
1838 
1839  private:
1840  __format::__formatter_chrono<_CharT> _M_f;
1841  };
1842 
1843  template<__format::__char _CharT>
1844  struct formatter<chrono::month_day_last, _CharT>
1845  {
1846  constexpr typename basic_format_parse_context<_CharT>::iterator
1847  parse(basic_format_parse_context<_CharT>& __pc)
1848  { return _M_f._M_parse(__pc, __format::_Month); }
1849 
1850  template<typename _Out>
1851  typename basic_format_context<_Out, _CharT>::iterator
1852  format(const chrono::month_day_last& __t,
1853  basic_format_context<_Out, _CharT>& __fc) const
1854  { return _M_f._M_format(__t, __fc); }
1855 
1856  private:
1857  __format::__formatter_chrono<_CharT> _M_f;
1858  };
1859 
1860  template<__format::__char _CharT>
1861  struct formatter<chrono::month_weekday, _CharT>
1862  {
1863  constexpr typename basic_format_parse_context<_CharT>::iterator
1864  parse(basic_format_parse_context<_CharT>& __pc)
1865  { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1866 
1867  template<typename _Out>
1868  typename basic_format_context<_Out, _CharT>::iterator
1869  format(const chrono::month_weekday& __t,
1870  basic_format_context<_Out, _CharT>& __fc) const
1871  { return _M_f._M_format(__t, __fc); }
1872 
1873  private:
1874  __format::__formatter_chrono<_CharT> _M_f;
1875  };
1876 
1877  template<__format::__char _CharT>
1878  struct formatter<chrono::month_weekday_last, _CharT>
1879  {
1880  constexpr typename basic_format_parse_context<_CharT>::iterator
1881  parse(basic_format_parse_context<_CharT>& __pc)
1882  { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1883 
1884  template<typename _Out>
1885  typename basic_format_context<_Out, _CharT>::iterator
1886  format(const chrono::month_weekday_last& __t,
1887  basic_format_context<_Out, _CharT>& __fc) const
1888  { return _M_f._M_format(__t, __fc); }
1889 
1890  private:
1891  __format::__formatter_chrono<_CharT> _M_f;
1892  };
1893 
1894  template<__format::__char _CharT>
1895  struct formatter<chrono::year_month, _CharT>
1896  {
1897  constexpr typename basic_format_parse_context<_CharT>::iterator
1898  parse(basic_format_parse_context<_CharT>& __pc)
1899  { return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }
1900 
1901  template<typename _Out>
1902  typename basic_format_context<_Out, _CharT>::iterator
1903  format(const chrono::year_month& __t,
1904  basic_format_context<_Out, _CharT>& __fc) const
1905  { return _M_f._M_format(__t, __fc); }
1906 
1907  private:
1908  __format::__formatter_chrono<_CharT> _M_f;
1909  };
1910 
1911  template<__format::__char _CharT>
1912  struct formatter<chrono::year_month_day, _CharT>
1913  {
1914  constexpr typename basic_format_parse_context<_CharT>::iterator
1915  parse(basic_format_parse_context<_CharT>& __pc)
1916  { return _M_f._M_parse(__pc, __format::_Date); }
1917 
1918  template<typename _Out>
1919  typename basic_format_context<_Out, _CharT>::iterator
1920  format(const chrono::year_month_day& __t,
1921  basic_format_context<_Out, _CharT>& __fc) const
1922  { return _M_f._M_format(__t, __fc); }
1923 
1924  private:
1925  __format::__formatter_chrono<_CharT> _M_f;
1926  };
1927 
1928  template<__format::__char _CharT>
1929  struct formatter<chrono::year_month_day_last, _CharT>
1930  {
1931  constexpr typename basic_format_parse_context<_CharT>::iterator
1932  parse(basic_format_parse_context<_CharT>& __pc)
1933  { return _M_f._M_parse(__pc, __format::_Date); }
1934 
1935  template<typename _Out>
1936  typename basic_format_context<_Out, _CharT>::iterator
1937  format(const chrono::year_month_day_last& __t,
1938  basic_format_context<_Out, _CharT>& __fc) const
1939  { return _M_f._M_format(__t, __fc); }
1940 
1941  private:
1942  __format::__formatter_chrono<_CharT> _M_f;
1943  };
1944 
1945  template<__format::__char _CharT>
1946  struct formatter<chrono::year_month_weekday, _CharT>
1947  {
1948  constexpr typename basic_format_parse_context<_CharT>::iterator
1949  parse(basic_format_parse_context<_CharT>& __pc)
1950  { return _M_f._M_parse(__pc, __format::_Date); }
1951 
1952  template<typename _Out>
1953  typename basic_format_context<_Out, _CharT>::iterator
1954  format(const chrono::year_month_weekday& __t,
1955  basic_format_context<_Out, _CharT>& __fc) const
1956  { return _M_f._M_format(__t, __fc); }
1957 
1958  private:
1959  __format::__formatter_chrono<_CharT> _M_f;
1960  };
1961 
1962  template<__format::__char _CharT>
1963  struct formatter<chrono::year_month_weekday_last, _CharT>
1964  {
1965  constexpr typename basic_format_parse_context<_CharT>::iterator
1966  parse(basic_format_parse_context<_CharT>& __pc)
1967  { return _M_f._M_parse(__pc, __format::_Date); }
1968 
1969  template<typename _Out>
1970  typename basic_format_context<_Out, _CharT>::iterator
1971  format(const chrono::year_month_weekday_last& __t,
1972  basic_format_context<_Out, _CharT>& __fc) const
1973  { return _M_f._M_format(__t, __fc); }
1974 
1975  private:
1976  __format::__formatter_chrono<_CharT> _M_f;
1977  };
1978 
1979  template<typename _Rep, typename _Period, __format::__char _CharT>
1980  struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
1981  {
1982  constexpr typename basic_format_parse_context<_CharT>::iterator
1983  parse(basic_format_parse_context<_CharT>& __pc)
1984  { return _M_f._M_parse(__pc, __format::_TimeOfDay); }
1985 
1986  template<typename _Out>
1987  typename basic_format_context<_Out, _CharT>::iterator
1988  format(const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
1989  basic_format_context<_Out, _CharT>& __fc) const
1990  { return _M_f._M_format(__t, __fc); }
1991 
1992  private:
1993  __format::__formatter_chrono<_CharT> _M_f;
1994  };
1995 
1996 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
1997  template<__format::__char _CharT>
1998  struct formatter<chrono::sys_info, _CharT>
1999  {
2000  constexpr typename basic_format_parse_context<_CharT>::iterator
2001  parse(basic_format_parse_context<_CharT>& __pc)
2002  { return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2003 
2004  template<typename _Out>
2005  typename basic_format_context<_Out, _CharT>::iterator
2006  format(const chrono::sys_info& __i,
2007  basic_format_context<_Out, _CharT>& __fc) const
2008  { return _M_f._M_format(__i, __fc); }
2009 
2010  private:
2011  __format::__formatter_chrono<_CharT> _M_f;
2012  };
2013 
2014  template<__format::__char _CharT>
2015  struct formatter<chrono::local_info, _CharT>
2016  {
2017  constexpr typename basic_format_parse_context<_CharT>::iterator
2018  parse(basic_format_parse_context<_CharT>& __pc)
2019  { return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2020 
2021  template<typename _Out>
2022  typename basic_format_context<_Out, _CharT>::iterator
2023  format(const chrono::local_info& __i,
2024  basic_format_context<_Out, _CharT>& __fc) const
2025  { return _M_f._M_format(__i, __fc); }
2026 
2027  private:
2028  __format::__formatter_chrono<_CharT> _M_f;
2029  };
2030 #endif
2031 
2032  template<typename _Duration, __format::__char _CharT>
2033  struct formatter<chrono::sys_time<_Duration>, _CharT>
2034  {
2035  constexpr typename basic_format_parse_context<_CharT>::iterator
2036  parse(basic_format_parse_context<_CharT>& __pc)
2037  {
2038  auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
2039  if constexpr (!__stream_insertable)
2040  if (_M_f._M_spec._M_chrono_specs.empty())
2041  __format::__invalid_chrono_spec(); // chrono-specs can't be empty
2042  return __next;
2043  }
2044 
2045  template<typename _Out>
2046  typename basic_format_context<_Out, _CharT>::iterator
2047  format(const chrono::sys_time<_Duration>& __t,
2048  basic_format_context<_Out, _CharT>& __fc) const
2049  { return _M_f._M_format(__t, __fc); }
2050 
2051  private:
2052  static constexpr bool __stream_insertable
2053  = requires (basic_ostream<_CharT>& __os,
2054  chrono::sys_time<_Duration> __t) { __os << __t; };
2055 
2056  __format::__formatter_chrono<_CharT> _M_f;
2057  };
2058 
2059  template<typename _Duration, __format::__char _CharT>
2060  struct formatter<chrono::utc_time<_Duration>, _CharT>
2061  : __format::__formatter_chrono<_CharT>
2062  {
2063  constexpr typename basic_format_parse_context<_CharT>::iterator
2064  parse(basic_format_parse_context<_CharT>& __pc)
2065  { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2066 
2067  template<typename _Out>
2068  typename basic_format_context<_Out, _CharT>::iterator
2069  format(const chrono::utc_time<_Duration>& __t,
2070  basic_format_context<_Out, _CharT>& __fc) const
2071  {
2072  // Adjust by removing leap seconds to get equivalent sys_time.
2073  // We can't just use clock_cast because we want to know if the time
2074  // falls within a leap second insertion, and format seconds as "60".
2075  using chrono::__detail::__utc_leap_second;
2076  using chrono::seconds;
2077  using chrono::sys_time;
2078  using _CDur = common_type_t<_Duration, seconds>;
2079  const auto __li = chrono::get_leap_second_info(__t);
2080  sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
2081  if (!__li.is_leap_second) [[likely]]
2082  return _M_f._M_format(__s, __fc);
2083  else
2084  return _M_f._M_format(__utc_leap_second(__s), __fc);
2085  }
2086 
2087  private:
2088  friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;
2089 
2090  __format::__formatter_chrono<_CharT> _M_f;
2091  };
2092 
2093  template<typename _Duration, __format::__char _CharT>
2094  struct formatter<chrono::tai_time<_Duration>, _CharT>
2095  : __format::__formatter_chrono<_CharT>
2096  {
2097  constexpr typename basic_format_parse_context<_CharT>::iterator
2098  parse(basic_format_parse_context<_CharT>& __pc)
2099  { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2100 
2101  template<typename _Out>
2102  typename basic_format_context<_Out, _CharT>::iterator
2103  format(const chrono::tai_time<_Duration>& __t,
2104  basic_format_context<_Out, _CharT>& __fc) const
2105  {
2106  // Convert to __local_time_fmt with abbrev "TAI" and offset 0s.
2107  // We use __local_time_fmt and not sys_time (as the standard implies)
2108  // because %Z for sys_time would print "UTC" and we want "TAI" here.
2109 
2110  // Offset is 1970y/January/1 - 1958y/January/1
2111  constexpr chrono::days __tai_offset = chrono::days(4383);
2112  using _CDur = common_type_t<_Duration, chrono::days>;
2113  chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
2114  const string __abbrev("TAI", 3);
2115  const chrono::seconds __off = 0s;
2116  const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2117  return _M_f._M_format(__lf, __fc);
2118  }
2119 
2120  private:
2121  __format::__formatter_chrono<_CharT> _M_f;
2122  };
2123 
2124  template<typename _Duration, __format::__char _CharT>
2125  struct formatter<chrono::gps_time<_Duration>, _CharT>
2126  : __format::__formatter_chrono<_CharT>
2127  {
2128  constexpr typename basic_format_parse_context<_CharT>::iterator
2129  parse(basic_format_parse_context<_CharT>& __pc)
2130  { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2131 
2132  template<typename _Out>
2133  typename basic_format_context<_Out, _CharT>::iterator
2134  format(const chrono::gps_time<_Duration>& __t,
2135  basic_format_context<_Out, _CharT>& __fc) const
2136  {
2137  // Convert to __local_time_fmt with abbrev "GPS" and offset 0s.
2138  // We use __local_time_fmt and not sys_time (as the standard implies)
2139  // because %Z for sys_time would print "UTC" and we want "GPS" here.
2140 
2141  // Offset is 1980y/January/Sunday[1] - 1970y/January/1
2142  constexpr chrono::days __gps_offset = chrono::days(3657);
2143  using _CDur = common_type_t<_Duration, chrono::days>;
2144  chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
2145  const string __abbrev("GPS", 3);
2146  const chrono::seconds __off = 0s;
2147  const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2148  return _M_f._M_format(__lf, __fc);
2149  }
2150 
2151  private:
2152  __format::__formatter_chrono<_CharT> _M_f;
2153  };
2154 
2155  template<typename _Duration, __format::__char _CharT>
2156  struct formatter<chrono::file_time<_Duration>, _CharT>
2157  {
2158  constexpr typename basic_format_parse_context<_CharT>::iterator
2159  parse(basic_format_parse_context<_CharT>& __pc)
2160  { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2161 
2162  template<typename _Out>
2163  typename basic_format_context<_Out, _CharT>::iterator
2164  format(const chrono::file_time<_Duration>& __t,
2165  basic_format_context<_Out, _CharT>& __fc) const
2166  {
2167  using namespace chrono;
2168  return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __fc);
2169  }
2170 
2171  private:
2172  __format::__formatter_chrono<_CharT> _M_f;
2173  };
2174 
2175  template<typename _Duration, __format::__char _CharT>
2176  struct formatter<chrono::local_time<_Duration>, _CharT>
2177  {
2178  constexpr typename basic_format_parse_context<_CharT>::iterator
2179  parse(basic_format_parse_context<_CharT>& __pc)
2180  { return _M_f._M_parse(__pc, __format::_DateTime); }
2181 
2182  template<typename _Out>
2183  typename basic_format_context<_Out, _CharT>::iterator
2184  format(const chrono::local_time<_Duration>& __t,
2185  basic_format_context<_Out, _CharT>& __fc) const
2186  { return _M_f._M_format(__t, __fc); }
2187 
2188  private:
2189  __format::__formatter_chrono<_CharT> _M_f;
2190  };
2191 
2192  template<typename _Duration, __format::__char _CharT>
2193  struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2194  {
2195  constexpr typename basic_format_parse_context<_CharT>::iterator
2196  parse(basic_format_parse_context<_CharT>& __pc)
2197  { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2198 
2199  template<typename _Out>
2200  typename basic_format_context<_Out, _CharT>::iterator
2201  format(const chrono::__detail::__local_time_fmt<_Duration>& __t,
2202  basic_format_context<_Out, _CharT>& __fc) const
2203  { return _M_f._M_format(__t, __fc, /* use %Z for {} */ true); }
2204 
2205  private:
2206  __format::__formatter_chrono<_CharT> _M_f;
2207  };
2208 
2209 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2210  template<typename _Duration, typename _TimeZonePtr, __format::__char _CharT>
2211  struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
2212  : formatter<chrono::__detail::__local_time_fmt_for<_Duration>, _CharT>
2213  {
2214  template<typename _Out>
2215  typename basic_format_context<_Out, _CharT>::iterator
2216  format(const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
2217  basic_format_context<_Out, _CharT>& __fc) const
2218  {
2219  using _Ltf = chrono::__detail::__local_time_fmt_for<_Duration>;
2220  using _Base = formatter<_Ltf, _CharT>;
2221  const chrono::sys_info __info = __tp.get_info();
2222  const auto __lf = chrono::local_time_format(__tp.get_local_time(),
2223  &__info.abbrev,
2224  &__info.offset);
2225  return _Base::format(__lf, __fc);
2226  }
2227  };
2228 #endif
2229 
2230  // Partial specialization needed for %c formatting of __utc_leap_second.
2231  template<typename _Duration, __format::__char _CharT>
2232  struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
2233  : formatter<chrono::utc_time<_Duration>, _CharT>
2234  {
2235  template<typename _Out>
2236  typename basic_format_context<_Out, _CharT>::iterator
2237  format(const chrono::__detail::__utc_leap_second<_Duration>& __t,
2238  basic_format_context<_Out, _CharT>& __fc) const
2239  { return this->_M_f._M_format(__t, __fc); }
2240  };
2241 
2242 namespace chrono
2243 {
2244 /// @addtogroup chrono
2245 /// @{
2246 
2247 /// @cond undocumented
2248 namespace __detail
2249 {
2250  template<typename _Duration = seconds>
2251  struct _Parser
2252  {
2253  static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);
2254 
2255  explicit
2256  _Parser(__format::_ChronoParts __need) : _M_need(__need) { }
2257 
2258  _Parser(_Parser&&) = delete;
2259  void operator=(_Parser&&) = delete;
2260 
2261  _Duration _M_time{}; // since midnight
2262  sys_days _M_sys_days{};
2263  year_month_day _M_ymd{};
2264  weekday _M_wd{};
2265  __format::_ChronoParts _M_need;
2266  unsigned _M_is_leap_second : 1 {};
2267  unsigned _M_reserved : 15 {};
2268 
2269  template<typename _CharT, typename _Traits, typename _Alloc>
2270  basic_istream<_CharT, _Traits>&
2271  operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2272  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2273  minutes* __offset = nullptr);
2274 
2275  private:
2276  // Read an unsigned integer from the stream and return it.
2277  // Extract no more than __n digits. Set failbit if an integer isn't read.
2278  template<typename _CharT, typename _Traits>
2279  static int_least32_t
2280  _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
2281  ios_base::iostate& __err, int __n)
2282  {
2283  int_least32_t __val = _S_try_read_digit(__is, __err);
2284  if (__val == -1) [[unlikely]]
2285  __err |= ios_base::failbit;
2286  else
2287  {
2288  int __n1 = (std::min)(__n, 9);
2289  // Cannot overflow __val unless we read more than 9 digits
2290  for (int __i = 1; __i < __n1; ++__i)
2291  if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2292  {
2293  __val *= 10;
2294  __val += __dig;
2295  }
2296 
2297  while (__n1++ < __n) [[unlikely]]
2298  if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2299  {
2300  if (__builtin_mul_overflow(__val, 10, &__val)
2301  || __builtin_add_overflow(__val, __dig, &__val))
2302  {
2303  __err |= ios_base::failbit;
2304  return -1;
2305  }
2306  }
2307  }
2308  return __val;
2309  }
2310 
2311  // Read an unsigned integer from the stream and return it.
2312  // Extract no more than __n digits. Set failbit if an integer isn't read.
2313  template<typename _CharT, typename _Traits>
2314  static int_least32_t
2315  _S_read_signed(basic_istream<_CharT, _Traits>& __is,
2316  ios_base::iostate& __err, int __n)
2317  {
2318  auto __sign = __is.peek();
2319  if (__sign == '-' || __sign == '+')
2320  (void) __is.get();
2321  int_least32_t __val = _S_read_unsigned(__is, __err, __n);
2322  if (__err & ios_base::failbit)
2323  {
2324  if (__sign == '-') [[unlikely]]
2325  __val *= -1;
2326  }
2327  return __val;
2328  }
2329 
2330  // Read a digit from the stream and return it, or return -1.
2331  // If no digit is read eofbit will be set (but not failbit).
2332  template<typename _CharT, typename _Traits>
2333  static int_least32_t
2334  _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
2335  ios_base::iostate& __err)
2336  {
2337  int_least32_t __val = -1;
2338  auto __i = __is.peek();
2339  if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
2340  {
2341  _CharT __c = _Traits::to_char_type(__i);
2342  if (_CharT('0') <= __c && __c <= _CharT('9')) [[likely]]
2343  {
2344  (void) __is.get();
2345  __val = __c - _CharT('0');
2346  }
2347  }
2348  else
2349  __err |= ios_base::eofbit;
2350  return __val;
2351  }
2352 
2353  // Read the specified character and return true.
2354  // If the character is not found, set failbit and return false.
2355  template<typename _CharT, typename _Traits>
2356  static bool
2357  _S_read_chr(basic_istream<_CharT, _Traits>& __is,
2358  ios_base::iostate& __err, _CharT __c)
2359  {
2360  auto __i = __is.peek();
2361  if (_Traits::eq_int_type(__i, _Traits::eof()))
2362  __err |= ios_base::eofbit;
2363  else if (_Traits::to_char_type(__i) == __c) [[likely]]
2364  {
2365  (void) __is.get();
2366  return true;
2367  }
2368  __err |= ios_base::failbit;
2369  return false;
2370  }
2371  };
2372 
2373  template<typename _Duration>
2374  using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;
2375 
2376  template<typename _Duration>
2377  consteval bool
2378  __use_floor()
2379  {
2380  if constexpr (_Duration::period::den == 1)
2381  {
2382  switch (_Duration::period::num)
2383  {
2384  case minutes::period::num:
2385  case hours::period::num:
2386  case days::period::num:
2387  case weeks::period::num:
2388  case years::period::num:
2389  return true;
2390  }
2391  }
2392  return false;
2393  }
2394 
2395  // A "do the right thing" rounding function for duration and time_point
2396  // values extracted by from_stream. When treat_as_floating_point is true
2397  // we don't want to do anything, just a straightforward conversion.
2398  // When the destination type has a period of minutes, hours, days, weeks,
2399  // or years, we use chrono::floor to truncate towards negative infinity.
2400  // This ensures that an extracted timestamp such as 2024-09-05 13:00:00
2401  // will produce 2024-09-05 when rounded to days, rather than rounding up
2402  // to 2024-09-06 (a different day).
2403  // Otherwise, use chrono::round to get the nearest value representable
2404  // in the destination type.
2405  template<typename _ToDur, typename _Tp>
2406  constexpr auto
2407  __round(const _Tp& __t)
2408  {
2409  if constexpr (__is_duration_v<_Tp>)
2410  {
2411  if constexpr (treat_as_floating_point_v<typename _Tp::rep>)
2412  return chrono::duration_cast<_ToDur>(__t);
2413  else if constexpr (__detail::__use_floor<_ToDur>())
2414  return chrono::floor<_ToDur>(__t);
2415  else
2416  return chrono::round<_ToDur>(__t);
2417  }
2418  else
2419  {
2420  static_assert(__is_time_point_v<_Tp>);
2421  using _Tpt = time_point<typename _Tp::clock, _ToDur>;
2422  return _Tpt(__detail::__round<_ToDur>(__t.time_since_epoch()));
2423  }
2424  }
2425 
2426 } // namespace __detail
2427 /// @endcond
2428 
2429  template<typename _CharT, typename _Traits, typename _Rep, typename _Period,
2430  typename _Alloc = allocator<_CharT>>
2431  inline basic_istream<_CharT, _Traits>&
2432  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2433  duration<_Rep, _Period>& __d,
2434  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2435  minutes* __offset = nullptr)
2436  {
2437  auto __need = __format::_ChronoParts::_TimeOfDay;
2438  __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
2439  if (__p(__is, __fmt, __abbrev, __offset))
2440  __d = __detail::__round<duration<_Rep, _Period>>(__p._M_time);
2441  return __is;
2442  }
2443 
2444  template<typename _CharT, typename _Traits>
2445  inline basic_ostream<_CharT, _Traits>&
2446  operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d)
2447  {
2448  using _Ctx = __format::__format_context<_CharT>;
2449  using _Str = basic_string_view<_CharT>;
2450  _Str __s = _GLIBCXX_WIDEN("{:02d} is not a valid day");
2451  if (__d.ok())
2452  __s = __s.substr(0, 6);
2453  auto __u = (unsigned)__d;
2454  __os << std::vformat(__s, make_format_args<_Ctx>(__u));
2455  return __os;
2456  }
2457 
2458  template<typename _CharT, typename _Traits,
2459  typename _Alloc = allocator<_CharT>>
2460  inline basic_istream<_CharT, _Traits>&
2461  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2462  day& __d,
2463  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2464  minutes* __offset = nullptr)
2465  {
2466  __detail::_Parser<> __p(__format::_ChronoParts::_Day);
2467  if (__p(__is, __fmt, __abbrev, __offset))
2468  __d = __p._M_ymd.day();
2469  return __is;
2470  }
2471 
2472  template<typename _CharT, typename _Traits>
2473  inline basic_ostream<_CharT, _Traits>&
2474  operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m)
2475  {
2476  using _Ctx = __format::__format_context<_CharT>;
2477  using _Str = basic_string_view<_CharT>;
2478  _Str __s = _GLIBCXX_WIDEN("{:L%b}{} is not a valid month");
2479  if (__m.ok())
2480  __os << std::vformat(__os.getloc(), __s.substr(0, 6),
2481  make_format_args<_Ctx>(__m));
2482  else
2483  {
2484  auto __u = (unsigned)__m;
2485  __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
2486  }
2487  return __os;
2488  }
2489 
2490  template<typename _CharT, typename _Traits,
2491  typename _Alloc = allocator<_CharT>>
2492  inline basic_istream<_CharT, _Traits>&
2493  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2494  month& __m,
2495  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2496  minutes* __offset = nullptr)
2497  {
2498  __detail::_Parser<> __p(__format::_ChronoParts::_Month);
2499  if (__p(__is, __fmt, __abbrev, __offset))
2500  __m = __p._M_ymd.month();
2501  return __is;
2502  }
2503 
2504  template<typename _CharT, typename _Traits>
2505  inline basic_ostream<_CharT, _Traits>&
2506  operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y)
2507  {
2508  using _Ctx = __format::__format_context<_CharT>;
2509  using _Str = basic_string_view<_CharT>;
2510  _Str __s = _GLIBCXX_WIDEN("-{:04d} is not a valid year");
2511  if (__y.ok())
2512  __s = __s.substr(0, 7);
2513  int __i = (int)__y;
2514  if (__i >= 0) [[likely]]
2515  __s.remove_prefix(1);
2516  else
2517  __i = -__i;
2518  __os << std::vformat(__s, make_format_args<_Ctx>(__i));
2519  return __os;
2520  }
2521 
2522  template<typename _CharT, typename _Traits,
2523  typename _Alloc = allocator<_CharT>>
2524  inline basic_istream<_CharT, _Traits>&
2525  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2526  year& __y,
2527  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2528  minutes* __offset = nullptr)
2529  {
2530  __detail::_Parser<> __p(__format::_ChronoParts::_Year);
2531  if (__p(__is, __fmt, __abbrev, __offset))
2532  __y = __p._M_ymd.year();
2533  return __is;
2534  }
2535 
2536  template<typename _CharT, typename _Traits>
2537  inline basic_ostream<_CharT, _Traits>&
2538  operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd)
2539  {
2540  using _Ctx = __format::__format_context<_CharT>;
2541  using _Str = basic_string_view<_CharT>;
2542  _Str __s = _GLIBCXX_WIDEN("{:L%a}{} is not a valid weekday");
2543  if (__wd.ok())
2544  __os << std::vformat(__os.getloc(), __s.substr(0, 6),
2545  make_format_args<_Ctx>(__wd));
2546  else
2547  {
2548  auto __c = __wd.c_encoding();
2549  __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
2550  }
2551  return __os;
2552  }
2553 
2554  template<typename _CharT, typename _Traits,
2555  typename _Alloc = allocator<_CharT>>
2556  inline basic_istream<_CharT, _Traits>&
2557  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2558  weekday& __wd,
2559  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2560  minutes* __offset = nullptr)
2561  {
2562  __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
2563  if (__p(__is, __fmt, __abbrev, __offset))
2564  __wd = __p._M_wd;
2565  return __is;
2566  }
2567 
2568  template<typename _CharT, typename _Traits>
2569  inline basic_ostream<_CharT, _Traits>&
2570  operator<<(basic_ostream<_CharT, _Traits>& __os,
2571  const weekday_indexed& __wdi)
2572  {
2573  // The standard says to format wdi.weekday() and wdi.index() using
2574  // either "{:L}[{}]" or "{:L}[{} is not a valid index]". The {:L} spec
2575  // means to format the weekday using ostringstream, so just do that.
2576  basic_stringstream<_CharT> __os2;
2577  __os2.imbue(__os.getloc());
2578  __os2 << __wdi.weekday();
2579  const auto __i = __wdi.index();
2580  basic_string_view<_CharT> __s
2581  = _GLIBCXX_WIDEN("[ is not a valid index]");
2582  __os2 << __s[0];
2583  __os2 << std::format(_GLIBCXX_WIDEN("{}"), __i);
2584  if (__i >= 1 && __i <= 5)
2585  __os2 << __s.back();
2586  else
2587  __os2 << __s.substr(1);
2588  __os << __os2.view();
2589  return __os;
2590  }
2591 
2592  template<typename _CharT, typename _Traits>
2593  inline basic_ostream<_CharT, _Traits>&
2594  operator<<(basic_ostream<_CharT, _Traits>& __os,
2595  const weekday_last& __wdl)
2596  {
2597  // As above, just write straight to a stringstream, as if by "{:L}[last]"
2598  basic_stringstream<_CharT> __os2;
2599  __os2.imbue(__os.getloc());
2600  __os2 << __wdl.weekday() << _GLIBCXX_WIDEN("[last]");
2601  __os << __os2.view();
2602  return __os;
2603  }
2604 
2605  template<typename _CharT, typename _Traits>
2606  inline basic_ostream<_CharT, _Traits>&
2607  operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md)
2608  {
2609  // As above, just write straight to a stringstream, as if by "{:L}/{}"
2610  basic_stringstream<_CharT> __os2;
2611  __os2.imbue(__os.getloc());
2612  __os2 << __md.month();
2613  if constexpr (is_same_v<_CharT, char>)
2614  __os2 << '/';
2615  else
2616  __os2 << L'/';
2617  __os2 << __md.day();
2618  __os << __os2.view();
2619  return __os;
2620  }
2621 
2622  template<typename _CharT, typename _Traits,
2623  typename _Alloc = allocator<_CharT>>
2624  inline basic_istream<_CharT, _Traits>&
2625  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2626  month_day& __md,
2627  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2628  minutes* __offset = nullptr)
2629  {
2630  using __format::_ChronoParts;
2631  auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
2632  __detail::_Parser<> __p(__need);
2633  if (__p(__is, __fmt, __abbrev, __offset))
2634  __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
2635  return __is;
2636  }
2637 
2638  template<typename _CharT, typename _Traits>
2639  inline basic_ostream<_CharT, _Traits>&
2640  operator<<(basic_ostream<_CharT, _Traits>& __os,
2641  const month_day_last& __mdl)
2642  {
2643  // As above, just write straight to a stringstream, as if by "{:L}/last"
2644  basic_stringstream<_CharT> __os2;
2645  __os2.imbue(__os.getloc());
2646  __os2 << __mdl.month() << _GLIBCXX_WIDEN("/last");
2647  __os << __os2.view();
2648  return __os;
2649  }
2650 
2651  template<typename _CharT, typename _Traits>
2652  inline basic_ostream<_CharT, _Traits>&
2653  operator<<(basic_ostream<_CharT, _Traits>& __os,
2654  const month_weekday& __mwd)
2655  {
2656  // As above, just write straight to a stringstream, as if by "{:L}/{:L}"
2657  basic_stringstream<_CharT> __os2;
2658  __os2.imbue(__os.getloc());
2659  __os2 << __mwd.month();
2660  if constexpr (is_same_v<_CharT, char>)
2661  __os2 << '/';
2662  else
2663  __os2 << L'/';
2664  __os2 << __mwd.weekday_indexed();
2665  __os << __os2.view();
2666  return __os;
2667  }
2668 
2669  template<typename _CharT, typename _Traits>
2670  inline basic_ostream<_CharT, _Traits>&
2671  operator<<(basic_ostream<_CharT, _Traits>& __os,
2672  const month_weekday_last& __mwdl)
2673  {
2674  // As above, just write straight to a stringstream, as if by "{:L}/{:L}"
2675  basic_stringstream<_CharT> __os2;
2676  __os2.imbue(__os.getloc());
2677  __os2 << __mwdl.month();
2678  if constexpr (is_same_v<_CharT, char>)
2679  __os2 << '/';
2680  else
2681  __os2 << L'/';
2682  __os2 << __mwdl.weekday_last();
2683  __os << __os2.view();
2684  return __os;
2685  }
2686 
2687  template<typename _CharT, typename _Traits>
2688  inline basic_ostream<_CharT, _Traits>&
2689  operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym)
2690  {
2691  // As above, just write straight to a stringstream, as if by "{}/{:L}"
2692  basic_stringstream<_CharT> __os2;
2693  __os2.imbue(__os.getloc());
2694  __os2 << __ym.year();
2695  if constexpr (is_same_v<_CharT, char>)
2696  __os2 << '/';
2697  else
2698  __os2 << L'/';
2699  __os2 << __ym.month();
2700  __os << __os2.view();
2701  return __os;
2702  }
2703 
2704  template<typename _CharT, typename _Traits,
2705  typename _Alloc = allocator<_CharT>>
2706  inline basic_istream<_CharT, _Traits>&
2707  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2708  year_month& __ym,
2709  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2710  minutes* __offset = nullptr)
2711  {
2712  using __format::_ChronoParts;
2713  auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
2714  __detail::_Parser<> __p(__need);
2715  if (__p(__is, __fmt, __abbrev, __offset))
2716  __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
2717  return __is;
2718  }
2719 
2720  template<typename _CharT, typename _Traits>
2721  inline basic_ostream<_CharT, _Traits>&
2722  operator<<(basic_ostream<_CharT, _Traits>& __os,
2723  const year_month_day& __ymd)
2724  {
2725  using _Ctx = __format::__format_context<_CharT>;
2726  using _Str = basic_string_view<_CharT>;
2727  _Str __s = _GLIBCXX_WIDEN("{:%F} is not a valid date");
2728  __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
2729  make_format_args<_Ctx>(__ymd));
2730  return __os;
2731  }
2732 
2733  template<typename _CharT, typename _Traits,
2734  typename _Alloc = allocator<_CharT>>
2735  inline basic_istream<_CharT, _Traits>&
2736  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2737  year_month_day& __ymd,
2738  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2739  minutes* __offset = nullptr)
2740  {
2741  using __format::_ChronoParts;
2742  auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2743  | _ChronoParts::_Day;
2744  __detail::_Parser<> __p(__need);
2745  if (__p(__is, __fmt, __abbrev, __offset))
2746  __ymd = __p._M_ymd;
2747  return __is;
2748  }
2749 
2750  template<typename _CharT, typename _Traits>
2751  inline basic_ostream<_CharT, _Traits>&
2752  operator<<(basic_ostream<_CharT, _Traits>& __os,
2753  const year_month_day_last& __ymdl)
2754  {
2755  // As above, just write straight to a stringstream, as if by "{}/{:L}"
2756  basic_stringstream<_CharT> __os2;
2757  __os2.imbue(__os.getloc());
2758  __os2 << __ymdl.year();
2759  if constexpr (is_same_v<_CharT, char>)
2760  __os2 << '/';
2761  else
2762  __os2 << L'/';
2763  __os2 << __ymdl.month_day_last();
2764  __os << __os2.view();
2765  return __os;
2766  }
2767 
2768  template<typename _CharT, typename _Traits>
2769  inline basic_ostream<_CharT, _Traits>&
2770  operator<<(basic_ostream<_CharT, _Traits>& __os,
2771  const year_month_weekday& __ymwd)
2772  {
2773  // As above, just write straight to a stringstream, as if by
2774  // "{}/{:L}/{:L}"
2775  basic_stringstream<_CharT> __os2;
2776  __os2.imbue(__os.getloc());
2777  _CharT __slash;
2778  if constexpr (is_same_v<_CharT, char>)
2779  __slash = '/';
2780  else
2781  __slash = L'/';
2782  __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
2783  << __ymwd.weekday_indexed();
2784  __os << __os2.view();
2785  return __os;
2786  }
2787 
2788  template<typename _CharT, typename _Traits>
2789  inline basic_ostream<_CharT, _Traits>&
2790  operator<<(basic_ostream<_CharT, _Traits>& __os,
2791  const year_month_weekday_last& __ymwdl)
2792  {
2793  // As above, just write straight to a stringstream, as if by
2794  // "{}/{:L}/{:L}"
2795  basic_stringstream<_CharT> __os2;
2796  __os2.imbue(__os.getloc());
2797  _CharT __slash;
2798  if constexpr (is_same_v<_CharT, char>)
2799  __slash = '/';
2800  else
2801  __slash = L'/';
2802  __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
2803  << __ymwdl.weekday_last();
2804  __os << __os2.view();
2805  return __os;
2806  }
2807 
2808  template<typename _CharT, typename _Traits, typename _Duration>
2809  inline basic_ostream<_CharT, _Traits>&
2810  operator<<(basic_ostream<_CharT, _Traits>& __os,
2811  const hh_mm_ss<_Duration>& __hms)
2812  {
2813  return __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%T}"), __hms);
2814  }
2815 
2816 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2817  /// Writes a sys_info object to an ostream in an unspecified format.
2818  template<typename _CharT, typename _Traits>
2819  basic_ostream<_CharT, _Traits>&
2820  operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __i)
2821  {
2822  __os << '[' << __i.begin << ',' << __i.end
2823  << ',' << hh_mm_ss(__i.offset) << ',' << __i.save
2824  << ',' << __i.abbrev << ']';
2825  return __os;
2826  }
2827 
2828  /// Writes a local_info object to an ostream in an unspecified format.
2829  template<typename _CharT, typename _Traits>
2830  basic_ostream<_CharT, _Traits>&
2831  operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __li)
2832  {
2833  __os << '[';
2834  if (__li.result == local_info::unique)
2835  __os << __li.first;
2836  else
2837  {
2838  if (__li.result == local_info::nonexistent)
2839  __os << "nonexistent";
2840  else
2841  __os << "ambiguous";
2842  __os << " local time between " << __li.first;
2843  __os << " and " << __li.second;
2844  }
2845  __os << ']';
2846  return __os;
2847  }
2848 
2849  template<typename _CharT, typename _Traits, typename _Duration,
2850  typename _TimeZonePtr>
2851  inline basic_ostream<_CharT, _Traits>&
2852  operator<<(basic_ostream<_CharT, _Traits>& __os,
2853  const zoned_time<_Duration, _TimeZonePtr>& __t)
2854  {
2855  __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T %Z}"), __t);
2856  return __os;
2857  }
2858 #endif
2859 
2860  template<typename _CharT, typename _Traits, typename _Duration>
2861  requires (!treat_as_floating_point_v<typename _Duration::rep>)
2862  && ratio_less_v<typename _Duration::period, days::period>
2863  inline basic_ostream<_CharT, _Traits>&
2864  operator<<(basic_ostream<_CharT, _Traits>& __os,
2865  const sys_time<_Duration>& __tp)
2866  {
2867  __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __tp);
2868  return __os;
2869  }
2870 
2871  template<typename _CharT, typename _Traits>
2872  inline basic_ostream<_CharT, _Traits>&
2873  operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp)
2874  {
2875  __os << year_month_day{__dp};
2876  return __os;
2877  }
2878 
2879  template<typename _CharT, typename _Traits, typename _Duration,
2880  typename _Alloc = allocator<_CharT>>
2881  basic_istream<_CharT, _Traits>&
2882  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2883  sys_time<_Duration>& __tp,
2884  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2885  minutes* __offset = nullptr)
2886  {
2887  minutes __off{};
2888  if (!__offset)
2889  __offset = &__off;
2890  using __format::_ChronoParts;
2891  auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2892  | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2893  __detail::_Parser_t<_Duration> __p(__need);
2894  if (__p(__is, __fmt, __abbrev, __offset))
2895  {
2896  if (__p._M_is_leap_second)
2897  __is.setstate(ios_base::failbit);
2898  else
2899  {
2900  auto __st = __p._M_sys_days + __p._M_time - *__offset;
2901  __tp = __detail::__round<_Duration>(__st);
2902  }
2903  }
2904  return __is;
2905  }
2906 
2907  template<typename _CharT, typename _Traits, typename _Duration>
2908  inline basic_ostream<_CharT, _Traits>&
2909  operator<<(basic_ostream<_CharT, _Traits>& __os,
2910  const utc_time<_Duration>& __t)
2911  {
2912  __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
2913  return __os;
2914  }
2915 
2916  template<typename _CharT, typename _Traits, typename _Duration,
2917  typename _Alloc = allocator<_CharT>>
2918  inline basic_istream<_CharT, _Traits>&
2919  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2920  utc_time<_Duration>& __tp,
2921  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2922  minutes* __offset = nullptr)
2923  {
2924  minutes __off{};
2925  if (!__offset)
2926  __offset = &__off;
2927  using __format::_ChronoParts;
2928  auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2929  | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2930  __detail::_Parser_t<_Duration> __p(__need);
2931  if (__p(__is, __fmt, __abbrev, __offset))
2932  {
2933  // Converting to utc_time before adding _M_time is necessary for
2934  // "23:59:60" to correctly produce a time within a leap second.
2935  auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
2936  - *__offset;
2937  __tp = __detail::__round<_Duration>(__ut);
2938  }
2939  return __is;
2940  }
2941 
2942  template<typename _CharT, typename _Traits, typename _Duration>
2943  inline basic_ostream<_CharT, _Traits>&
2944  operator<<(basic_ostream<_CharT, _Traits>& __os,
2945  const tai_time<_Duration>& __t)
2946  {
2947  __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
2948  return __os;
2949  }
2950 
2951  template<typename _CharT, typename _Traits, typename _Duration,
2952  typename _Alloc = allocator<_CharT>>
2953  inline basic_istream<_CharT, _Traits>&
2954  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2955  tai_time<_Duration>& __tp,
2956  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2957  minutes* __offset = nullptr)
2958  {
2959  minutes __off{};
2960  if (!__offset)
2961  __offset = &__off;
2962  using __format::_ChronoParts;
2963  auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2964  | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2965  __detail::_Parser_t<_Duration> __p(__need);
2966  if (__p(__is, __fmt, __abbrev, __offset))
2967  {
2968  if (__p._M_is_leap_second)
2969  __is.setstate(ios_base::failbit);
2970  else
2971  {
2972  constexpr sys_days __epoch(-days(4383)); // 1958y/1/1
2973  auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
2974  tai_time<common_type_t<_Duration, seconds>> __tt(__d);
2975  __tp = __detail::__round<_Duration>(__tt);
2976  }
2977  }
2978  return __is;
2979  }
2980 
2981  template<typename _CharT, typename _Traits, typename _Duration>
2982  inline basic_ostream<_CharT, _Traits>&
2983  operator<<(basic_ostream<_CharT, _Traits>& __os,
2984  const gps_time<_Duration>& __t)
2985  {
2986  __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
2987  return __os;
2988  }
2989 
2990  template<typename _CharT, typename _Traits, typename _Duration,
2991  typename _Alloc = allocator<_CharT>>
2992  inline basic_istream<_CharT, _Traits>&
2993  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2994  gps_time<_Duration>& __tp,
2995  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2996  minutes* __offset = nullptr)
2997  {
2998  minutes __off{};
2999  if (!__offset)
3000  __offset = &__off;
3001  using __format::_ChronoParts;
3002  auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3003  | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3004  __detail::_Parser_t<_Duration> __p(__need);
3005  if (__p(__is, __fmt, __abbrev, __offset))
3006  {
3007  if (__p._M_is_leap_second)
3008  __is.setstate(ios_base::failbit);
3009  else
3010  {
3011  constexpr sys_days __epoch(days(3657)); // 1980y/1/Sunday[1]
3012  auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3013  gps_time<common_type_t<_Duration, seconds>> __gt(__d);
3014  __tp = __detail::__round<_Duration>(__gt);
3015  }
3016  }
3017  return __is;
3018  }
3019 
3020  template<typename _CharT, typename _Traits, typename _Duration>
3021  inline basic_ostream<_CharT, _Traits>&
3022  operator<<(basic_ostream<_CharT, _Traits>& __os,
3023  const file_time<_Duration>& __t)
3024  {
3025  __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
3026  return __os;
3027  }
3028 
3029  template<typename _CharT, typename _Traits, typename _Duration,
3030  typename _Alloc = allocator<_CharT>>
3031  inline basic_istream<_CharT, _Traits>&
3032  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
3033  file_time<_Duration>& __tp,
3034  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
3035  minutes* __offset = nullptr)
3036  {
3037  sys_time<_Duration> __st;
3038  if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
3039  __tp = __detail::__round<_Duration>(file_clock::from_sys(__st));
3040  return __is;
3041  }
3042 
3043  template<typename _CharT, typename _Traits, typename _Duration>
3044  inline basic_ostream<_CharT, _Traits>&
3045  operator<<(basic_ostream<_CharT, _Traits>& __os,
3046  const local_time<_Duration>& __lt)
3047  {
3048  __os << sys_time<_Duration>{__lt.time_since_epoch()};
3049  return __os;
3050  }
3051 
3052  template<typename _CharT, typename _Traits, typename _Duration,
3053  typename _Alloc = allocator<_CharT>>
3054  basic_istream<_CharT, _Traits>&
3055  from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
3056  local_time<_Duration>& __tp,
3057  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
3058  minutes* __offset = nullptr)
3059  {
3060  using __format::_ChronoParts;
3061  auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3062  | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3063  __detail::_Parser_t<_Duration> __p(__need);
3064  if (__p(__is, __fmt, __abbrev, __offset))
3065  {
3066  days __d = __p._M_sys_days.time_since_epoch();
3067  auto __t = local_days(__d) + __p._M_time; // ignore offset
3068  __tp = __detail::__round<_Duration>(__t);
3069  }
3070  return __is;
3071  }
3072 
3073  // [time.parse] parsing
3074 
3075 namespace __detail
3076 {
3077  // _GLIBCXX_RESOLVE_LIB_DEFECTS
3078  // 3956. chrono::parse uses from_stream as a customization point
3079  void from_stream() = delete;
3080 
3081  template<typename _Parsable, typename _CharT,
3082  typename _Traits = std::char_traits<_CharT>,
3083  typename... _OptArgs>
3084  concept __parsable = requires (basic_istream<_CharT, _Traits>& __is,
3085  const _CharT* __fmt, _Parsable& __tp,
3086  _OptArgs*... __args)
3087  { from_stream(__is, __fmt, __tp, __args...); };
3088 
3089  template<typename _Parsable, typename _CharT,
3090  typename _Traits = char_traits<_CharT>,
3091  typename _Alloc = allocator<_CharT>>
3092  struct _Parse
3093  {
3094  private:
3095  using __string_type = basic_string<_CharT, _Traits, _Alloc>;
3096 
3097  public:
3098  _Parse(const _CharT* __fmt, _Parsable& __tp,
3099  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
3100  minutes* __offset = nullptr)
3101  : _M_fmt(__fmt), _M_tp(std::__addressof(__tp)),
3102  _M_abbrev(__abbrev), _M_offset(__offset)
3103  { }
3104 
3105  _Parse(_Parse&&) = delete;
3106  _Parse& operator=(_Parse&&) = delete;
3107 
3108  private:
3109  using __stream_type = basic_istream<_CharT, _Traits>;
3110 
3111  const _CharT* const _M_fmt;
3112  _Parsable* const _M_tp;
3113  __string_type* const _M_abbrev;
3114  minutes* const _M_offset;
3115 
3116  friend __stream_type&
3117  operator>>(__stream_type& __is, _Parse&& __p)
3118  {
3119  if (__p._M_offset)
3120  from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
3121  __p._M_offset);
3122  else if (__p._M_abbrev)
3123  from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
3124  else
3125  from_stream(__is, __p._M_fmt, *__p._M_tp);
3126  return __is;
3127  }
3128 
3129  friend void operator>>(__stream_type&, _Parse&) = delete;
3130  friend void operator>>(__stream_type&, const _Parse&) = delete;
3131  };
3132 } // namespace __detail
3133 
3134  template<typename _CharT, __detail::__parsable<_CharT> _Parsable>
3135  [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3136  inline auto
3137  parse(const _CharT* __fmt, _Parsable& __tp)
3138  { return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }
3139 
3140  template<typename _CharT, typename _Traits, typename _Alloc,
3141  __detail::__parsable<_CharT, _Traits> _Parsable>
3142  [[nodiscard]]
3143  inline auto
3144  parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
3145  {
3146  return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
3147  }
3148 
3149  template<typename _CharT, typename _Traits, typename _Alloc,
3150  typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3151  __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3152  [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3153  inline auto
3154  parse(const _CharT* __fmt, _Parsable& __tp,
3155  basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3156  {
3157  auto __pa = std::__addressof(__abbrev);
3158  return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3159  __pa);
3160  }
3161 
3162  template<typename _CharT, typename _Traits, typename _Alloc,
3163  typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3164  __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3165  [[nodiscard]]
3166  inline auto
3167  parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3168  basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3169  {
3170  auto __pa = std::__addressof(__abbrev);
3171  return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3172  __tp, __pa);
3173  }
3174 
3175  template<typename _CharT, typename _Traits = char_traits<_CharT>,
3176  typename _StrT = basic_string<_CharT, _Traits>,
3177  __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3178  [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3179  inline auto
3180  parse(const _CharT* __fmt, _Parsable& __tp, minutes& __offset)
3181  {
3182  return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp, nullptr,
3183  &__offset);
3184  }
3185 
3186  template<typename _CharT, typename _Traits, typename _Alloc,
3187  typename _StrT = basic_string<_CharT, _Traits>,
3188  __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3189  [[nodiscard]]
3190  inline auto
3191  parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3192  minutes& __offset)
3193  {
3194  return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3195  __tp, nullptr,
3196  &__offset);
3197  }
3198 
3199  template<typename _CharT, typename _Traits, typename _Alloc,
3200  typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3201  __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3202  [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3203  inline auto
3204  parse(const _CharT* __fmt, _Parsable& __tp,
3205  basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
3206  {
3207  auto __pa = std::__addressof(__abbrev);
3208  return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3209  __pa,
3210  &__offset);
3211  }
3212 
3213  template<typename _CharT, typename _Traits, typename _Alloc,
3214  typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3215  __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3216  [[nodiscard]]
3217  inline auto
3218  parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3219  basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
3220  {
3221  auto __pa = std::__addressof(__abbrev);
3222  return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3223  __tp, __pa,
3224  &__offset);
3225  }
3226 
3227  /// @cond undocumented
3228  template<typename _Duration>
3229  template<typename _CharT, typename _Traits, typename _Alloc>
3230  basic_istream<_CharT, _Traits>&
3231  __detail::_Parser<_Duration>::
3232  operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
3233  basic_string<_CharT, _Traits, _Alloc>* __abbrev,
3234  minutes* __offset)
3235  {
3236  using sentry = typename basic_istream<_CharT, _Traits>::sentry;
3237  ios_base::iostate __err = ios_base::goodbit;
3238  if (sentry __cerb(__is, true); __cerb)
3239  {
3240  locale __loc = __is.getloc();
3241  auto& __tmget = std::use_facet<std::time_get<_CharT>>(__loc);
3242  auto& __tmpunct = std::use_facet<std::__timepunct<_CharT>>(__loc);
3243 
3244  // RAII type to save and restore stream state.
3245  struct _Stream_state
3246  {
3247  explicit
3248  _Stream_state(basic_istream<_CharT, _Traits>& __i)
3249  : _M_is(__i),
3250  _M_flags(__i.flags(ios_base::skipws | ios_base::dec)),
3251  _M_w(__i.width(0))
3252  { }
3253 
3254  ~_Stream_state()
3255  {
3256  _M_is.flags(_M_flags);
3257  _M_is.width(_M_w);
3258  }
3259 
3260  _Stream_state(_Stream_state&&) = delete;
3261 
3262  basic_istream<_CharT, _Traits>& _M_is;
3263  ios_base::fmtflags _M_flags;
3264  streamsize _M_w;
3265  };
3266 
3267  auto __is_failed = [](ios_base::iostate __e) {
3268  return static_cast<bool>(__e & ios_base::failbit);
3269  };
3270 
3271  // Read an unsigned integer from the stream and return it.
3272  // Extract no more than __n digits. Set __err on error.
3273  auto __read_unsigned = [&] (int __n) {
3274  return _S_read_unsigned(__is, __err, __n);
3275  };
3276 
3277  // Read a signed integer from the stream and return it.
3278  // Extract no more than __n digits. Set __err on error.
3279  auto __read_signed = [&] (int __n) {
3280  return _S_read_signed(__is, __err, __n);
3281  };
3282 
3283  // Read an expected character from the stream.
3284  auto __read_chr = [&__is, &__err] (_CharT __c) {
3285  return _S_read_chr(__is, __err, __c);
3286  };
3287 
3288  using __format::_ChronoParts;
3289  _ChronoParts __parts{};
3290 
3291  const year __bad_y = --year::min(); // SHRT_MIN
3292  const month __bad_mon(255);
3293  const day __bad_day(255);
3294  const weekday __bad_wday(255);
3295  const hours __bad_h(-1);
3296  const minutes __bad_min(-9999);
3297  const seconds __bad_sec(-1);
3298 
3299  year __y = __bad_y, __yy = __bad_y; // %Y, %yy
3300  year __iso_y = __bad_y, __iso_yy = __bad_y; // %G, %g
3301  month __m = __bad_mon; // %m
3302  day __d = __bad_day; // %d
3303  weekday __wday = __bad_wday; // %a %A %u %w
3304  hours __h = __bad_h, __h12 = __bad_h; // %H, %I
3305  minutes __min = __bad_min; // %M
3306  _Duration __s = __bad_sec; // %S
3307  int __ampm = 0; // %p
3308  int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1; // %V, %U, %W
3309  int __century = -1; // %C
3310  int __dayofyear = -1; // %j (for non-duration)
3311 
3312  minutes __tz_offset = __bad_min;
3313  basic_string<_CharT, _Traits> __tz_abbr;
3314 
3315  if ((_M_need & _ChronoParts::_TimeOfDay)
3316  && (_M_need & _ChronoParts::_Year))
3317  {
3318  // For time_points assume "00:00:00" is implicitly present,
3319  // so we don't fail to parse if it's not (PR libstdc++/114240).
3320  // We will still fail to parse if there's no year+month+day.
3321  __h = hours(0);
3322  __parts = _ChronoParts::_TimeOfDay;
3323  }
3324 
3325  // bool __is_neg = false; // TODO: how is this handled for parsing?
3326 
3327  _CharT __mod{}; // One of 'E' or 'O' or nul.
3328  unsigned __num = 0; // Non-zero for N modifier.
3329  bool __is_flag = false; // True if we're processing a % flag.
3330 
3331  constexpr bool __is_floating
3332  = treat_as_floating_point_v<typename _Duration::rep>;
3333 
3334  // If an out-of-range value is extracted (e.g. 61min for %M),
3335  // do not set failbit immediately because we might not need it
3336  // (e.g. parsing chrono::year doesn't care about invalid %M values).
3337  // Instead set the variable back to its initial 'bad' state,
3338  // and also set related variables corresponding to the same field
3339  // (e.g. a bad %M value for __min should also reset __h and __s).
3340  // If a valid value is needed later the bad value will cause failure.
3341 
3342  // For some fields we don't know the correct range when parsing and
3343  // we have to be liberal in what we accept, e.g. we allow 366 for
3344  // day-of-year because that's valid in leap years, and we allow 31
3345  // for day-of-month. If those values are needed to determine the
3346  // result then we can do a correct range check at the end when we
3347  // know the how many days the relevant year or month actually has.
3348 
3349  while (*__fmt)
3350  {
3351  _CharT __c = *__fmt++;
3352  if (!__is_flag)
3353  {
3354  if (__c == '%')
3355  __is_flag = true; // This is the start of a flag.
3356  else if (std::isspace(__c, __loc))
3357  std::ws(__is); // Match zero or more whitespace characters.
3358  else if (!__read_chr(__c)) [[unlikely]]
3359  break; // Failed to match the expected character.
3360 
3361  continue; // Process next character in the format string.
3362  }
3363 
3364  // Now processing a flag.
3365  switch (__c)
3366  {
3367  case 'a': // Locale's weekday name
3368  case 'A': // (full or abbreviated, matched case-insensitively).
3369  if (__mod || __num) [[unlikely]]
3370  __err = ios_base::failbit;
3371  else
3372  {
3373  struct tm __tm{};
3374  __tmget.get(__is, {}, __is, __err, &__tm,
3375  __fmt - 2, __fmt);
3376  if (!__is_failed(__err))
3377  __wday = weekday(__tm.tm_wday);
3378  }
3379  __parts |= _ChronoParts::_Weekday;
3380  break;
3381 
3382  case 'b': // Locale's month name
3383  case 'h': // (full or abbreviated, matched case-insensitively).
3384  case 'B':
3385  if (__mod || __num) [[unlikely]]
3386  __err = ios_base::failbit;
3387  else
3388  {
3389  // strptime behaves differently for %b and %B,
3390  // but chrono::parse says they're equivalent.
3391  // Luckily libstdc++ std::time_get works as needed.
3392  struct tm __tm{};
3393  __tmget.get(__is, {}, __is, __err, &__tm,
3394  __fmt - 2, __fmt);
3395  if (!__is_failed(__err))
3396  __m = month(__tm.tm_mon + 1);
3397  }
3398  __parts |= _ChronoParts::_Month;
3399  break;
3400 
3401  case 'c': // Locale's date and time representation.
3402  if (__mod == 'O' || __num) [[unlikely]]
3403  __err |= ios_base::failbit;
3404  else
3405  {
3406  struct tm __tm{};
3407  __tmget.get(__is, {}, __is, __err, &__tm,
3408  __fmt - 2 - (__mod == 'E'), __fmt);
3409  if (!__is_failed(__err))
3410  {
3411  __y = year(__tm.tm_year + 1900);
3412  __m = month(__tm.tm_mon + 1);
3413  __d = day(__tm.tm_mday);
3414  __h = hours(__tm.tm_hour);
3415  __min = minutes(__tm.tm_min);
3416  __s = seconds(__tm.tm_sec);
3417  }
3418  }
3419  __parts |= _ChronoParts::_DateTime;
3420  break;
3421 
3422  case 'C': // Century
3423  if (!__mod) [[likely]]
3424  {
3425  auto __v = __read_signed(__num ? __num : 2);
3426  if (!__is_failed(__err))
3427  {
3428  int __cmin = (int)year::min() / 100;
3429  int __cmax = (int)year::max() / 100;
3430  if (__cmin <= __v && __v <= __cmax)
3431  __century = __v * 100;
3432  else
3433  __century = -2; // This prevents guessing century.
3434  }
3435  }
3436  else if (__mod == 'E')
3437  {
3438  struct tm __tm{};
3439  __tmget.get(__is, {}, __is, __err, &__tm,
3440  __fmt - 3, __fmt);
3441  if (!__is_failed(__err))
3442  __century = __tm.tm_year;
3443  }
3444  else [[unlikely]]
3445  __err |= ios_base::failbit;
3446  // N.B. don't set this here: __parts |= _ChronoParts::_Year;
3447  break;
3448 
3449  case 'd': // Day of month (1-31)
3450  case 'e':
3451  if (!__mod) [[likely]]
3452  {
3453  auto __v = __read_unsigned(__num ? __num : 2);
3454  if (!__is_failed(__err))
3455  __d = day(__v);
3456  }
3457  else if (__mod == 'O')
3458  {
3459  struct tm __tm{};
3460  __tmget.get(__is, {}, __is, __err, &__tm,
3461  __fmt - 3, __fmt);
3462  if (!__is_failed(__err))
3463  __d = day(__tm.tm_mday);
3464  }
3465  else [[unlikely]]
3466  __err |= ios_base::failbit;
3467  __parts |= _ChronoParts::_Day;
3468  break;
3469 
3470  case 'D': // %m/%d/%y
3471  if (__mod || __num) [[unlikely]]
3472  __err |= ios_base::failbit;
3473  else
3474  {
3475  auto __month = __read_unsigned(2); // %m
3476  __read_chr('/');
3477  auto __day = __read_unsigned(2); // %d
3478  __read_chr('/');
3479  auto __year = __read_unsigned(2); // %y
3480  if (__is_failed(__err))
3481  break;
3482  __y = year(__year + 1900 + 100 * int(__year < 69));
3483  __m = month(__month);
3484  __d = day(__day);
3485  if (!year_month_day(__y, __m, __d).ok())
3486  {
3487  __y = __yy = __iso_y = __iso_yy = __bad_y;
3488  __m = __bad_mon;
3489  __d = __bad_day;
3490  break;
3491  }
3492  }
3493  __parts |= _ChronoParts::_Date;
3494  break;
3495 
3496  case 'F': // %Y-%m-%d - any N modifier only applies to %Y.
3497  if (__mod) [[unlikely]]
3498  __err |= ios_base::failbit;
3499  else
3500  {
3501  auto __year = __read_signed(__num ? __num : 4); // %Y
3502  __read_chr('-');
3503  auto __month = __read_unsigned(2); // %m
3504  __read_chr('-');
3505  auto __day = __read_unsigned(2); // %d
3506  if (__is_failed(__err))
3507  break;
3508  __y = year(__year);
3509  __m = month(__month);
3510  __d = day(__day);
3511  if (!year_month_day(__y, __m, __d).ok())
3512  {
3513  __y = __yy = __iso_y = __iso_yy = __bad_y;
3514  __m = __bad_mon;
3515  __d = __bad_day;
3516  break;
3517  }
3518  }
3519  __parts |= _ChronoParts::_Date;
3520  break;
3521 
3522  case 'g': // Last two digits of ISO week-based year.
3523  if (__mod) [[unlikely]]
3524  __err |= ios_base::failbit;
3525  else
3526  {
3527  auto __val = __read_unsigned(__num ? __num : 2);
3528  if (__val >= 0 && __val <= 99)
3529  {
3530  __iso_yy = year(__val);
3531  if (__century == -1) // No %C has been parsed yet.
3532  __century = 2000;
3533  }
3534  else
3535  __iso_yy = __iso_y = __y = __yy = __bad_y;
3536  }
3537  __parts |= _ChronoParts::_Year;
3538  break;
3539 
3540  case 'G': // ISO week-based year.
3541  if (__mod) [[unlikely]]
3542  __err |= ios_base::failbit;
3543  else
3544  __iso_y = year(__read_unsigned(__num ? __num : 4));
3545  __parts |= _ChronoParts::_Year;
3546  break;
3547 
3548  case 'H': // 24-hour (00-23)
3549  case 'I': // 12-hour (1-12)
3550  if (__mod == 'E') [[unlikely]]
3551  __err |= ios_base::failbit;
3552  else if (__mod == 'O')
3553  {
3554 #if 0
3555  struct tm __tm{};
3556  __tm.tm_ampm = 1;
3557  __tmget.get(__is, {}, __is, __err, &__tm,
3558  __fmt - 3, __fmt);
3559  if (!__is_failed(__err))
3560  {
3561  if (__c == 'I')
3562  {
3563  __h12 = hours(__tm.tm_hour);
3564  __h = __bad_h;
3565  }
3566  else
3567  __h = hours(__tm.tm_hour);
3568  }
3569 #else
3570  // XXX %OI seems to be unimplementable.
3571  __err |= ios_base::failbit;
3572 #endif
3573  }
3574  else
3575  {
3576  auto __val = __read_unsigned(__num ? __num : 2);
3577  if (__c == 'I' && __val >= 1 && __val <= 12)
3578  {
3579  __h12 = hours(__val);
3580  __h = __bad_h;
3581  }
3582  else if (__c == 'H' && __val >= 0 && __val <= 23)
3583  {
3584  __h = hours(__val);
3585  __h12 = __bad_h;
3586  }
3587  else
3588  {
3589  if (_M_need & _ChronoParts::_TimeOfDay)
3590  __err |= ios_base::failbit;
3591  break;
3592  }
3593  }
3594  __parts |= _ChronoParts::_TimeOfDay;
3595  break;
3596 
3597  case 'j': // For duration, count of days, otherwise day of year
3598  if (__mod) [[unlikely]]
3599  __err |= ios_base::failbit;
3600  else if (_M_need == _ChronoParts::_TimeOfDay) // duration
3601  {
3602  auto __val = __read_signed(__num ? __num : 3);
3603  if (!__is_failed(__err))
3604  {
3605  __h = days(__val); // __h will get added to _M_time
3606  __parts |= _ChronoParts::_TimeOfDay;
3607  }
3608  }
3609  else
3610  {
3611  __dayofyear = __read_unsigned(__num ? __num : 3);
3612  // N.B. do not alter __parts here, done after loop.
3613  // No need for range checking here either.
3614  }
3615  break;
3616 
3617  case 'm': // Month (1-12)
3618  if (__mod == 'E') [[unlikely]]
3619  __err |= ios_base::failbit;
3620  else if (__mod == 'O')
3621  {
3622  struct tm __tm{};
3623  __tmget.get(__is, {}, __is, __err, &__tm,
3624  __fmt - 2, __fmt);
3625  if (!__is_failed(__err))
3626  __m = month(__tm.tm_mon + 1);
3627  }
3628  else
3629  {
3630  auto __val = __read_unsigned(__num ? __num : 2);
3631  if (__val >= 1 && __val <= 12)
3632  __m = month(__val);
3633  else
3634  __m = __bad_mon;
3635  }
3636  __parts |= _ChronoParts::_Month;
3637  break;
3638 
3639  case 'M': // Minutes
3640  if (__mod == 'E') [[unlikely]]
3641  __err |= ios_base::failbit;
3642  else if (__mod == 'O')
3643  {
3644  struct tm __tm{};
3645  __tmget.get(__is, {}, __is, __err, &__tm,
3646  __fmt - 2, __fmt);
3647  if (!__is_failed(__err))
3648  __min = minutes(__tm.tm_min);
3649  }
3650  else
3651  {
3652  auto __val = __read_unsigned(__num ? __num : 2);
3653  if (0 <= __val && __val < 60)
3654  __min = minutes(__val);
3655  else
3656  {
3657  if (_M_need & _ChronoParts::_TimeOfDay)
3658  __err |= ios_base::failbit;
3659  break;
3660  }
3661  }
3662  __parts |= _ChronoParts::_TimeOfDay;
3663  break;
3664 
3665  case 'p': // Locale's AM/PM designation for 12-hour clock.
3666  if (__mod || __num)
3667  __err |= ios_base::failbit;
3668  else
3669  {
3670  // Can't use std::time_get here as it can't parse %p
3671  // in isolation without %I. This might be faster anyway.
3672  const _CharT* __ampms[2];
3673  __tmpunct._M_am_pm(__ampms);
3674  int __n = 0, __which = 3;
3675  while (__which != 0)
3676  {
3677  auto __i = __is.peek();
3678  if (_Traits::eq_int_type(__i, _Traits::eof()))
3679  {
3680  __err |= ios_base::eofbit | ios_base::failbit;
3681  break;
3682  }
3683  __i = std::toupper(_Traits::to_char_type(__i), __loc);
3684  if (__which & 1)
3685  {
3686  if (__i != std::toupper(__ampms[0][__n], __loc))
3687  __which ^= 1;
3688  else if (__ampms[0][__n + 1] == _CharT())
3689  {
3690  __which = 1;
3691  (void) __is.get();
3692  break;
3693  }
3694  }
3695  if (__which & 2)
3696  {
3697  if (__i != std::toupper(__ampms[1][__n], __loc))
3698  __which ^= 2;
3699  else if (__ampms[1][__n + 1] == _CharT())
3700  {
3701  __which = 2;
3702  (void) __is.get();
3703  break;
3704  }
3705  }
3706  if (__which)
3707  (void) __is.get();
3708  ++__n;
3709  }
3710  if (__which == 0 || __which == 3)
3711  __err |= ios_base::failbit;
3712  else
3713  __ampm = __which;
3714  }
3715  break;
3716 
3717  case 'r': // Locale's 12-hour time.
3718  if (__mod || __num)
3719  __err |= ios_base::failbit;
3720  else
3721  {
3722  struct tm __tm{};
3723  __tmget.get(__is, {}, __is, __err, &__tm,
3724  __fmt - 2, __fmt);
3725  if (!__is_failed(__err))
3726  {
3727  __h = hours(__tm.tm_hour);
3728  __min = minutes(__tm.tm_min);
3729  __s = seconds(__tm.tm_sec);
3730  }
3731  }
3732  __parts |= _ChronoParts::_TimeOfDay;
3733  break;
3734 
3735  case 'R': // %H:%M
3736  case 'T': // %H:%M:%S
3737  if (__mod || __num) [[unlikely]]
3738  {
3739  __err |= ios_base::failbit;
3740  break;
3741  }
3742  else
3743  {
3744  auto __val = __read_unsigned(2);
3745  if (__val == -1 || __val > 23) [[unlikely]]
3746  {
3747  if (_M_need & _ChronoParts::_TimeOfDay)
3748  __err |= ios_base::failbit;
3749  break;
3750  }
3751  if (!__read_chr(':')) [[unlikely]]
3752  break;
3753  __h = hours(__val);
3754 
3755  __val = __read_unsigned(2);
3756  if (__val == -1 || __val > 60) [[unlikely]]
3757  {
3758  if (_M_need & _ChronoParts::_TimeOfDay)
3759  __err |= ios_base::failbit;
3760  break;
3761  }
3762  __min = minutes(__val);
3763 
3764  if (__c == 'R')
3765  {
3766  __parts |= _ChronoParts::_TimeOfDay;
3767  break;
3768  }
3769  else if (!__read_chr(':')) [[unlikely]]
3770  break;
3771  }
3772  [[fallthrough]];
3773 
3774  case 'S': // Seconds
3775  if (__mod == 'E') [[unlikely]]
3776  __err |= ios_base::failbit;
3777  else if (__mod == 'O')
3778  {
3779  struct tm __tm{};
3780  __tmget.get(__is, {}, __is, __err, &__tm,
3781  __fmt - 3, __fmt);
3782  if (!__is_failed(__err))
3783  __s = seconds(__tm.tm_sec);
3784  }
3785  else if constexpr (_Duration::period::den == 1
3786  && !__is_floating)
3787  {
3788  auto __val = __read_unsigned(__num ? __num : 2);
3789  if (0 <= __val && __val <= 59) [[likely]]
3790  __s = seconds(__val);
3791  else
3792  {
3793  if (_M_need & _ChronoParts::_TimeOfDay)
3794  __err |= ios_base::failbit;
3795  break;
3796  }
3797  }
3798  else // Read fractional seconds
3799  {
3800  stringstream __buf;
3801  auto __digit = _S_try_read_digit(__is, __err);
3802  if (__digit != -1)
3803  {
3804  __buf.put('0' + __digit);
3805  __digit = _S_try_read_digit(__is, __err);
3806  if (__digit != -1)
3807  __buf.put('0' + __digit);
3808  }
3809 
3810  auto __i = __is.peek();
3811  if (_Traits::eq_int_type(__i, _Traits::eof()))
3812  __err |= ios_base::eofbit;
3813  else
3814  {
3815  _CharT __dp = '.';
3816  if (__loc != locale::classic())
3817  {
3818  auto& __np = use_facet<numpunct<_CharT>>(__loc);
3819  __dp = __np.decimal_point();
3820  }
3821  _CharT __c = _Traits::to_char_type(__i);
3822  if (__c == __dp)
3823  {
3824  (void) __is.get();
3825  __buf.put('.');
3826  int __prec
3827  = hh_mm_ss<_Duration>::fractional_width;
3828  do
3829  {
3830  __digit = _S_try_read_digit(__is, __err);
3831  if (__digit != -1)
3832  __buf.put('0' + __digit);
3833  else
3834  break;
3835  }
3836  while (--__prec);
3837  }
3838  }
3839 
3840  if (!__is_failed(__err)) [[likely]]
3841  {
3842  long double __val{};
3843 #if __cpp_lib_to_chars
3844  string __str = std::move(__buf).str();
3845  auto __first = __str.data();
3846  auto __last = __first + __str.size();
3847  using enum chars_format;
3848  auto [ptr, ec] = std::from_chars(__first, __last,
3849  __val, fixed);
3850  if ((bool)ec || ptr != __last) [[unlikely]]
3851  __err |= ios_base::failbit;
3852  else
3853 #else
3854  if (__buf >> __val)
3855 #endif
3856  {
3857  duration<long double> __fs(__val);
3858  if constexpr (__is_floating)
3859  __s = __fs;
3860  else
3861  __s = chrono::round<_Duration>(__fs);
3862  }
3863  }
3864  }
3865  __parts |= _ChronoParts::_TimeOfDay;
3866  break;
3867 
3868  case 'u': // ISO weekday (1-7)
3869  case 'w': // Weekday (0-6)
3870  if (__mod == 'E') [[unlikely]]
3871  __err |= ios_base::failbit;
3872  else if (__mod == 'O')
3873  {
3874  if (__c == 'w')
3875  {
3876  struct tm __tm{};
3877  __tmget.get(__is, {}, __is, __err, &__tm,
3878  __fmt - 3, __fmt);
3879  if (!__is_failed(__err))
3880  __wday = weekday(__tm.tm_wday);
3881  }
3882  else
3883  __err |= ios_base::failbit;
3884  }
3885  else
3886  {
3887  const int __lo = __c == 'u' ? 1 : 0;
3888  const int __hi = __lo + 6;
3889  auto __val = __read_unsigned(__num ? __num : 1);
3890  if (__lo <= __val && __val <= __hi)
3891  __wday = weekday(__val);
3892  else
3893  {
3894  __wday = __bad_wday;
3895  break;
3896  }
3897  }
3898  __parts |= _ChronoParts::_Weekday;
3899  break;
3900 
3901  case 'U': // Week number of the year (from first Sunday).
3902  case 'V': // ISO week-based week number.
3903  case 'W': // Week number of the year (from first Monday).
3904  if (__mod == 'E') [[unlikely]]
3905  __err |= ios_base::failbit;
3906  else if (__mod == 'O')
3907  {
3908  if (__c == 'V') [[unlikely]]
3909  __err |= ios_base::failbit;
3910  else
3911  {
3912  // TODO nl_langinfo_l(ALT_DIGITS) ?
3913  // Not implementable using std::time_get.
3914  }
3915  }
3916  else
3917  {
3918  const int __lo = __c == 'V' ? 1 : 0;
3919  const int __hi = 53;
3920  auto __val = __read_unsigned(__num ? __num : 2);
3921  if (__lo <= __val && __val <= __hi)
3922  {
3923  switch (__c)
3924  {
3925  case 'U':
3926  __sunday_wk = __val;
3927  break;
3928  case 'V':
3929  __iso_wk = __val;
3930  break;
3931  case 'W':
3932  __monday_wk = __val;
3933  break;
3934  }
3935  }
3936  else
3937  __iso_wk = __sunday_wk = __monday_wk = -1;
3938  }
3939  // N.B. do not alter __parts here, done after loop.
3940  break;
3941 
3942  case 'x': // Locale's date representation.
3943  if (__mod == 'O' || __num) [[unlikely]]
3944  __err |= ios_base::failbit;
3945  else
3946  {
3947  struct tm __tm{};
3948  __tmget.get(__is, {}, __is, __err, &__tm,
3949  __fmt - 2 - (__mod == 'E'), __fmt);
3950  if (!__is_failed(__err))
3951  {
3952  __y = year(__tm.tm_year + 1900);
3953  __m = month(__tm.tm_mon + 1);
3954  __d = day(__tm.tm_mday);
3955  }
3956  }
3957  __parts |= _ChronoParts::_Date;
3958  break;
3959 
3960  case 'X': // Locale's time representation.
3961  if (__mod == 'O' || __num) [[unlikely]]
3962  __err |= ios_base::failbit;
3963  else
3964  {
3965  struct tm __tm{};
3966  __tmget.get(__is, {}, __is, __err, &__tm,
3967  __fmt - 2 - (__mod == 'E'), __fmt);
3968  if (!__is_failed(__err))
3969  {
3970  __h = hours(__tm.tm_hour);
3971  __min = minutes(__tm.tm_min);
3972  __s = seconds(__tm.tm_sec);
3973  }
3974  }
3975  __parts |= _ChronoParts::_TimeOfDay;
3976  break;
3977 
3978  case 'y': // Last two digits of year.
3979  if (__mod) [[unlikely]]
3980  {
3981  struct tm __tm{};
3982  __tmget.get(__is, {}, __is, __err, &__tm,
3983  __fmt - 3, __fmt);
3984  if (!__is_failed(__err))
3985  {
3986  int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
3987  __yy = year(__tm.tm_year - __cent);
3988  if (__century == -1) // No %C has been parsed yet.
3989  __century = __cent;
3990  }
3991  }
3992  else
3993  {
3994  auto __val = __read_unsigned(__num ? __num : 2);
3995  if (__val >= 0 && __val <= 99)
3996  {
3997  __yy = year(__val);
3998  if (__century == -1) // No %C has been parsed yet.
3999  __century = __val < 69 ? 2000 : 1900;
4000  }
4001  else
4002  __y = __yy = __iso_yy = __iso_y = __bad_y;
4003  }
4004  __parts |= _ChronoParts::_Year;
4005  break;
4006 
4007  case 'Y': // Year
4008  if (__mod == 'O') [[unlikely]]
4009  __err |= ios_base::failbit;
4010  else if (__mod == 'E')
4011  {
4012  struct tm __tm{};
4013  __tmget.get(__is, {}, __is, __err, &__tm,
4014  __fmt - 3, __fmt);
4015  if (!__is_failed(__err))
4016  __y = year(__tm.tm_year);
4017  }
4018  else
4019  {
4020  auto __val = __read_unsigned(__num ? __num : 4);
4021  if (!__is_failed(__err))
4022  __y = year(__val);
4023  }
4024  __parts |= _ChronoParts::_Year;
4025  break;
4026 
4027  case 'z':
4028  if (__num) [[unlikely]]
4029  __err |= ios_base::failbit;
4030  else
4031  {
4032  // For %Ez and %Oz read [+|-][h]h[:mm].
4033  // For %z read [+|-]hh[mm].
4034 
4035  auto __i = __is.peek();
4036  if (_Traits::eq_int_type(__i, _Traits::eof()))
4037  {
4038  __err |= ios_base::eofbit | ios_base::failbit;
4039  break;
4040  }
4041  _CharT __ic = _Traits::to_char_type(__i);
4042  const bool __neg = __ic == _CharT('-');
4043  if (__ic == _CharT('-') || __ic == _CharT('+'))
4044  (void) __is.get();
4045 
4046  int_least32_t __hh;
4047  if (__mod)
4048  {
4049  // Read h[h]
4050  __hh = __read_unsigned(2);
4051  }
4052  else
4053  {
4054  // Read hh
4055  __hh = 10 * _S_try_read_digit(__is, __err);
4056  __hh += _S_try_read_digit(__is, __err);
4057  }
4058 
4059  if (__is_failed(__err))
4060  break;
4061 
4062  __i = __is.peek();
4063  if (_Traits::eq_int_type(__i, _Traits::eof()))
4064  {
4065  __err |= ios_base::eofbit;
4066  __tz_offset = minutes(__hh * (__neg ? -60 : 60));
4067  break;
4068  }
4069  __ic = _Traits::to_char_type(__i);
4070 
4071  bool __read_mm = false;
4072  if (__mod)
4073  {
4074  if (__ic == _GLIBCXX_WIDEN(":")[0])
4075  {
4076  // Read [:mm] part.
4077  (void) __is.get();
4078  __read_mm = true;
4079  }
4080  }
4081  else if (_CharT('0') <= __ic && __ic <= _CharT('9'))
4082  {
4083  // Read [mm] part.
4084  __read_mm = true;
4085  }
4086 
4087  int_least32_t __mm = 0;
4088  if (__read_mm)
4089  {
4090  __mm = 10 * _S_try_read_digit(__is, __err);
4091  __mm += _S_try_read_digit(__is, __err);
4092  }
4093 
4094  if (!__is_failed(__err))
4095  {
4096  auto __z = __hh * 60 + __mm;
4097  __tz_offset = minutes(__neg ? -__z : __z);
4098  }
4099  }
4100  break;
4101 
4102  case 'Z':
4103  if (__mod || __num) [[unlikely]]
4104  __err |= ios_base::failbit;
4105  else
4106  {
4107  basic_string_view<_CharT> __x = _GLIBCXX_WIDEN("_/-+");
4108  __tz_abbr.clear();
4109  while (true)
4110  {
4111  auto __i = __is.peek();
4112  if (!_Traits::eq_int_type(__i, _Traits::eof()))
4113  {
4114  _CharT __a = _Traits::to_char_type(__i);
4115  if (std::isalnum(__a, __loc)
4116  || __x.find(__a) != __x.npos)
4117  {
4118  __tz_abbr.push_back(__a);
4119  (void) __is.get();
4120  continue;
4121  }
4122  }
4123  else
4124  __err |= ios_base::eofbit;
4125  break;
4126  }
4127  if (__tz_abbr.empty())
4128  __err |= ios_base::failbit;
4129  }
4130  break;
4131 
4132  case 'n': // Exactly one whitespace character.
4133  if (__mod || __num) [[unlikely]]
4134  __err |= ios_base::failbit;
4135  else
4136  {
4137  _CharT __i = __is.peek();
4138  if (_Traits::eq_int_type(__i, _Traits::eof()))
4139  __err |= ios_base::eofbit | ios_base::failbit;
4140  else if (std::isspace(_Traits::to_char_type(__i), __loc))
4141  (void) __is.get();
4142  else
4143  __err |= ios_base::failbit;
4144  }
4145  break;
4146 
4147  case 't': // Zero or one whitespace characters.
4148  if (__mod || __num) [[unlikely]]
4149  __err |= ios_base::failbit;
4150  else
4151  {
4152  _CharT __i = __is.peek();
4153  if (_Traits::eq_int_type(__i, _Traits::eof()))
4154  __err |= ios_base::eofbit;
4155  else if (std::isspace(_Traits::to_char_type(__i), __loc))
4156  (void) __is.get();
4157  }
4158  break;
4159 
4160  case '%': // A % character.
4161  if (__mod || __num) [[unlikely]]
4162  __err |= ios_base::failbit;
4163  else
4164  __read_chr('%');
4165  break;
4166 
4167  case 'O': // Modifiers
4168  case 'E':
4169  if (__mod || __num) [[unlikely]]
4170  {
4171  __err |= ios_base::failbit;
4172  break;
4173  }
4174  __mod = __c;
4175  continue;
4176 
4177  default:
4178  if (_CharT('1') <= __c && __c <= _CharT('9'))
4179  {
4180  if (!__mod) [[likely]]
4181  {
4182  // %Nx - extract positive decimal integer N
4183  auto __end = __fmt + _Traits::length(__fmt);
4184  auto [__v, __ptr]
4185  = __format::__parse_integer(__fmt - 1, __end);
4186  if (__ptr) [[likely]]
4187  {
4188  __num = __v;
4189  __fmt = __ptr;
4190  continue;
4191  }
4192  }
4193  }
4194  __err |= ios_base::failbit;
4195  }
4196 
4197  if (__is_failed(__err)) [[unlikely]]
4198  break;
4199 
4200  __is_flag = false;
4201  __num = 0;
4202  __mod = _CharT();
4203  }
4204 
4205  if (__century >= 0)
4206  {
4207  if (__yy != __bad_y && __y == __bad_y)
4208  __y = years(__century) + __yy; // Use %y instead of %Y
4209  if (__iso_yy != __bad_y && __iso_y == __bad_y)
4210  __iso_y = years(__century) + __iso_yy; // Use %g instead of %G
4211  }
4212 
4213  bool __can_use_doy = false;
4214  bool __can_use_iso_wk = false;
4215  bool __can_use_sun_wk = false;
4216  bool __can_use_mon_wk = false;
4217 
4218  // A year + day-of-year can be converted to a full date.
4219  if (__y != __bad_y && __dayofyear >= 0)
4220  {
4221  __can_use_doy = true;
4222  __parts |= _ChronoParts::_Date;
4223  }
4224  else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
4225  {
4226  __can_use_sun_wk = true;
4227  __parts |= _ChronoParts::_Date;
4228  }
4229  else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
4230  {
4231  __can_use_mon_wk = true;
4232  __parts |= _ChronoParts::_Date;
4233  }
4234  else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
4235  {
4236  // An ISO week date can be converted to a full date.
4237  __can_use_iso_wk = true;
4238  __parts |= _ChronoParts::_Date;
4239  }
4240 
4241  if (__is_failed(__err)) [[unlikely]]
4242  ; // Don't bother doing any more work.
4243  else if (__is_flag) [[unlikely]] // incomplete format flag
4244  __err |= ios_base::failbit;
4245  else if ((_M_need & __parts) == _M_need) [[likely]]
4246  {
4247  // We try to avoid calculating _M_sys_days and _M_ymd unless
4248  // necessary, because converting sys_days to year_month_day
4249  // (or vice versa) requires non-trivial calculations.
4250  // If we have y/m/d values then use them to populate _M_ymd
4251  // and only convert it to _M_sys_days if the caller needs that.
4252  // But if we don't have y/m/d and need to calculate the date
4253  // from the day-of-year or a week+weekday then we set _M_sys_days
4254  // and only convert it to _M_ymd if the caller needs that.
4255 
4256  // We do more error checking here, but only for the fields that
4257  // we actually need to use. For example, we will not diagnose
4258  // an invalid dayofyear==366 for non-leap years unless actually
4259  // using __dayofyear. This should mean we never produce invalid
4260  // results, but it means not all invalid inputs are diagnosed,
4261  // e.g. "2023-01-01 366" >> "%F %j" ignores the invalid 366.
4262  // We also do not diagnose inconsistent values for the same
4263  // field, e.g. "2021 2022 2023" >> "%C%y %Y %Y" just uses 2023.
4264 
4265  // Whether the caller wants _M_wd.
4266  // The _Weekday bit is only set for chrono::weekday.
4267  const bool __need_wday = _M_need & _ChronoParts::_Weekday;
4268 
4269  // Whether the caller wants _M_sys_days and _M_time.
4270  // Only true for durations and time_points.
4271  const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;
4272 
4273  if (__need_wday && __wday != __bad_wday)
4274  _M_wd = __wday; // Caller only wants a weekday and we have one.
4275  else if (_M_need & _ChronoParts::_Date) // subsumes __need_wday
4276  {
4277  // Whether the caller wants _M_ymd.
4278  // True for chrono::year etc., false for time_points.
4279  const bool __need_ymd = !__need_wday && !__need_time;
4280 
4281  if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
4282  || (_M_need & _ChronoParts::_Month && __m == __bad_mon)
4283  || (_M_need & _ChronoParts::_Day && __d == __bad_day))
4284  {
4285  // Missing at least one of y/m/d so calculate sys_days
4286  // from the other data we have available.
4287 
4288  if (__can_use_doy)
4289  {
4290  if ((0 < __dayofyear && __dayofyear <= 365)
4291  || (__dayofyear == 366 && __y.is_leap()))
4292  [[likely]]
4293  {
4294  _M_sys_days = sys_days(__y/January/1)
4295  + days(__dayofyear - 1);
4296  if (__need_ymd)
4297  _M_ymd = year_month_day(_M_sys_days);
4298  }
4299  else
4300  __err |= ios_base::failbit;
4301  }
4302  else if (__can_use_iso_wk)
4303  {
4304  // Calculate y/m/d from ISO week date.
4305 
4306  if (__iso_wk == 53)
4307  {
4308  // A year has 53 weeks iff Jan 1st is a Thursday
4309  // or Jan 1 is a Wednesday and it's a leap year.
4310  const sys_days __jan4(__iso_y/January/4);
4311  weekday __wd1(__jan4 - days(3));
4312  if (__wd1 != Thursday)
4313  if (__wd1 != Wednesday || !__iso_y.is_leap())
4314  __err |= ios_base::failbit;
4315  }
4316 
4317  if (!__is_failed(__err)) [[likely]]
4318  {
4319  // First Thursday is always in week one:
4320  sys_days __w(Thursday[1]/January/__iso_y);
4321  // First day of week-based year:
4322  __w -= Thursday - Monday;
4323  __w += days(weeks(__iso_wk - 1));
4324  __w += __wday - Monday;
4325  _M_sys_days = __w;
4326 
4327  if (__need_ymd)
4328  _M_ymd = year_month_day(_M_sys_days);
4329  }
4330  }
4331  else if (__can_use_sun_wk)
4332  {
4333  // Calculate y/m/d from week number + weekday.
4334  sys_days __wk1(__y/January/Sunday[1]);
4335  _M_sys_days = __wk1 + weeks(__sunday_wk - 1)
4336  + days(__wday.c_encoding());
4337  _M_ymd = year_month_day(_M_sys_days);
4338  if (_M_ymd.year() != __y) [[unlikely]]
4339  __err |= ios_base::failbit;
4340  }
4341  else if (__can_use_mon_wk)
4342  {
4343  // Calculate y/m/d from week number + weekday.
4344  sys_days __wk1(__y/January/Monday[1]);
4345  _M_sys_days = __wk1 + weeks(__monday_wk - 1)
4346  + days(__wday.c_encoding() - 1);
4347  _M_ymd = year_month_day(_M_sys_days);
4348  if (_M_ymd.year() != __y) [[unlikely]]
4349  __err |= ios_base::failbit;
4350  }
4351  else // Should not be able to get here.
4352  __err |= ios_base::failbit;
4353  }
4354  else
4355  {
4356  // We know that all fields the caller needs are present,
4357  // but check that their values are in range.
4358  // Make unwanted fields valid so that _M_ymd.ok() is true.
4359 
4360  if (_M_need & _ChronoParts::_Year)
4361  {
4362  if (!__y.ok()) [[unlikely]]
4363  __err |= ios_base::failbit;
4364  }
4365  else if (__y == __bad_y)
4366  __y = 1972y; // Leap year so that Feb 29 is valid.
4367 
4368  if (_M_need & _ChronoParts::_Month)
4369  {
4370  if (!__m.ok()) [[unlikely]]
4371  __err |= ios_base::failbit;
4372  }
4373  else if (__m == __bad_mon)
4374  __m = January;
4375 
4376  if (_M_need & _ChronoParts::_Day)
4377  {
4378  if (__d < day(1) || __d > (__y/__m/last).day())
4379  __err |= ios_base::failbit;
4380  }
4381  else if (__d == __bad_day)
4382  __d = 1d;
4383 
4384  if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
4385  {
4386  _M_ymd = __ymd;
4387  if (__need_wday || __need_time)
4388  _M_sys_days = sys_days(_M_ymd);
4389  }
4390  else [[unlikely]]
4391  __err |= ios_base::failbit;
4392  }
4393 
4394  if (__need_wday)
4395  _M_wd = weekday(_M_sys_days);
4396  }
4397 
4398  // Need to set _M_time for both durations and time_points.
4399  if (__need_time)
4400  {
4401  if (__h == __bad_h && __h12 != __bad_h)
4402  {
4403  if (__ampm == 1)
4404  __h = __h12 == hours(12) ? hours(0) : __h12;
4405  else if (__ampm == 2)
4406  __h = __h12 == hours(12) ? __h12 : __h12 + hours(12);
4407  else [[unlikely]]
4408  __err |= ios_base::failbit;
4409  }
4410 
4411  auto __t = _M_time.zero();
4412  bool __ok = false;
4413 
4414  if (__h != __bad_h)
4415  {
4416  __ok = true;
4417  __t += __h;
4418  }
4419 
4420  if (__min != __bad_min)
4421  {
4422  __ok = true;
4423  __t += __min;
4424  }
4425 
4426  if (__s != __bad_sec)
4427  {
4428  __ok = true;
4429  __t += __s;
4430  _M_is_leap_second = __s >= seconds(60);
4431  }
4432 
4433  if (__ok)
4434  _M_time = __t;
4435  else
4436  __err |= ios_base::failbit;
4437  }
4438 
4439  if (!__is_failed(__err)) [[likely]]
4440  {
4441  if (__offset && __tz_offset != __bad_min)
4442  *__offset = __tz_offset;
4443  if (__abbrev && !__tz_abbr.empty())
4444  *__abbrev = std::move(__tz_abbr);
4445  }
4446  }
4447  else
4448  __err |= ios_base::failbit;
4449  }
4450  if (__err)
4451  __is.setstate(__err);
4452  return __is;
4453  }
4454  /// @endcond
4455 #undef _GLIBCXX_WIDEN
4456 
4457  /// @} group chrono
4458 } // namespace chrono
4459 
4460 _GLIBCXX_END_NAMESPACE_VERSION
4461 } // namespace std
4462 
4463 #endif // C++20
4464 
4465 #endif //_GLIBCXX_CHRONO_IO_H
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:138
std::min
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:234
std
ISO C++ entities toplevel namespace is std.
std::right
ios_base & right(ios_base &__base)
Calls base.setf(ios_base::right, ios_base::adjustfield).
Definition: ios_base.h:1085
std::chrono::duration
chrono::duration represents a distance between two points in time
Definition: chrono.h:516
Generated by doxygen 1.9.1