30#ifndef _GLIBCXX_CHRONO_IO_H
31#define _GLIBCXX_CHRONO_IO_H 1
34#pragma GCC system_header
37#if __cplusplus >= 202002L
48namespace std _GLIBCXX_VISIBILITY(default)
50_GLIBCXX_BEGIN_NAMESPACE_VERSION
60#define _GLIBCXX_WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
61#define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
63 template<
typename _Period,
typename _CharT>
65 __units_suffix()
noexcept
70#define _GLIBCXX_UNITS_SUFFIX(period, suffix) \
71 if constexpr (is_same_v<_Period, period>) \
72 return _GLIBCXX_WIDEN(suffix); \
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
83 _GLIBCXX_UNITS_SUFFIX(micro,
"\u00b5s")
85 _GLIBCXX_UNITS_SUFFIX(micro,
"us")
87 _GLIBCXX_UNITS_SUFFIX(centi,
"cs")
88 _GLIBCXX_UNITS_SUFFIX(deci,
"ds")
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")
102#undef _GLIBCXX_UNITS_SUFFIX
106 template<
typename _Period,
typename _CharT,
typename _Out>
108 __fmt_units_suffix(_Out __out)
noexcept
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);
116 return std::format_to(
std::move(__out), _GLIBCXX_WIDEN(
"[{}/{}]s"),
117 (uintmax_t)_Period::num,
118 (uintmax_t)_Period::den);
127 template<
typename _CharT,
typename _Traits,
128 typename _Rep,
typename _Period>
134 using period =
typename _Period::type;
142 __detail::__fmt_units_suffix<period, _CharT>(_Out(__s));
152 template<
typename _Duration>
153 struct __local_time_fmt
155 local_time<_Duration> _M_time;
156 const string* _M_abbrev;
162 template<
typename _Duration>
163 using __local_time_fmt_for
164 = __local_time_fmt<common_type_t<_Duration, seconds>>;
177 template<
typename _Duration>
178 inline __detail::__local_time_fmt<_Duration>
180 const string* __abbrev =
nullptr,
181 const seconds* __offset_sec =
nullptr)
182 {
return {__time, __abbrev, __offset_sec}; }
190 [[noreturn,__gnu__::__always_inline__]]
192 __no_timezone_available()
193 { __throw_format_error(
"format error: no timezone available for %Z or %z"); }
195 [[noreturn,__gnu__::__always_inline__]]
197 __not_valid_for_duration()
198 { __throw_format_error(
"format error: chrono-format-spec not valid for "
199 "chrono::duration"); }
201 [[noreturn,__gnu__::__always_inline__]]
203 __invalid_chrono_spec()
204 { __throw_format_error(
"format error: chrono-format-spec not valid for "
207 template<
typename _CharT>
208 struct _ChronoSpec : _Spec<_CharT>
210 basic_string_view<_CharT> _M_chrono_specs;
219 _M_locale_specific() const noexcept
220 {
return this->_M_reserved; }
223 _M_locale_specific(
bool __b)
noexcept
224 { this->_M_reserved = __b; }
231 _Year = 1, _Month = 2, _Day = 4, _Weekday = 8, _TimeOfDay = 16,
233 _Date = _Year | _Month | _Day | _Weekday,
234 _DateTime = _Date | _TimeOfDay,
235 _ZonedDateTime = _DateTime | _TimeZone,
239 constexpr _ChronoParts
240 operator|(_ChronoParts __x, _ChronoParts __y)
noexcept
241 {
return static_cast<_ChronoParts
>((int)__x | (int)__y); }
243 constexpr _ChronoParts&
244 operator|=(_ChronoParts& __x, _ChronoParts __y)
noexcept
245 {
return __x = __x | __y; }
248 template<
typename _CharT>
249 struct __formatter_chrono
251 using __string_view = basic_string_view<_CharT>;
252 using __string = basic_string<_CharT>;
254 template<
typename _ParseContext>
255 constexpr typename _ParseContext::iterator
256 _M_parse(_ParseContext& __pc, _ChronoParts __parts)
258 auto __first = __pc.
begin();
259 auto __last = __pc.end();
261 _ChronoSpec<_CharT> __spec{};
263 auto __finalize = [
this, &__spec] {
267 auto __finished = [&] {
268 if (__first == __last || *__first ==
'}')
279 __first = __spec._M_parse_fill_and_align(__first, __last);
283 __first = __spec._M_parse_width(__first, __last, __pc);
287 if (__parts & _ChronoParts::_Duration)
289 __first = __spec._M_parse_precision(__first, __last, __pc);
294 __first = __spec._M_parse_locale(__first, __last);
301 __string_view __str(__first, __last - __first);
302 auto __end = __str.find(
'}');
303 if (__end != __str.npos)
305 __str.remove_suffix(__str.length() - __end);
306 __last = __first + __end;
308 if (__str.find(
'{') != __str.npos)
309 __throw_format_error(
"chrono format error: '{' in chrono-specs");
316 const auto __chrono_specs = __first++;
317 if (*__chrono_specs !=
'%')
318 __throw_format_error(
"chrono format error: no '%' at start of "
324 bool __locale_specific =
false;
326 while (__first != __last)
328 enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
329 _Mods __allowed_mods = _Mod_none;
331 _CharT __c = *__first++;
337 __locale_specific =
true;
343 __locale_specific =
true;
346 __needed = _DateTime;
347 __allowed_mods = _Mod_E;
348 __locale_specific =
true;
352 __allowed_mods = _Mod_E;
357 __allowed_mods = _Mod_O;
369 __needed = _TimeOfDay;
370 __allowed_mods = _Mod_O;
373 if (!(__parts & _Duration))
378 __allowed_mods = _Mod_O;
381 __needed = _TimeOfDay;
382 __allowed_mods = _Mod_O;
386 __locale_specific =
true;
390 __needed = _TimeOfDay;
394 __needed = _Duration;
397 __needed = _TimeOfDay;
398 __allowed_mods = _Mod_O;
403 __allowed_mods = _Mod_O;
409 __allowed_mods = _Mod_O;
413 __locale_specific =
true;
414 __allowed_mods = _Mod_E;
417 __needed = _TimeOfDay;
418 __locale_specific =
true;
419 __allowed_mods = _Mod_E;
423 __allowed_mods = _Mod_E_O;
427 __allowed_mods = _Mod_E;
430 __needed = _TimeZone;
431 __allowed_mods = _Mod_E_O;
434 __needed = _TimeZone;
442 if (__mod) [[unlikely]]
444 __allowed_mods = _Mod_none;
450 __throw_format_error(
"chrono format error: invalid "
451 " specifier in chrono-specs");
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;
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");
468 size_t __pos = __string_view(__first, __last - __first).find(
'%');
473 if (__pos == __string_view::npos)
479 __first += __pos + 1;
484 if (__conv || __mod != _CharT())
485 __throw_format_error(
"chrono format error: unescaped '%' in "
489 _M_spec._M_chrono_specs
490 = __string_view(__chrono_specs, __first - __chrono_specs);
491 _M_spec._M_locale_specific(__locale_specific);
501 template<
typename _Tp,
typename _FormatContext>
502 typename _FormatContext::iterator
503 _M_format(
const _Tp& __t, _FormatContext& __fc,
504 bool __is_neg =
false)
const
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);
511#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
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())
519 extern locale __with_encoding_conversion(
const locale&);
523 locale __loc = __fc.locale();
524 if (__loc != locale::classic())
525 __fc._M_loc = __with_encoding_conversion(__loc);
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,
535 if (_M_spec._M_width_kind == __format::_WP_none)
538 __write_direct =
true;
541 __out = __sink.out();
544 __out = __sink.out();
548 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
549 __is_neg = __t.is_negative();
551 auto __print_sign = [&__is_neg, &__out] {
552 if constexpr (chrono::__is_duration_v<_Tp>
553 || __is_specialization_of<_Tp, chrono::hh_mm_ss>)
556 *__out++ = _S_plus_minus[1];
563 constexpr const _CharT* __literals = _GLIBCXX_WIDEN(
"\n\t%");
570 _CharT __c = *__first++;
575 __out = _M_a_A(__t,
std::move(__out), __fc, __c ==
'A');
580 __out = _M_b_B(__t,
std::move(__out), __fc, __c ==
'B');
583 __out = _M_c(__t,
std::move(__out), __fc, __mod ==
'E');
588 __out = _M_C_y_Y(__t,
std::move(__out), __fc, __c, __mod);
592 __out = _M_d_e(__t,
std::move(__out), __fc, __c, __mod ==
'O');
595 __out = _M_D(__t,
std::move(__out), __fc);
598 __out = _M_F(__t,
std::move(__out), __fc);
602 __out = _M_g_G(__t,
std::move(__out), __fc, __c ==
'G');
606 __out = _M_H_I(__t, __print_sign(), __fc, __c, __mod ==
'O');
609 __out = _M_j(__t, __print_sign(), __fc);
612 __out = _M_m(__t,
std::move(__out), __fc, __mod ==
'O');
615 __out = _M_M(__t, __print_sign(), __fc, __mod ==
'O');
618 __out = _M_p(__t,
std::move(__out), __fc);
621 __out = _M_q(__t,
std::move(__out), __fc);
625 if constexpr (chrono::__is_duration_v<_Tp>)
628 __out = std::format_to(__print_sign(), _S_empty_spec,
631 __throw_format_error(
"chrono format error: argument is "
635 __out = _M_r(__t, __print_sign(), __fc);
639 __out = _M_R_T(__t, __print_sign(), __fc, __c ==
'T');
642 __out = _M_S(__t, __print_sign(), __fc, __mod ==
'O');
646 __out = _M_u_w(__t,
std::move(__out), __fc, __c, __mod ==
'O');
651 __out = _M_U_V_W(__t,
std::move(__out), __fc, __c,
655 __out = _M_x(__t,
std::move(__out), __fc, __mod ==
'E');
658 __out = _M_X(__t, __print_sign(), __fc, __mod ==
'E');
661 __out = _M_z(__t,
std::move(__out), __fc, (
bool)__mod);
664 __out = _M_Z(__t,
std::move(__out), __fc);
667 *__out++ = __literals[0];
670 *__out++ = __literals[1];
673 *__out++ = __literals[2];
685 __string_view __str(__first, __last - __first);
686 size_t __pos = __str.find(
'%');
691 if (__pos == __str.npos)
695 __str.remove_suffix(__str.length() - __pos);
696 __first += __pos + 1;
698 __out = __format::__write(
std::move(__out), __str);
701 while (__first != __last);
703 if constexpr (is_same_v<
typename _FormatContext::iterator,
709 return __format::__write_padded_as_spec(__str, __str.size(),
713 _ChronoSpec<_CharT> _M_spec;
717 template<
typename _FormatContext>
719 _M_locale(_FormatContext& __fc)
const
721 if (!_M_spec._M_localized)
724 return __fc.locale();
732 template<
typename _Tp,
typename _FormatContext>
733 typename _FormatContext::iterator
734 _M_format_to_ostream(
const _Tp& __t, _FormatContext& __fc,
737 using ::std::chrono::__detail::__utc_leap_second;
738 using ::std::chrono::__detail::__local_time_fmt;
740 basic_ostringstream<_CharT> __os;
741 __os.imbue(_M_locale(__fc));
743 if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
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);
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;
761 for (
char __c : *__t._M_abbrev)
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>)
777 if constexpr (is_convertible_v<_Tp, chrono::sys_days>)
778 __os << _S_date(__t);
781 auto __days = chrono::floor<chrono::days>(__t);
782 __os << chrono::year_month_day(__days) <<
' '
783 << chrono::hh_mm_ss(__t - __days);
788 if constexpr (chrono::__is_duration_v<_Tp>)
789 if (__is_neg) [[unlikely]]
790 __os << _S_plus_minus[1];
796 return __format::__write_padded_as_spec(__str, __str.size(),
800 static constexpr const _CharT* _S_chars
801 = _GLIBCXX_WIDEN(
"0123456789+-:/ {}");
802 static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
803 static constexpr _CharT _S_colon = _S_chars[12];
804 static constexpr _CharT _S_slash = _S_chars[13];
805 static constexpr _CharT _S_space = _S_chars[14];
806 static constexpr const _CharT* _S_empty_spec = _S_chars + 15;
808 template<
typename _OutIter>
810 _M_write(_OutIter __out,
const locale& __loc, __string_view __s)
const
812#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
817 if constexpr (is_same_v<_CharT, char>)
818 if constexpr (__unicode::__literal_encoding_is_utf8())
819 if (_M_spec._M_localized && _M_spec._M_locale_specific()
820 && __loc != locale::classic())
823 __locale_encoding_to_utf8(
const locale&, string_view,
void*);
825 __s = __locale_encoding_to_utf8(__loc, __s, &__buf);
828 return __format::__write(
std::move(__out), __s);
831 template<
typename _Tp,
typename _FormatContext>
832 typename _FormatContext::iterator
833 _M_a_A(
const _Tp& __t,
typename _FormatContext::iterator __out,
834 _FormatContext& __ctx,
bool __full)
const
838 chrono::weekday __wd = _S_weekday(__t);
840 __throw_format_error(
"format error: invalid weekday");
842 locale __loc = _M_locale(__ctx);
843 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
844 const _CharT* __days[7];
846 __tp._M_days(__days);
848 __tp._M_days_abbreviated(__days);
849 __string_view __str(__days[__wd.c_encoding()]);
850 return _M_write(
std::move(__out), __loc, __str);
853 template<
typename _Tp,
typename _FormatContext>
854 typename _FormatContext::iterator
855 _M_b_B(
const _Tp& __t,
typename _FormatContext::iterator __out,
856 _FormatContext& __ctx,
bool __full)
const
860 chrono::month __m = _S_month(__t);
862 __throw_format_error(
"format error: invalid month");
863 locale __loc = _M_locale(__ctx);
864 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
865 const _CharT* __months[12];
867 __tp._M_months(__months);
869 __tp._M_months_abbreviated(__months);
870 __string_view __str(__months[(
unsigned)__m - 1]);
871 return _M_write(
std::move(__out), __loc, __str);
874 template<
typename _Tp,
typename _FormatContext>
875 typename _FormatContext::iterator
876 _M_c(
const _Tp& __t,
typename _FormatContext::iterator __out,
877 _FormatContext& __ctx,
bool __mod =
false)
const
882 using namespace chrono;
883 using ::std::chrono::__detail::__utc_leap_second;
884 using ::std::chrono::__detail::__local_time_fmt;
894#ifdef _GLIBCXX_USE_STRUCT_TM_TM_ZONE
897 if constexpr (__is_time_point_v<_Tp>)
900 if constexpr (!is_same_v<typename _Tp::clock, local_t>)
901 __tm.tm_zone =
const_cast<char*
>(
"UTC");
903 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
908 __tm.tm_zone =
const_cast<char*
>(__t._M_abbrev->c_str());
911 __tm.tm_zone =
const_cast<char*
>(
"UTC");
914 auto __d = _S_days(__t);
915 using _TDays =
decltype(__d);
916 const year_month_day __ymd(__d);
917 const auto __y = __ymd.year();
918 const auto __hms = _S_hms(__t);
920 __tm.tm_year = (int)__y - 1900;
921 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
922 __tm.tm_mon = (unsigned)__ymd.month() - 1;
923 __tm.tm_mday = (unsigned)__ymd.day();
924 __tm.tm_wday = weekday(__d).c_encoding();
925 __tm.tm_hour = __hms.hours().count();
926 __tm.tm_min = __hms.minutes().count();
927 __tm.tm_sec = __hms.seconds().count();
929 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
'c',
933 template<
typename _Tp,
typename _FormatContext>
934 typename _FormatContext::iterator
935 _M_C_y_Y(
const _Tp& __t,
typename _FormatContext::iterator __out,
936 _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0)
const
946 chrono::year __y = _S_year(__t);
948 if (__mod && _M_spec._M_localized) [[unlikely]]
949 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
952 __tm.tm_year = (int)__y - 1900;
953 return _M_locale_fmt(
std::move(__out), __loc, __tm,
957 basic_string<_CharT> __s;
959 const bool __is_neg = __yi < 0;
960 __yi = __builtin_abs(__yi);
962 if (__conv ==
'Y' || __conv ==
'C')
964 int __ci = __yi / 100;
965 if (__is_neg) [[unlikely]]
967 __s.assign(1, _S_plus_minus[1]);
969 if (__conv ==
'C' && (__ci * 100) != __yi)
972 if (__ci >= 100) [[unlikely]]
974 __s += std::format(_S_empty_spec, __ci / 100);
977 __s += _S_two_digits(__ci);
980 if (__conv ==
'Y' || __conv ==
'y')
981 __s += _S_two_digits(__yi % 100);
983 return __format::__write(
std::move(__out), __string_view(__s));
986 template<
typename _Tp,
typename _FormatContext>
987 typename _FormatContext::iterator
988 _M_D(
const _Tp& __t,
typename _FormatContext::iterator __out,
989 _FormatContext&)
const
991 auto __ymd = _S_date(__t);
992 basic_string<_CharT> __s;
993#if ! _GLIBCXX_USE_CXX11_ABI
996 __s = _S_two_digits((
unsigned)__ymd.month());
998 __s += _S_two_digits((
unsigned)__ymd.day());
1000 __s += _S_two_digits(__builtin_abs((
int)__ymd.year()) % 100);
1001 return __format::__write(
std::move(__out), __string_view(__s));
1004 template<
typename _Tp,
typename _FormatContext>
1005 typename _FormatContext::iterator
1006 _M_d_e(
const _Tp& __t,
typename _FormatContext::iterator __out,
1007 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1014 chrono::day __d = _S_day(__t);
1015 unsigned __i = (unsigned)__d;
1017 if (__mod && _M_spec._M_localized) [[unlikely]]
1018 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1022 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1026 auto __sv = _S_two_digits(__i);
1028 if (__conv == _CharT(
'e') && __i < 10)
1030 __buf[0] = _S_space;
1034 return __format::__write(
std::move(__out), __sv);
1037 template<
typename _Tp,
typename _FormatContext>
1038 typename _FormatContext::iterator
1039 _M_F(
const _Tp& __t,
typename _FormatContext::iterator __out,
1040 _FormatContext&)
const
1042 auto __ymd = _S_date(__t);
1043 auto __s = std::format(_GLIBCXX_WIDEN(
"{:04d}- - "),
1045 auto __sv = _S_two_digits((
unsigned)__ymd.month());
1046 __s[__s.size() - 5] = __sv[0];
1047 __s[__s.size() - 4] = __sv[1];
1048 __sv = _S_two_digits((
unsigned)__ymd.day());
1049 __s[__s.size() - 2] = __sv[0];
1050 __s[__s.size() - 1] = __sv[1];
1052 return __format::__write(
std::move(__out), __sv);
1055 template<
typename _Tp,
typename _FormatContext>
1056 typename _FormatContext::iterator
1057 _M_g_G(
const _Tp& __t,
typename _FormatContext::iterator __out,
1058 _FormatContext& __ctx,
bool __full)
const
1062 using namespace chrono;
1063 auto __d = _S_days(__t);
1065 __d -= (weekday(__d) - Monday) -
days(3);
1067 year __y = year_month_day(__d).year();
1068 return _M_C_y_Y(__y,
std::move(__out), __ctx,
"yY"[__full]);
1071 template<
typename _Tp,
typename _FormatContext>
1072 typename _FormatContext::iterator
1073 _M_H_I(
const _Tp& __t,
typename _FormatContext::iterator __out,
1074 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1081 const auto __hms = _S_hms(__t);
1082 int __i = __hms.hours().count();
1084 if (__mod && _M_spec._M_localized) [[unlikely]]
1085 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1089 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1093 if (__conv == _CharT(
'I'))
1100 return __format::__write(
std::move(__out), _S_two_digits(__i));
1103 template<
typename _Tp,
typename _FormatContext>
1104 typename _FormatContext::iterator
1105 _M_j(
const _Tp& __t,
typename _FormatContext::iterator __out,
1106 _FormatContext&)
const
1108 if constexpr (chrono::__is_duration_v<_Tp>)
1111 unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
1112 return std::format_to(
std::move(__out), _S_empty_spec, __d);
1117 using namespace chrono;
1118 auto __day = _S_days(__t);
1119 auto __ymd = _S_date(__t);
1123 if constexpr (is_same_v<
typename decltype(__day)::clock, local_t>)
1124 __d = __day - local_days(__ymd.year()/January/0);
1126 __d = __day - sys_days(__ymd.year()/January/0);
1127 return std::format_to(
std::move(__out), _GLIBCXX_WIDEN(
"{:03d}"),
1132 template<
typename _Tp,
typename _FormatContext>
1133 typename _FormatContext::iterator
1134 _M_m(
const _Tp& __t,
typename _FormatContext::iterator __out,
1135 _FormatContext& __ctx,
bool __mod)
const
1140 auto __m = _S_month(__t);
1141 auto __i = (unsigned)__m;
1143 if (__mod && _M_spec._M_localized) [[unlikely]]
1144 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1147 __tm.tm_mon = __i - 1;
1148 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1152 return __format::__write(
std::move(__out), _S_two_digits(__i));
1155 template<
typename _Tp,
typename _FormatContext>
1156 typename _FormatContext::iterator
1157 _M_M(
const _Tp& __t,
typename _FormatContext::iterator __out,
1158 _FormatContext& __ctx,
bool __mod)
const
1163 auto __m = _S_hms(__t).minutes();
1164 auto __i = __m.count();
1166 if (__mod && _M_spec._M_localized) [[unlikely]]
1167 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1171 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1175 return __format::__write(
std::move(__out), _S_two_digits(__i));
1178 template<
typename _Tp,
typename _FormatContext>
1179 typename _FormatContext::iterator
1180 _M_p(
const _Tp& __t,
typename _FormatContext::iterator __out,
1181 _FormatContext& __ctx)
const
1184 auto __hms = _S_hms(__t);
1185 locale __loc = _M_locale(__ctx);
1186 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1187 const _CharT* __ampm[2];
1188 __tp._M_am_pm(__ampm);
1189 return _M_write(
std::move(__out), __loc,
1190 __ampm[__hms.hours().count() >= 12]);
1193 template<
typename _Tp,
typename _FormatContext>
1194 typename _FormatContext::iterator
1195 _M_q(
const _Tp&,
typename _FormatContext::iterator __out,
1196 _FormatContext&)
const
1199 if constexpr (!chrono::__is_duration_v<_Tp>)
1200 __throw_format_error(
"format error: argument is not a duration");
1203 namespace __d = chrono::__detail;
1204 using period =
typename _Tp::period;
1205 return __d::__fmt_units_suffix<period, _CharT>(
std::move(__out));
1211 template<
typename _Tp,
typename _FormatContext>
1212 typename _FormatContext::iterator
1213 _M_r(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1214 _FormatContext& __ctx)
const
1217 auto __t = _S_floor_seconds(__tt);
1218 locale __loc = _M_locale(__ctx);
1219 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1220 const _CharT* __ampm_fmt;
1221 __tp._M_am_pm_format(&__ampm_fmt);
1222 basic_string<_CharT> __fmt(_S_empty_spec);
1223 __fmt.insert(1u, 1u, _S_colon);
1224 __fmt.insert(2u, __ampm_fmt);
1225 using _FmtStr = _Runtime_format_string<_CharT>;
1226 return _M_write(
std::move(__out), __loc,
1227 std::format(__loc, _FmtStr(__fmt), __t));
1230 template<
typename _Tp,
typename _FormatContext>
1231 typename _FormatContext::iterator
1232 _M_R_T(
const _Tp& __t,
typename _FormatContext::iterator __out,
1233 _FormatContext& __ctx,
bool __secs)
const
1237 auto __hms = _S_hms(__t);
1239 auto __s = std::format(_GLIBCXX_WIDEN(
"{:02d}:00"),
1240 __hms.hours().count());
1241 auto __sv = _S_two_digits(__hms.minutes().count());
1242 __s[__s.size() - 2] = __sv[0];
1243 __s[__s.size() - 1] = __sv[1];
1245 __out = __format::__write(
std::move(__out), __sv);
1248 *__out++ = _S_colon;
1249 __out = _M_S(__hms,
std::move(__out), __ctx);
1254 template<
typename _Tp,
typename _FormatContext>
1255 typename _FormatContext::iterator
1256 _M_S(
const _Tp& __t,
typename _FormatContext::iterator __out,
1257 _FormatContext& __ctx,
bool __mod =
false)
const
1261 auto __hms = _S_hms(__t);
1262 auto __s = __hms.seconds();
1264 if (__mod) [[unlikely]]
1266 if (_M_spec._M_localized)
1267 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1270 __tm.tm_sec = (int)__s.count();
1271 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1276 return __format::__write(
std::move(__out),
1277 _S_two_digits(__s.count()));
1280 if constexpr (__hms.fractional_width == 0)
1281 __out = __format::__write(
std::move(__out),
1282 _S_two_digits(__s.count()));
1285 locale __loc = _M_locale(__ctx);
1286 auto __ss = __hms.subseconds();
1287 using rep =
typename decltype(__ss)::rep;
1288 if constexpr (is_floating_point_v<rep>)
1290 chrono::duration<rep> __fs = __s + __ss;
1291 __out = std::format_to(
std::move(__out), __loc,
1292 _GLIBCXX_WIDEN(
"{:#0{}.{}Lf}"),
1294 3 + __hms.fractional_width,
1295 __hms.fractional_width);
1300 = use_facet<numpunct<_CharT>>(__loc);
1301 __out = __format::__write(
std::move(__out),
1302 _S_two_digits(__s.count()));
1303 *__out++ = __np.decimal_point();
1304 if constexpr (is_integral_v<rep>)
1305 __out = std::format_to(
std::move(__out),
1306 _GLIBCXX_WIDEN(
"{:0{}}"),
1308 __hms.fractional_width);
1311 auto __str = std::format(_S_empty_spec, __ss.count());
1312 __out = std::format_to(_GLIBCXX_WIDEN(
"{:0>{}s}"),
1314 __hms.fractional_width);
1323 template<
typename _Tp,
typename _FormatContext>
1324 typename _FormatContext::iterator
1325 _M_u_w(
const _Tp& __t,
typename _FormatContext::iterator __out,
1326 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1333 chrono::weekday __wd = _S_weekday(__t);
1335 if (__mod && _M_spec._M_localized) [[unlikely]]
1336 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1339 __tm.tm_wday = __wd.c_encoding();
1340 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1344 unsigned __wdi = __conv ==
'u' ? __wd.iso_encoding()
1345 : __wd.c_encoding();
1346 const _CharT __d = _S_digit(__wdi);
1347 return __format::__write(
std::move(__out), __string_view(&__d, 1));
1350 template<
typename _Tp,
typename _FormatContext>
1351 typename _FormatContext::iterator
1352 _M_U_V_W(
const _Tp& __t,
typename _FormatContext::iterator __out,
1353 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1361 using namespace chrono;
1362 auto __d = _S_days(__t);
1363 using _TDays =
decltype(__d);
1365 if (__mod && _M_spec._M_localized) [[unlikely]]
1366 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1368 const year_month_day __ymd(__d);
1369 const year __y = __ymd.year();
1371 __tm.tm_year = (int)__y - 1900;
1372 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
1373 __tm.tm_wday = weekday(__d).c_encoding();
1374 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1382 __d -= (weekday(__d) - Monday) -
days(3);
1385 __first = _TDays(year_month_day(__d).year()/January/1);
1390 if constexpr (
requires { __t.year(); })
1393 __y = year_month_day(__d).year();
1394 const weekday __weekstart = __conv ==
'U' ? Sunday : Monday;
1395 __first = _TDays(__y/January/__weekstart[1]);
1397 auto __weeks = chrono::floor<weeks>(__d - __first);
1398 __string_view __sv = _S_two_digits(__weeks.count() + 1);
1399 return __format::__write(
std::move(__out), __sv);
1402 template<
typename _Tp,
typename _FormatContext>
1403 typename _FormatContext::iterator
1404 _M_x(
const _Tp& __t,
typename _FormatContext::iterator __out,
1405 _FormatContext& __ctx,
bool __mod =
false)
const
1409 locale __loc = _M_locale(__ctx);
1410 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1411 const _CharT* __date_reps[2];
1412 __tp._M_date_formats(__date_reps);
1413 const _CharT* __rep = __date_reps[__mod];
1415 return _M_D(__t,
std::move(__out), __ctx);
1417 basic_string<_CharT> __fmt(_S_empty_spec);
1418 __fmt.insert(1u, 1u, _S_colon);
1419 __fmt.insert(2u, __rep);
1420 using _FmtStr = _Runtime_format_string<_CharT>;
1421 return _M_write(
std::move(__out), __loc,
1422 std::format(__loc, _FmtStr(__fmt), __t));
1425 template<
typename _Tp,
typename _FormatContext>
1426 typename _FormatContext::iterator
1427 _M_X(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1428 _FormatContext& __ctx,
bool __mod =
false)
const
1432 auto __t = _S_floor_seconds(__tt);
1433 locale __loc = _M_locale(__ctx);
1434 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1435 const _CharT* __time_reps[2];
1436 __tp._M_time_formats(__time_reps);
1437 const _CharT* __rep = __time_reps[__mod];
1439 return _M_R_T(__t,
std::move(__out), __ctx,
true);
1441 basic_string<_CharT> __fmt(_S_empty_spec);
1442 __fmt.insert(1u, 1u, _S_colon);
1443 __fmt.insert(2u, __rep);
1444 using _FmtStr = _Runtime_format_string<_CharT>;
1445 return _M_write(
std::move(__out), __loc,
1446 std::format(__loc, _FmtStr(__fmt), __t));
1449 template<
typename _Tp,
typename _FormatContext>
1450 typename _FormatContext::iterator
1451 _M_z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1452 _FormatContext&,
bool __mod =
false)
const
1454 using ::std::chrono::__detail::__utc_leap_second;
1455 using ::std::chrono::__detail::__local_time_fmt;
1457 auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN(
"+00:00"), 6)
1458 : __string_view(_GLIBCXX_WIDEN(
"+0000"), 5);
1460 if constexpr (chrono::__is_time_point_v<_Tp>)
1462 if constexpr (is_same_v<
typename _Tp::clock,
1463 chrono::system_clock>)
1464 return __format::__write(
std::move(__out), __utc);
1466 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1468 if (__t._M_offset_sec)
1471 basic_string<_CharT> __s;
1472 if (*__t._M_offset_sec != 0s)
1474 chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
1475 __s = _S_plus_minus[__hms.is_negative()];
1476 __s += _S_two_digits(__hms.hours().count());
1479 __s += _S_two_digits(__hms.minutes().count());
1482 return __format::__write(
std::move(__out), __sv);
1485 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1486 return __format::__write(
std::move(__out), __utc);
1488 __no_timezone_available();
1491 template<
typename _Tp,
typename _FormatContext>
1492 typename _FormatContext::iterator
1493 _M_Z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1494 _FormatContext& __ctx)
const
1496 using ::std::chrono::__detail::__utc_leap_second;
1497 using ::std::chrono::__detail::__local_time_fmt;
1499 __string_view __utc(_GLIBCXX_WIDEN(
"UTC"), 3);
1500 if constexpr (chrono::__is_time_point_v<_Tp>)
1502 if constexpr (is_same_v<
typename _Tp::clock,
1503 chrono::system_clock>)
1504 return __format::__write(
std::move(__out), __utc);
1506 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1510 string_view __sv = *__t._M_abbrev;
1511 if constexpr (is_same_v<_CharT, char>)
1512 return __format::__write(
std::move(__out), __sv);
1516 basic_string<_CharT> __ws(__sv.size(), _CharT());
1517 auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
1518 __ct.widen(__sv.begin(), __sv.end(), __ws.data());
1519 __string_view __wsv = __ws;
1520 return __format::__write(
std::move(__out), __wsv);
1524 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1525 return __format::__write(
std::move(__out), __utc);
1527 __no_timezone_available();
1534 _S_digit(
int __n)
noexcept
1537 return _GLIBCXX_WIDEN(
"0123456789999999")[__n & 0xf];
1541 static basic_string_view<_CharT>
1542 _S_two_digits(
int __n)
noexcept
1545 _GLIBCXX_WIDEN(
"0001020304050607080910111213141516171819"
1546 "2021222324252627282930313233343536373839"
1547 "4041424344454647484950515253545556575859"
1548 "6061626364656667686970717273747576777879"
1549 "8081828384858687888990919293949596979899"
1550 "9999999999999999999999999999999999999999"
1551 "9999999999999999") + 2 * (__n & 0x7f),
1559 template<
typename _Tp>
1560 static decltype(
auto)
1561 _S_hms(
const _Tp& __t)
1563 using ::std::chrono::__detail::__utc_leap_second;
1564 using ::std::chrono::__detail::__local_time_fmt;
1566 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1568 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1570 else if constexpr (chrono::__is_duration_v<_Tp>)
1571 return chrono::hh_mm_ss<_Tp>(__t);
1572 else if constexpr (chrono::__is_time_point_v<_Tp>)
1573 return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
1574 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1575 return _S_hms(__t._M_time);
1578 __invalid_chrono_spec();
1579 return chrono::hh_mm_ss<chrono::seconds>();
1584 template<
typename _Tp>
1586 _S_days(
const _Tp& __t)
1588 using namespace chrono;
1589 using ::std::chrono::__detail::__utc_leap_second;
1590 using ::std::chrono::__detail::__local_time_fmt;
1592 if constexpr (__is_time_point_v<_Tp>)
1593 return chrono::floor<days>(__t);
1594 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1596 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1597 return chrono::floor<days>(__t._M_time);
1598 else if constexpr (is_same_v<_Tp, year_month_day>
1599 || is_same_v<_Tp, year_month_day_last>
1600 || is_same_v<_Tp, year_month_weekday>
1601 || is_same_v<_Tp, year_month_weekday_last>)
1602 return sys_days(__t);
1605 if constexpr (__is_duration_v<_Tp>)
1606 __not_valid_for_duration();
1608 __invalid_chrono_spec();
1609 return chrono::sys_days();
1614 template<
typename _Tp>
1615 static chrono::year_month_day
1616 _S_date(
const _Tp& __t)
1618 if constexpr (is_same_v<_Tp, chrono::year_month_day>)
1621 return chrono::year_month_day(_S_days(__t));
1624 template<
typename _Tp>
1626 _S_day(
const _Tp& __t)
1628 using namespace chrono;
1630 if constexpr (is_same_v<_Tp, day>)
1632 else if constexpr (
requires { __t.day(); })
1635 return _S_date(__t).day();
1638 template<
typename _Tp>
1639 static chrono::month
1640 _S_month(
const _Tp& __t)
1642 using namespace chrono;
1644 if constexpr (is_same_v<_Tp, month>)
1646 else if constexpr (
requires { __t.month(); })
1649 return _S_date(__t).month();
1652 template<
typename _Tp>
1654 _S_year(
const _Tp& __t)
1656 using namespace chrono;
1658 if constexpr (is_same_v<_Tp, year>)
1660 else if constexpr (
requires { __t.year(); })
1663 return _S_date(__t).year();
1666 template<
typename _Tp>
1667 static chrono::weekday
1668 _S_weekday(
const _Tp& __t)
1670 using namespace ::std::chrono;
1671 using ::std::chrono::__detail::__local_time_fmt;
1673 if constexpr (is_same_v<_Tp, weekday>)
1675 else if constexpr (
requires { __t.weekday(); })
1676 return __t.weekday();
1677 else if constexpr (is_same_v<_Tp, month_weekday>)
1678 return __t.weekday_indexed().weekday();
1679 else if constexpr (is_same_v<_Tp, month_weekday_last>)
1680 return __t.weekday_last().weekday();
1682 return weekday(_S_days(__t));
1686 template<
typename _Tp>
1688 _S_floor_seconds(
const _Tp& __t)
1690 using chrono::__detail::__local_time_fmt;
1691 if constexpr (chrono::__is_time_point_v<_Tp>
1692 || chrono::__is_duration_v<_Tp>)
1694 if constexpr (_Tp::period::den != 1)
1695 return chrono::floor<chrono::seconds>(__t);
1699 else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1701 if constexpr (_Tp::fractional_width != 0)
1702 return chrono::floor<chrono::seconds>(__t.to_duration());
1706 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1707 return _S_floor_seconds(__t._M_time);
1714 template<
typename _Iter>
1716 _M_locale_fmt(_Iter __out,
const locale& __loc,
const struct tm& __tm,
1717 char __fmt,
char __mod)
const
1719 basic_ostringstream<_CharT> __os;
1721 const auto& __tp = use_facet<time_put<_CharT>>(__loc);
1722 __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
1724 __out = _M_write(
std::move(__out), __loc, __os.view());
1732 template<
typename _Rep,
typename _Period,
typename _CharT>
1733 requires __format::__formattable_impl<_Rep, _CharT>
1734 struct formatter<
chrono::duration<_Rep, _Period>, _CharT>
1736 constexpr typename basic_format_parse_context<_CharT>::iterator
1737 parse(basic_format_parse_context<_CharT>& __pc)
1739 using namespace __format;
1740 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1741 if constexpr (!is_floating_point_v<_Rep>)
1742 if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1743 __throw_format_error(
"format error: invalid precision for duration");
1747 template<
typename _Out>
1748 typename basic_format_context<_Out, _CharT>::iterator
1749 format(
const chrono::duration<_Rep, _Period>& __d,
1750 basic_format_context<_Out, _CharT>& __fc)
const
1752 if constexpr (numeric_limits<_Rep>::is_signed)
1753 if (__d < __d.zero()) [[unlikely]]
1755 if constexpr (is_integral_v<_Rep>)
1759 using _URep = make_unsigned_t<_Rep>;
1760 auto __ucnt = -
static_cast<_URep
>(__d.count());
1761 auto __ud = chrono::duration<_URep, _Period>(__ucnt);
1762 return _M_f._M_format(__ud, __fc,
true);
1765 return _M_f._M_format(-__d, __fc,
true);
1767 return _M_f._M_format(__d, __fc,
false);
1771 __format::__formatter_chrono<_CharT> _M_f;
1774 template<__format::__
char _CharT>
1775 struct formatter<
chrono::day, _CharT>
1777 constexpr typename basic_format_parse_context<_CharT>::iterator
1778 parse(basic_format_parse_context<_CharT>& __pc)
1779 {
return _M_f._M_parse(__pc, __format::_Day); }
1781 template<
typename _Out>
1782 typename basic_format_context<_Out, _CharT>::iterator
1783 format(
const chrono::day& __t,
1784 basic_format_context<_Out, _CharT>& __fc)
const
1785 {
return _M_f._M_format(__t, __fc); }
1788 __format::__formatter_chrono<_CharT> _M_f;
1791 template<__format::__
char _CharT>
1792 struct formatter<
chrono::month, _CharT>
1794 constexpr typename basic_format_parse_context<_CharT>::iterator
1795 parse(basic_format_parse_context<_CharT>& __pc)
1796 {
return _M_f._M_parse(__pc, __format::_Month); }
1798 template<
typename _Out>
1799 typename basic_format_context<_Out, _CharT>::iterator
1800 format(
const chrono::month& __t,
1801 basic_format_context<_Out, _CharT>& __fc)
const
1802 {
return _M_f._M_format(__t, __fc); }
1805 __format::__formatter_chrono<_CharT> _M_f;
1808 template<__format::__
char _CharT>
1809 struct formatter<
chrono::year, _CharT>
1811 constexpr typename basic_format_parse_context<_CharT>::iterator
1812 parse(basic_format_parse_context<_CharT>& __pc)
1813 {
return _M_f._M_parse(__pc, __format::_Year); }
1815 template<
typename _Out>
1816 typename basic_format_context<_Out, _CharT>::iterator
1817 format(
const chrono::year& __t,
1818 basic_format_context<_Out, _CharT>& __fc)
const
1819 {
return _M_f._M_format(__t, __fc); }
1822 __format::__formatter_chrono<_CharT> _M_f;
1825 template<__format::__
char _CharT>
1826 struct formatter<
chrono::weekday, _CharT>
1828 constexpr typename basic_format_parse_context<_CharT>::iterator
1829 parse(basic_format_parse_context<_CharT>& __pc)
1830 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1832 template<
typename _Out>
1833 typename basic_format_context<_Out, _CharT>::iterator
1834 format(
const chrono::weekday& __t,
1835 basic_format_context<_Out, _CharT>& __fc)
const
1836 {
return _M_f._M_format(__t, __fc); }
1839 __format::__formatter_chrono<_CharT> _M_f;
1842 template<__format::__
char _CharT>
1843 struct formatter<
chrono::weekday_indexed, _CharT>
1845 constexpr typename basic_format_parse_context<_CharT>::iterator
1846 parse(basic_format_parse_context<_CharT>& __pc)
1847 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1849 template<
typename _Out>
1850 typename basic_format_context<_Out, _CharT>::iterator
1851 format(
const chrono::weekday_indexed& __t,
1852 basic_format_context<_Out, _CharT>& __fc)
const
1853 {
return _M_f._M_format(__t, __fc); }
1856 __format::__formatter_chrono<_CharT> _M_f;
1859 template<__format::__
char _CharT>
1860 struct formatter<
chrono::weekday_last, _CharT>
1862 constexpr typename basic_format_parse_context<_CharT>::iterator
1863 parse(basic_format_parse_context<_CharT>& __pc)
1864 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1866 template<
typename _Out>
1867 typename basic_format_context<_Out, _CharT>::iterator
1868 format(
const chrono::weekday_last& __t,
1869 basic_format_context<_Out, _CharT>& __fc)
const
1870 {
return _M_f._M_format(__t, __fc); }
1873 __format::__formatter_chrono<_CharT> _M_f;
1876 template<__format::__
char _CharT>
1877 struct formatter<
chrono::month_day, _CharT>
1879 constexpr typename basic_format_parse_context<_CharT>::iterator
1880 parse(basic_format_parse_context<_CharT>& __pc)
1881 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1883 template<
typename _Out>
1884 typename basic_format_context<_Out, _CharT>::iterator
1885 format(
const chrono::month_day& __t,
1886 basic_format_context<_Out, _CharT>& __fc)
const
1887 {
return _M_f._M_format(__t, __fc); }
1890 __format::__formatter_chrono<_CharT> _M_f;
1893 template<__format::__
char _CharT>
1894 struct formatter<
chrono::month_day_last, _CharT>
1896 constexpr typename basic_format_parse_context<_CharT>::iterator
1897 parse(basic_format_parse_context<_CharT>& __pc)
1898 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1900 template<
typename _Out>
1901 typename basic_format_context<_Out, _CharT>::iterator
1902 format(
const chrono::month_day_last& __t,
1903 basic_format_context<_Out, _CharT>& __fc)
const
1904 {
return _M_f._M_format(__t, __fc); }
1907 __format::__formatter_chrono<_CharT> _M_f;
1910 template<__format::__
char _CharT>
1911 struct formatter<
chrono::month_weekday, _CharT>
1913 constexpr typename basic_format_parse_context<_CharT>::iterator
1914 parse(basic_format_parse_context<_CharT>& __pc)
1915 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1917 template<
typename _Out>
1918 typename basic_format_context<_Out, _CharT>::iterator
1919 format(
const chrono::month_weekday& __t,
1920 basic_format_context<_Out, _CharT>& __fc)
const
1921 {
return _M_f._M_format(__t, __fc); }
1924 __format::__formatter_chrono<_CharT> _M_f;
1927 template<__format::__
char _CharT>
1928 struct formatter<
chrono::month_weekday_last, _CharT>
1930 constexpr typename basic_format_parse_context<_CharT>::iterator
1931 parse(basic_format_parse_context<_CharT>& __pc)
1932 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1934 template<
typename _Out>
1935 typename basic_format_context<_Out, _CharT>::iterator
1936 format(
const chrono::month_weekday_last& __t,
1937 basic_format_context<_Out, _CharT>& __fc)
const
1938 {
return _M_f._M_format(__t, __fc); }
1941 __format::__formatter_chrono<_CharT> _M_f;
1944 template<__format::__
char _CharT>
1945 struct formatter<
chrono::year_month, _CharT>
1947 constexpr typename basic_format_parse_context<_CharT>::iterator
1948 parse(basic_format_parse_context<_CharT>& __pc)
1949 {
return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }
1951 template<
typename _Out>
1952 typename basic_format_context<_Out, _CharT>::iterator
1953 format(
const chrono::year_month& __t,
1954 basic_format_context<_Out, _CharT>& __fc)
const
1955 {
return _M_f._M_format(__t, __fc); }
1958 __format::__formatter_chrono<_CharT> _M_f;
1961 template<__format::__
char _CharT>
1962 struct formatter<
chrono::year_month_day, _CharT>
1964 constexpr typename basic_format_parse_context<_CharT>::iterator
1965 parse(basic_format_parse_context<_CharT>& __pc)
1966 {
return _M_f._M_parse(__pc, __format::_Date); }
1968 template<
typename _Out>
1969 typename basic_format_context<_Out, _CharT>::iterator
1970 format(
const chrono::year_month_day& __t,
1971 basic_format_context<_Out, _CharT>& __fc)
const
1972 {
return _M_f._M_format(__t, __fc); }
1975 __format::__formatter_chrono<_CharT> _M_f;
1978 template<__format::__
char _CharT>
1979 struct formatter<
chrono::year_month_day_last, _CharT>
1981 constexpr typename basic_format_parse_context<_CharT>::iterator
1982 parse(basic_format_parse_context<_CharT>& __pc)
1983 {
return _M_f._M_parse(__pc, __format::_Date); }
1985 template<
typename _Out>
1986 typename basic_format_context<_Out, _CharT>::iterator
1987 format(
const chrono::year_month_day_last& __t,
1988 basic_format_context<_Out, _CharT>& __fc)
const
1989 {
return _M_f._M_format(__t, __fc); }
1992 __format::__formatter_chrono<_CharT> _M_f;
1995 template<__format::__
char _CharT>
1996 struct formatter<
chrono::year_month_weekday, _CharT>
1998 constexpr typename basic_format_parse_context<_CharT>::iterator
1999 parse(basic_format_parse_context<_CharT>& __pc)
2000 {
return _M_f._M_parse(__pc, __format::_Date); }
2002 template<
typename _Out>
2003 typename basic_format_context<_Out, _CharT>::iterator
2004 format(
const chrono::year_month_weekday& __t,
2005 basic_format_context<_Out, _CharT>& __fc)
const
2006 {
return _M_f._M_format(__t, __fc); }
2009 __format::__formatter_chrono<_CharT> _M_f;
2012 template<__format::__
char _CharT>
2013 struct formatter<
chrono::year_month_weekday_last, _CharT>
2015 constexpr typename basic_format_parse_context<_CharT>::iterator
2016 parse(basic_format_parse_context<_CharT>& __pc)
2017 {
return _M_f._M_parse(__pc, __format::_Date); }
2019 template<
typename _Out>
2020 typename basic_format_context<_Out, _CharT>::iterator
2021 format(
const chrono::year_month_weekday_last& __t,
2022 basic_format_context<_Out, _CharT>& __fc)
const
2023 {
return _M_f._M_format(__t, __fc); }
2026 __format::__formatter_chrono<_CharT> _M_f;
2029 template<
typename _Rep,
typename _Period, __format::__
char _CharT>
2030 struct formatter<
chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
2032 constexpr typename basic_format_parse_context<_CharT>::iterator
2033 parse(basic_format_parse_context<_CharT>& __pc)
2034 {
return _M_f._M_parse(__pc, __format::_TimeOfDay); }
2036 template<
typename _Out>
2037 typename basic_format_context<_Out, _CharT>::iterator
2038 format(
const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
2039 basic_format_context<_Out, _CharT>& __fc)
const
2040 {
return _M_f._M_format(__t, __fc); }
2043 __format::__formatter_chrono<_CharT> _M_f;
2046#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2047 template<__format::__
char _CharT>
2048 struct formatter<
chrono::sys_info, _CharT>
2050 constexpr typename basic_format_parse_context<_CharT>::iterator
2051 parse(basic_format_parse_context<_CharT>& __pc)
2052 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2054 template<
typename _Out>
2055 typename basic_format_context<_Out, _CharT>::iterator
2056 format(
const chrono::sys_info& __i,
2057 basic_format_context<_Out, _CharT>& __fc)
const
2058 {
return _M_f._M_format(__i, __fc); }
2061 __format::__formatter_chrono<_CharT> _M_f;
2064 template<__format::__
char _CharT>
2065 struct formatter<
chrono::local_info, _CharT>
2067 constexpr typename basic_format_parse_context<_CharT>::iterator
2068 parse(basic_format_parse_context<_CharT>& __pc)
2069 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2071 template<
typename _Out>
2072 typename basic_format_context<_Out, _CharT>::iterator
2073 format(
const chrono::local_info& __i,
2074 basic_format_context<_Out, _CharT>& __fc)
const
2075 {
return _M_f._M_format(__i, __fc); }
2078 __format::__formatter_chrono<_CharT> _M_f;
2082 template<
typename _Duration, __format::__
char _CharT>
2083 struct formatter<
chrono::sys_time<_Duration>, _CharT>
2085 constexpr typename basic_format_parse_context<_CharT>::iterator
2086 parse(basic_format_parse_context<_CharT>& __pc)
2088 auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
2089 if constexpr (!__stream_insertable)
2090 if (_M_f._M_spec._M_chrono_specs.empty())
2091 __format::__invalid_chrono_spec();
2095 template<
typename _Out>
2096 typename basic_format_context<_Out, _CharT>::iterator
2097 format(
const chrono::sys_time<_Duration>& __t,
2098 basic_format_context<_Out, _CharT>& __fc)
const
2099 {
return _M_f._M_format(__t, __fc); }
2102 static constexpr bool __stream_insertable
2103 =
requires (basic_ostream<_CharT>& __os,
2104 chrono::sys_time<_Duration> __t) { __os << __t; };
2106 __format::__formatter_chrono<_CharT> _M_f;
2109 template<
typename _Duration, __format::__
char _CharT>
2110 struct formatter<
chrono::utc_time<_Duration>, _CharT>
2111 : __format::__formatter_chrono<_CharT>
2113 constexpr typename basic_format_parse_context<_CharT>::iterator
2114 parse(basic_format_parse_context<_CharT>& __pc)
2115 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2117 template<
typename _Out>
2118 typename basic_format_context<_Out, _CharT>::iterator
2119 format(
const chrono::utc_time<_Duration>& __t,
2120 basic_format_context<_Out, _CharT>& __fc)
const
2125 using chrono::__detail::__utc_leap_second;
2126 using chrono::seconds;
2127 using chrono::sys_time;
2128 using _CDur = common_type_t<_Duration, seconds>;
2129 const auto __li = chrono::get_leap_second_info(__t);
2130 sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
2131 if (!__li.is_leap_second) [[likely]]
2132 return _M_f._M_format(__s, __fc);
2134 return _M_f._M_format(__utc_leap_second(__s), __fc);
2138 friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;
2140 __format::__formatter_chrono<_CharT> _M_f;
2143 template<
typename _Duration, __format::__
char _CharT>
2144 struct formatter<
chrono::tai_time<_Duration>, _CharT>
2145 : __format::__formatter_chrono<_CharT>
2147 constexpr typename basic_format_parse_context<_CharT>::iterator
2148 parse(basic_format_parse_context<_CharT>& __pc)
2149 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2151 template<
typename _Out>
2152 typename basic_format_context<_Out, _CharT>::iterator
2153 format(
const chrono::tai_time<_Duration>& __t,
2154 basic_format_context<_Out, _CharT>& __fc)
const
2161 constexpr chrono::days __tai_offset = chrono::days(4383);
2162 using _CDur = common_type_t<_Duration, chrono::days>;
2163 chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
2164 const string __abbrev(
"TAI", 3);
2165 const chrono::seconds __off = 0s;
2166 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2167 return _M_f._M_format(__lf, __fc);
2171 __format::__formatter_chrono<_CharT> _M_f;
2174 template<
typename _Duration, __format::__
char _CharT>
2175 struct formatter<
chrono::gps_time<_Duration>, _CharT>
2176 : __format::__formatter_chrono<_CharT>
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::_ZonedDateTime); }
2182 template<
typename _Out>
2183 typename basic_format_context<_Out, _CharT>::iterator
2184 format(
const chrono::gps_time<_Duration>& __t,
2185 basic_format_context<_Out, _CharT>& __fc)
const
2192 constexpr chrono::days __gps_offset = chrono::days(3657);
2193 using _CDur = common_type_t<_Duration, chrono::days>;
2194 chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
2195 const string __abbrev(
"GPS", 3);
2196 const chrono::seconds __off = 0s;
2197 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2198 return _M_f._M_format(__lf, __fc);
2202 __format::__formatter_chrono<_CharT> _M_f;
2205 template<
typename _Duration, __format::__
char _CharT>
2206 struct formatter<
chrono::file_time<_Duration>, _CharT>
2208 constexpr typename basic_format_parse_context<_CharT>::iterator
2209 parse(basic_format_parse_context<_CharT>& __pc)
2210 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2212 template<
typename _Out>
2213 typename basic_format_context<_Out, _CharT>::iterator
2214 format(
const chrono::file_time<_Duration>& __t,
2215 basic_format_context<_Out, _CharT>& __fc)
const
2217 using namespace chrono;
2218 return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __fc);
2222 __format::__formatter_chrono<_CharT> _M_f;
2225 template<
typename _Duration, __format::__
char _CharT>
2226 struct formatter<
chrono::local_time<_Duration>, _CharT>
2228 constexpr typename basic_format_parse_context<_CharT>::iterator
2229 parse(basic_format_parse_context<_CharT>& __pc)
2230 {
return _M_f._M_parse(__pc, __format::_DateTime); }
2232 template<
typename _Out>
2233 typename basic_format_context<_Out, _CharT>::iterator
2234 format(
const chrono::local_time<_Duration>& __t,
2235 basic_format_context<_Out, _CharT>& __fc)
const
2236 {
return _M_f._M_format(__t, __fc); }
2239 __format::__formatter_chrono<_CharT> _M_f;
2242 template<
typename _Duration, __format::__
char _CharT>
2243 struct formatter<
chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2245 constexpr typename basic_format_parse_context<_CharT>::iterator
2246 parse(basic_format_parse_context<_CharT>& __pc)
2247 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2249 template<
typename _Out>
2250 typename basic_format_context<_Out, _CharT>::iterator
2251 format(
const chrono::__detail::__local_time_fmt<_Duration>& __t,
2252 basic_format_context<_Out, _CharT>& __fc)
const
2253 {
return _M_f._M_format(__t, __fc,
true); }
2256 __format::__formatter_chrono<_CharT> _M_f;
2259#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2260 template<
typename _Duration,
typename _TimeZonePtr, __format::__
char _CharT>
2261 struct formatter<
chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
2262 : formatter<chrono::__detail::__local_time_fmt_for<_Duration>, _CharT>
2264 template<
typename _Out>
2265 typename basic_format_context<_Out, _CharT>::iterator
2266 format(
const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
2267 basic_format_context<_Out, _CharT>& __fc)
const
2269 using _Ltf = chrono::__detail::__local_time_fmt_for<_Duration>;
2270 using _Base = formatter<_Ltf, _CharT>;
2271 const chrono::sys_info __info = __tp.get_info();
2272 const auto __lf = chrono::local_time_format(__tp.get_local_time(),
2275 return _Base::format(__lf, __fc);
2281 template<
typename _Duration, __format::__
char _CharT>
2282 struct formatter<
chrono::__detail::__utc_leap_second<_Duration>, _CharT>
2283 : formatter<chrono::utc_time<_Duration>, _CharT>
2285 template<
typename _Out>
2286 typename basic_format_context<_Out, _CharT>::iterator
2287 format(
const chrono::__detail::__utc_leap_second<_Duration>& __t,
2288 basic_format_context<_Out, _CharT>& __fc)
const
2289 {
return this->_M_f._M_format(__t, __fc); }
2300 template<
typename _Duration = seconds>
2303 static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);
2306 _Parser(__format::_ChronoParts __need) : _M_need(__need) { }
2308 _Parser(_Parser&&) =
delete;
2309 void operator=(_Parser&&) =
delete;
2311 _Duration _M_time{};
2312 sys_days _M_sys_days{};
2313 year_month_day _M_ymd{};
2315 __format::_ChronoParts _M_need;
2316 unsigned _M_is_leap_second : 1 {};
2317 unsigned _M_reserved : 15 {};
2319 template<
typename _CharT,
typename _Traits,
typename _Alloc>
2320 basic_istream<_CharT, _Traits>&
2321 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2322 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2323 minutes* __offset =
nullptr);
2328 template<
typename _CharT,
typename _Traits>
2329 static int_least32_t
2330 _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
2331 ios_base::iostate& __err,
int __n)
2333 int_least32_t __val = _S_try_read_digit(__is, __err);
2334 if (__val == -1) [[unlikely]]
2335 __err |= ios_base::failbit;
2340 for (
int __i = 1; __i < __n1; ++__i)
2341 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2347 while (__n1++ < __n) [[unlikely]]
2348 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2350 if (__builtin_mul_overflow(__val, 10, &__val)
2351 || __builtin_add_overflow(__val, __dig, &__val))
2353 __err |= ios_base::failbit;
2363 template<
typename _CharT,
typename _Traits>
2364 static int_least32_t
2365 _S_read_signed(basic_istream<_CharT, _Traits>& __is,
2366 ios_base::iostate& __err,
int __n)
2368 auto __sign = __is.peek();
2369 if (__sign ==
'-' || __sign ==
'+')
2371 int_least32_t __val = _S_read_unsigned(__is, __err, __n);
2372 if (__err & ios_base::failbit)
2374 if (__sign ==
'-') [[unlikely]]
2382 template<
typename _CharT,
typename _Traits>
2383 static int_least32_t
2384 _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
2385 ios_base::iostate& __err)
2387 int_least32_t __val = -1;
2388 auto __i = __is.peek();
2389 if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
2391 _CharT __c = _Traits::to_char_type(__i);
2392 if (_CharT(
'0') <= __c && __c <= _CharT(
'9')) [[likely]]
2395 __val = __c - _CharT(
'0');
2399 __err |= ios_base::eofbit;
2405 template<
typename _CharT,
typename _Traits>
2407 _S_read_chr(basic_istream<_CharT, _Traits>& __is,
2408 ios_base::iostate& __err, _CharT __c)
2410 auto __i = __is.peek();
2411 if (_Traits::eq_int_type(__i, _Traits::eof()))
2412 __err |= ios_base::eofbit;
2413 else if (_Traits::to_char_type(__i) == __c) [[likely]]
2418 __err |= ios_base::failbit;
2423 template<
typename _Duration>
2424 using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;
2426 template<
typename _Duration>
2430 if constexpr (_Duration::period::den == 1)
2432 switch (_Duration::period::num)
2434 case minutes::period::num:
2435 case hours::period::num:
2436 case days::period::num:
2437 case weeks::period::num:
2438 case years::period::num:
2455 template<
typename _ToDur,
typename _Tp>
2457 __round(
const _Tp& __t)
2459 if constexpr (__is_duration_v<_Tp>)
2461 if constexpr (treat_as_floating_point_v<typename _Tp::rep>)
2463 else if constexpr (__detail::__use_floor<_ToDur>())
2470 static_assert(__is_time_point_v<_Tp>);
2471 using _Tpt = time_point<typename _Tp::clock, _ToDur>;
2472 return _Tpt(__detail::__round<_ToDur>(__t.time_since_epoch()));
2479 template<
typename _CharT,
typename _Traits,
typename _Rep,
typename _Period,
2480 typename _Alloc = allocator<_CharT>>
2481 inline basic_istream<_CharT, _Traits>&
2482 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2484 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2487 auto __need = __format::_ChronoParts::_TimeOfDay;
2488 __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
2489 if (__p(__is, __fmt, __abbrev, __offset))
2490 __d = __detail::__round<duration<_Rep, _Period>>(__p._M_time);
2494 template<
typename _CharT,
typename _Traits>
2495 inline basic_ostream<_CharT, _Traits>&
2496 operator<<(basic_ostream<_CharT, _Traits>& __os,
const day& __d)
2498 using _Ctx = __format::__format_context<_CharT>;
2499 using _Str = basic_string_view<_CharT>;
2500 _Str __s = _GLIBCXX_WIDEN(
"{:02d} is not a valid day");
2502 __s = __s.substr(0, 6);
2503 auto __u = (unsigned)__d;
2504 __os << std::vformat(__s, make_format_args<_Ctx>(__u));
2508 template<
typename _CharT,
typename _Traits,
2509 typename _Alloc = allocator<_CharT>>
2510 inline basic_istream<_CharT, _Traits>&
2511 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2513 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2516 __detail::_Parser<> __p(__format::_ChronoParts::_Day);
2517 if (__p(__is, __fmt, __abbrev, __offset))
2518 __d = __p._M_ymd.day();
2522 template<
typename _CharT,
typename _Traits>
2523 inline basic_ostream<_CharT, _Traits>&
2524 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month& __m)
2526 using _Ctx = __format::__format_context<_CharT>;
2527 using _Str = basic_string_view<_CharT>;
2528 _Str __s = _GLIBCXX_WIDEN(
"{:L%b}{} is not a valid month");
2530 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
2531 make_format_args<_Ctx>(__m));
2534 auto __u = (unsigned)__m;
2535 __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
2540 template<
typename _CharT,
typename _Traits,
2541 typename _Alloc = allocator<_CharT>>
2542 inline basic_istream<_CharT, _Traits>&
2543 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2545 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2548 __detail::_Parser<> __p(__format::_ChronoParts::_Month);
2549 if (__p(__is, __fmt, __abbrev, __offset))
2550 __m = __p._M_ymd.month();
2554 template<
typename _CharT,
typename _Traits>
2555 inline basic_ostream<_CharT, _Traits>&
2556 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year& __y)
2558 using _Ctx = __format::__format_context<_CharT>;
2559 using _Str = basic_string_view<_CharT>;
2560 _Str __s = _GLIBCXX_WIDEN(
"-{:04d} is not a valid year");
2562 __s = __s.substr(0, 7);
2564 if (__i >= 0) [[likely]]
2565 __s.remove_prefix(1);
2568 __os << std::vformat(__s, make_format_args<_Ctx>(__i));
2572 template<
typename _CharT,
typename _Traits,
2573 typename _Alloc = allocator<_CharT>>
2574 inline basic_istream<_CharT, _Traits>&
2575 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2577 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2580 __detail::_Parser<> __p(__format::_ChronoParts::_Year);
2581 if (__p(__is, __fmt, __abbrev, __offset))
2582 __y = __p._M_ymd.year();
2586 template<
typename _CharT,
typename _Traits>
2587 inline basic_ostream<_CharT, _Traits>&
2588 operator<<(basic_ostream<_CharT, _Traits>& __os,
const weekday& __wd)
2590 using _Ctx = __format::__format_context<_CharT>;
2591 using _Str = basic_string_view<_CharT>;
2592 _Str __s = _GLIBCXX_WIDEN(
"{:L%a}{} is not a valid weekday");
2594 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
2595 make_format_args<_Ctx>(__wd));
2598 auto __c = __wd.c_encoding();
2599 __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
2604 template<
typename _CharT,
typename _Traits,
2605 typename _Alloc = allocator<_CharT>>
2606 inline basic_istream<_CharT, _Traits>&
2607 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2609 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2612 __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
2613 if (__p(__is, __fmt, __abbrev, __offset))
2618 template<
typename _CharT,
typename _Traits>
2619 inline basic_ostream<_CharT, _Traits>&
2620 operator<<(basic_ostream<_CharT, _Traits>& __os,
2621 const weekday_indexed& __wdi)
2626 basic_stringstream<_CharT> __os2;
2627 __os2.imbue(__os.getloc());
2628 __os2 << __wdi.weekday();
2629 const auto __i = __wdi.index();
2630 basic_string_view<_CharT> __s
2631 = _GLIBCXX_WIDEN(
"[ is not a valid index]");
2633 __os2 << std::format(_GLIBCXX_WIDEN(
"{}"), __i);
2634 if (__i >= 1 && __i <= 5)
2635 __os2 << __s.back();
2637 __os2 << __s.substr(1);
2638 __os << __os2.view();
2642 template<
typename _CharT,
typename _Traits>
2643 inline basic_ostream<_CharT, _Traits>&
2644 operator<<(basic_ostream<_CharT, _Traits>& __os,
2645 const weekday_last& __wdl)
2648 basic_stringstream<_CharT> __os2;
2649 __os2.imbue(__os.getloc());
2650 __os2 << __wdl.weekday() << _GLIBCXX_WIDEN(
"[last]");
2651 __os << __os2.view();
2655 template<
typename _CharT,
typename _Traits>
2656 inline basic_ostream<_CharT, _Traits>&
2657 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month_day& __md)
2660 basic_stringstream<_CharT> __os2;
2661 __os2.imbue(__os.getloc());
2662 __os2 << __md.month();
2663 if constexpr (is_same_v<_CharT, char>)
2667 __os2 << __md.day();
2668 __os << __os2.view();
2672 template<
typename _CharT,
typename _Traits,
2673 typename _Alloc = allocator<_CharT>>
2674 inline basic_istream<_CharT, _Traits>&
2675 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2677 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2680 using __format::_ChronoParts;
2681 auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
2682 __detail::_Parser<> __p(__need);
2683 if (__p(__is, __fmt, __abbrev, __offset))
2684 __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
2688 template<
typename _CharT,
typename _Traits>
2689 inline basic_ostream<_CharT, _Traits>&
2690 operator<<(basic_ostream<_CharT, _Traits>& __os,
2691 const month_day_last& __mdl)
2694 basic_stringstream<_CharT> __os2;
2695 __os2.imbue(__os.getloc());
2696 __os2 << __mdl.month() << _GLIBCXX_WIDEN(
"/last");
2697 __os << __os2.view();
2701 template<
typename _CharT,
typename _Traits>
2702 inline basic_ostream<_CharT, _Traits>&
2703 operator<<(basic_ostream<_CharT, _Traits>& __os,
2704 const month_weekday& __mwd)
2707 basic_stringstream<_CharT> __os2;
2708 __os2.imbue(__os.getloc());
2709 __os2 << __mwd.month();
2710 if constexpr (is_same_v<_CharT, char>)
2714 __os2 << __mwd.weekday_indexed();
2715 __os << __os2.view();
2719 template<
typename _CharT,
typename _Traits>
2720 inline basic_ostream<_CharT, _Traits>&
2721 operator<<(basic_ostream<_CharT, _Traits>& __os,
2722 const month_weekday_last& __mwdl)
2725 basic_stringstream<_CharT> __os2;
2726 __os2.imbue(__os.getloc());
2727 __os2 << __mwdl.month();
2728 if constexpr (is_same_v<_CharT, char>)
2732 __os2 << __mwdl.weekday_last();
2733 __os << __os2.view();
2737 template<
typename _CharT,
typename _Traits>
2738 inline basic_ostream<_CharT, _Traits>&
2739 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year_month& __ym)
2742 basic_stringstream<_CharT> __os2;
2743 __os2.imbue(__os.getloc());
2744 __os2 << __ym.year();
2745 if constexpr (is_same_v<_CharT, char>)
2749 __os2 << __ym.month();
2750 __os << __os2.view();
2754 template<
typename _CharT,
typename _Traits,
2755 typename _Alloc = allocator<_CharT>>
2756 inline basic_istream<_CharT, _Traits>&
2757 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2759 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2762 using __format::_ChronoParts;
2763 auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
2764 __detail::_Parser<> __p(__need);
2765 if (__p(__is, __fmt, __abbrev, __offset))
2766 __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
2770 template<
typename _CharT,
typename _Traits>
2771 inline basic_ostream<_CharT, _Traits>&
2772 operator<<(basic_ostream<_CharT, _Traits>& __os,
2773 const year_month_day& __ymd)
2775 using _Ctx = __format::__format_context<_CharT>;
2776 using _Str = basic_string_view<_CharT>;
2777 _Str __s = _GLIBCXX_WIDEN(
"{:%F} is not a valid date");
2778 __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
2779 make_format_args<_Ctx>(__ymd));
2783 template<
typename _CharT,
typename _Traits,
2784 typename _Alloc = allocator<_CharT>>
2785 inline basic_istream<_CharT, _Traits>&
2787 year_month_day& __ymd,
2791 using __format::_ChronoParts;
2792 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2793 | _ChronoParts::_Day;
2794 __detail::_Parser<> __p(__need);
2795 if (__p(__is, __fmt, __abbrev, __offset))
2800 template<
typename _CharT,
typename _Traits>
2803 const year_month_day_last& __ymdl)
2808 __os2 << __ymdl.year();
2809 if constexpr (is_same_v<_CharT, char>)
2813 __os2 << __ymdl.month_day_last();
2814 __os << __os2.view();
2818 template<
typename _CharT,
typename _Traits>
2819 inline basic_ostream<_CharT, _Traits>&
2820 operator<<(basic_ostream<_CharT, _Traits>& __os,
2821 const year_month_weekday& __ymwd)
2825 basic_stringstream<_CharT> __os2;
2826 __os2.
imbue(__os.getloc());
2828 if constexpr (is_same_v<_CharT, char>)
2832 __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
2833 << __ymwd.weekday_indexed();
2834 __os << __os2.view();
2838 template<
typename _CharT,
typename _Traits>
2839 inline basic_ostream<_CharT, _Traits>&
2840 operator<<(basic_ostream<_CharT, _Traits>& __os,
2841 const year_month_weekday_last& __ymwdl)
2845 basic_stringstream<_CharT> __os2;
2846 __os2.imbue(__os.getloc());
2848 if constexpr (is_same_v<_CharT, char>)
2852 __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
2853 << __ymwdl.weekday_last();
2854 __os << __os2.view();
2858 template<
typename _CharT,
typename _Traits,
typename _Duration>
2859 inline basic_ostream<_CharT, _Traits>&
2860 operator<<(basic_ostream<_CharT, _Traits>& __os,
2863 return __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%T}"), __hms);
2866#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2868 template<
typename _CharT,
typename _Traits>
2869 basic_ostream<_CharT, _Traits>&
2870 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_info& __i)
2872 __os <<
'[' << __i.begin <<
',' << __i.end
2873 <<
',' <<
hh_mm_ss(__i.offset) <<
',' << __i.save
2874 <<
',' << __i.abbrev <<
']';
2879 template<
typename _CharT,
typename _Traits>
2880 basic_ostream<_CharT, _Traits>&
2881 operator<<(basic_ostream<_CharT, _Traits>& __os,
const local_info& __li)
2884 if (__li.result == local_info::unique)
2888 if (__li.result == local_info::nonexistent)
2889 __os <<
"nonexistent";
2891 __os <<
"ambiguous";
2892 __os <<
" local time between " << __li.first;
2893 __os <<
" and " << __li.second;
2899 template<
typename _CharT,
typename _Traits,
typename _Duration,
2900 typename _TimeZonePtr>
2901 inline basic_ostream<_CharT, _Traits>&
2902 operator<<(basic_ostream<_CharT, _Traits>& __os,
2903 const zoned_time<_Duration, _TimeZonePtr>& __t)
2905 __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T %Z}"), __t);
2910 template<
typename _CharT,
typename _Traits,
typename _Duration>
2911 requires (!treat_as_floating_point_v<typename _Duration::rep>)
2912 && ratio_less_v<typename _Duration::period, days::period>
2913 inline basic_ostream<_CharT, _Traits>&
2914 operator<<(basic_ostream<_CharT, _Traits>& __os,
2915 const sys_time<_Duration>& __tp)
2917 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __tp);
2921 template<
typename _CharT,
typename _Traits>
2922 inline basic_ostream<_CharT, _Traits>&
2923 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_days& __dp)
2925 __os << year_month_day{__dp};
2929 template<
typename _CharT,
typename _Traits,
typename _Duration,
2930 typename _Alloc = allocator<_CharT>>
2931 basic_istream<_CharT, _Traits>&
2932 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2933 sys_time<_Duration>& __tp,
2934 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2940 using __format::_ChronoParts;
2941 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2942 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2943 __detail::_Parser_t<_Duration> __p(__need);
2944 if (__p(__is, __fmt, __abbrev, __offset))
2946 if (__p._M_is_leap_second)
2950 auto __st = __p._M_sys_days + __p._M_time - *__offset;
2951 __tp = __detail::__round<_Duration>(__st);
2957 template<
typename _CharT,
typename _Traits,
typename _Duration>
2958 inline basic_ostream<_CharT, _Traits>&
2959 operator<<(basic_ostream<_CharT, _Traits>& __os,
2960 const utc_time<_Duration>& __t)
2962 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2966 template<
typename _CharT,
typename _Traits,
typename _Duration,
2967 typename _Alloc = allocator<_CharT>>
2968 inline basic_istream<_CharT, _Traits>&
2969 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2970 utc_time<_Duration>& __tp,
2971 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2977 using __format::_ChronoParts;
2978 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2979 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2980 __detail::_Parser_t<_Duration> __p(__need);
2981 if (__p(__is, __fmt, __abbrev, __offset))
2985 auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
2987 __tp = __detail::__round<_Duration>(__ut);
2992 template<
typename _CharT,
typename _Traits,
typename _Duration>
2993 inline basic_ostream<_CharT, _Traits>&
2994 operator<<(basic_ostream<_CharT, _Traits>& __os,
2995 const tai_time<_Duration>& __t)
2997 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3001 template<
typename _CharT,
typename _Traits,
typename _Duration,
3002 typename _Alloc = allocator<_CharT>>
3003 inline basic_istream<_CharT, _Traits>&
3004 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3005 tai_time<_Duration>& __tp,
3006 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3012 using __format::_ChronoParts;
3013 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3014 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3015 __detail::_Parser_t<_Duration> __p(__need);
3016 if (__p(__is, __fmt, __abbrev, __offset))
3018 if (__p._M_is_leap_second)
3022 constexpr sys_days __epoch(-
days(4383));
3023 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3024 tai_time<common_type_t<_Duration, seconds>> __tt(__d);
3025 __tp = __detail::__round<_Duration>(__tt);
3031 template<
typename _CharT,
typename _Traits,
typename _Duration>
3032 inline basic_ostream<_CharT, _Traits>&
3033 operator<<(basic_ostream<_CharT, _Traits>& __os,
3034 const gps_time<_Duration>& __t)
3036 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3040 template<
typename _CharT,
typename _Traits,
typename _Duration,
3041 typename _Alloc = allocator<_CharT>>
3042 inline basic_istream<_CharT, _Traits>&
3043 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3044 gps_time<_Duration>& __tp,
3045 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3051 using __format::_ChronoParts;
3052 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3053 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3054 __detail::_Parser_t<_Duration> __p(__need);
3055 if (__p(__is, __fmt, __abbrev, __offset))
3057 if (__p._M_is_leap_second)
3061 constexpr sys_days __epoch(
days(3657));
3062 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3063 gps_time<common_type_t<_Duration, seconds>> __gt(__d);
3064 __tp = __detail::__round<_Duration>(__gt);
3070 template<
typename _CharT,
typename _Traits,
typename _Duration>
3071 inline basic_ostream<_CharT, _Traits>&
3072 operator<<(basic_ostream<_CharT, _Traits>& __os,
3073 const file_time<_Duration>& __t)
3075 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3079 template<
typename _CharT,
typename _Traits,
typename _Duration,
3080 typename _Alloc = allocator<_CharT>>
3081 inline basic_istream<_CharT, _Traits>&
3082 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3083 file_time<_Duration>& __tp,
3084 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3087 sys_time<_Duration> __st;
3088 if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
3089 __tp = __detail::__round<_Duration>(file_clock::from_sys(__st));
3093 template<
typename _CharT,
typename _Traits,
typename _Duration>
3094 inline basic_ostream<_CharT, _Traits>&
3095 operator<<(basic_ostream<_CharT, _Traits>& __os,
3096 const local_time<_Duration>& __lt)
3098 __os << sys_time<_Duration>{__lt.time_since_epoch()};
3102 template<
typename _CharT,
typename _Traits,
typename _Duration,
3103 typename _Alloc = allocator<_CharT>>
3104 basic_istream<_CharT, _Traits>&
3105 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3106 local_time<_Duration>& __tp,
3107 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3110 using __format::_ChronoParts;
3111 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3112 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3113 __detail::_Parser_t<_Duration> __p(__need);
3114 if (__p(__is, __fmt, __abbrev, __offset))
3116 days __d = __p._M_sys_days.time_since_epoch();
3117 auto __t = local_days(__d) + __p._M_time;
3118 __tp = __detail::__round<_Duration>(__t);
3129 void from_stream() =
delete;
3131 template<
typename _Parsable,
typename _CharT,
3132 typename _Traits = std::char_traits<_CharT>,
3133 typename... _OptArgs>
3134 concept __parsable =
requires (basic_istream<_CharT, _Traits>& __is,
3135 const _CharT* __fmt, _Parsable& __tp,
3136 _OptArgs*... __args)
3137 { from_stream(__is, __fmt, __tp, __args...); };
3139 template<
typename _Parsable,
typename _CharT,
3140 typename _Traits = char_traits<_CharT>,
3141 typename _Alloc = allocator<_CharT>>
3145 using __string_type = basic_string<_CharT, _Traits, _Alloc>;
3148 _Parse(
const _CharT* __fmt, _Parsable& __tp,
3149 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3152 _M_abbrev(__abbrev), _M_offset(__offset)
3155 _Parse(_Parse&&) =
delete;
3156 _Parse& operator=(_Parse&&) =
delete;
3159 using __stream_type = basic_istream<_CharT, _Traits>;
3161 const _CharT*
const _M_fmt;
3162 _Parsable*
const _M_tp;
3163 __string_type*
const _M_abbrev;
3166 friend __stream_type&
3167 operator>>(__stream_type& __is, _Parse&& __p)
3170 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
3172 else if (__p._M_abbrev)
3173 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
3175 from_stream(__is, __p._M_fmt, *__p._M_tp);
3179 friend void operator>>(__stream_type&, _Parse&) =
delete;
3180 friend void operator>>(__stream_type&,
const _Parse&) =
delete;
3184 template<
typename _CharT, __detail::__parsable<_CharT> _Parsable>
3185 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3187 parse(
const _CharT* __fmt, _Parsable& __tp)
3188 {
return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }
3190 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3191 __detail::__parsable<_CharT, _Traits> _Parsable>
3194 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
3196 return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
3199 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3200 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3201 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3202 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3204 parse(
const _CharT* __fmt, _Parsable& __tp,
3205 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3208 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3212 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3213 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3214 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3217 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3218 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3221 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3225 template<
typename _CharT,
typename _Traits =
char_traits<_CharT>,
3226 typename _StrT = basic_
string<_CharT, _Traits>,
3227 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3228 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3230 parse(
const _CharT* __fmt, _Parsable& __tp,
minutes& __offset)
3232 return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp,
nullptr,
3236 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3237 typename _StrT = basic_string<_CharT, _Traits>,
3238 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3241 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3244 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3249 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3250 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3251 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3252 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3254 parse(
const _CharT* __fmt, _Parsable& __tp,
3255 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3258 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3263 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3264 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3265 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3268 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3269 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3272 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3278 template<
typename _Duration>
3279 template<
typename _CharT,
typename _Traits,
typename _Alloc>
3280 basic_istream<_CharT, _Traits>&
3281 __detail::_Parser<_Duration>::
3282 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3283 basic_string<_CharT, _Traits, _Alloc>* __abbrev,
3286 using sentry =
typename basic_istream<_CharT, _Traits>::sentry;
3288 if (sentry __cerb(__is,
true); __cerb)
3290 locale __loc = __is.getloc();
3295 struct _Stream_state
3298 _Stream_state(basic_istream<_CharT, _Traits>& __i)
3300 _M_flags(__i.flags(ios_base::
skipws | ios_base::
dec)),
3306 _M_is.flags(_M_flags);
3310 _Stream_state(_Stream_state&&) =
delete;
3312 basic_istream<_CharT, _Traits>& _M_is;
3313 ios_base::fmtflags _M_flags;
3323 auto __read_unsigned = [&] (
int __n) {
3324 return _S_read_unsigned(__is, __err, __n);
3329 auto __read_signed = [&] (
int __n) {
3330 return _S_read_signed(__is, __err, __n);
3334 auto __read_chr = [&__is, &__err] (_CharT __c) {
3335 return _S_read_chr(__is, __err, __c);
3338 using __format::_ChronoParts;
3339 _ChronoParts __parts{};
3341 const year __bad_y = --year::min();
3342 const month __bad_mon(255);
3343 const day __bad_day(255);
3344 const weekday __bad_wday(255);
3345 const hours __bad_h(-1);
3346 const minutes __bad_min(-9999);
3349 year __y = __bad_y, __yy = __bad_y;
3350 year __iso_y = __bad_y, __iso_yy = __bad_y;
3351 month __m = __bad_mon;
3352 day __d = __bad_day;
3353 weekday __wday = __bad_wday;
3354 hours __h = __bad_h, __h12 = __bad_h;
3356 _Duration __s = __bad_sec;
3358 int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1;
3360 int __dayofyear = -1;
3362 minutes __tz_offset = __bad_min;
3363 basic_string<_CharT, _Traits> __tz_abbr;
3365 if ((_M_need & _ChronoParts::_TimeOfDay)
3366 && (_M_need & _ChronoParts::_Year))
3372 __parts = _ChronoParts::_TimeOfDay;
3379 bool __is_flag =
false;
3381 constexpr bool __is_floating
3382 = treat_as_floating_point_v<typename _Duration::rep>;
3401 _CharT __c = *__fmt++;
3408 else if (!__read_chr(__c)) [[unlikely]]
3419 if (__mod || __num) [[unlikely]]
3424 __tmget.get(__is, {}, __is, __err, &__tm,
3426 if (!__is_failed(__err))
3427 __wday = weekday(__tm.tm_wday);
3429 __parts |= _ChronoParts::_Weekday;
3435 if (__mod || __num) [[unlikely]]
3443 __tmget.get(__is, {}, __is, __err, &__tm,
3445 if (!__is_failed(__err))
3446 __m = month(__tm.tm_mon + 1);
3448 __parts |= _ChronoParts::_Month;
3452 if (__mod ==
'O' || __num) [[unlikely]]
3457 __tmget.get(__is, {}, __is, __err, &__tm,
3458 __fmt - 2 - (__mod ==
'E'), __fmt);
3459 if (!__is_failed(__err))
3461 __y = year(__tm.tm_year + 1900);
3462 __m = month(__tm.tm_mon + 1);
3463 __d = day(__tm.tm_mday);
3464 __h =
hours(__tm.tm_hour);
3469 __parts |= _ChronoParts::_DateTime;
3473 if (!__mod) [[likely]]
3475 auto __v = __read_signed(__num ? __num : 2);
3476 if (!__is_failed(__err))
3478 int __cmin = (int)year::min() / 100;
3479 int __cmax = (int)year::max() / 100;
3480 if (__cmin <= __v && __v <= __cmax)
3481 __century = __v * 100;
3486 else if (__mod ==
'E')
3489 __tmget.get(__is, {}, __is, __err, &__tm,
3491 if (!__is_failed(__err))
3492 __century = __tm.tm_year;
3501 if (!__mod) [[likely]]
3503 auto __v = __read_unsigned(__num ? __num : 2);
3504 if (!__is_failed(__err))
3507 else if (__mod ==
'O')
3510 __tmget.get(__is, {}, __is, __err, &__tm,
3512 if (!__is_failed(__err))
3513 __d = day(__tm.tm_mday);
3517 __parts |= _ChronoParts::_Day;
3521 if (__mod || __num) [[unlikely]]
3525 auto __month = __read_unsigned(2);
3527 auto __day = __read_unsigned(2);
3529 auto __year = __read_unsigned(2);
3530 if (__is_failed(__err))
3532 __y = year(__year + 1900 + 100 *
int(__year < 69));
3533 __m = month(__month);
3535 if (!year_month_day(__y, __m, __d).ok())
3537 __y = __yy = __iso_y = __iso_yy = __bad_y;
3543 __parts |= _ChronoParts::_Date;
3547 if (__mod) [[unlikely]]
3551 auto __year = __read_signed(__num ? __num : 4);
3553 auto __month = __read_unsigned(2);
3555 auto __day = __read_unsigned(2);
3556 if (__is_failed(__err))
3559 __m = month(__month);
3561 if (!year_month_day(__y, __m, __d).ok())
3563 __y = __yy = __iso_y = __iso_yy = __bad_y;
3569 __parts |= _ChronoParts::_Date;
3573 if (__mod) [[unlikely]]
3577 auto __val = __read_unsigned(__num ? __num : 2);
3578 if (__val >= 0 && __val <= 99)
3580 __iso_yy = year(__val);
3581 if (__century == -1)
3585 __iso_yy = __iso_y = __y = __yy = __bad_y;
3587 __parts |= _ChronoParts::_Year;
3591 if (__mod) [[unlikely]]
3594 __iso_y = year(__read_unsigned(__num ? __num : 4));
3595 __parts |= _ChronoParts::_Year;
3600 if (__mod ==
'E') [[unlikely]]
3602 else if (__mod ==
'O')
3607 __tmget.get(__is, {}, __is, __err, &__tm,
3609 if (!__is_failed(__err))
3613 __h12 =
hours(__tm.tm_hour);
3617 __h =
hours(__tm.tm_hour);
3626 auto __val = __read_unsigned(__num ? __num : 2);
3627 if (__c ==
'I' && __val >= 1 && __val <= 12)
3629 __h12 =
hours(__val);
3632 else if (__c ==
'H' && __val >= 0 && __val <= 23)
3639 if (_M_need & _ChronoParts::_TimeOfDay)
3644 __parts |= _ChronoParts::_TimeOfDay;
3648 if (__mod) [[unlikely]]
3650 else if (_M_need == _ChronoParts::_TimeOfDay)
3652 auto __val = __read_signed(__num ? __num : 3);
3653 if (!__is_failed(__err))
3656 __parts |= _ChronoParts::_TimeOfDay;
3661 __dayofyear = __read_unsigned(__num ? __num : 3);
3668 if (__mod ==
'E') [[unlikely]]
3670 else if (__mod ==
'O')
3673 __tmget.get(__is, {}, __is, __err, &__tm,
3675 if (!__is_failed(__err))
3676 __m = month(__tm.tm_mon + 1);
3680 auto __val = __read_unsigned(__num ? __num : 2);
3681 if (__val >= 1 && __val <= 12)
3686 __parts |= _ChronoParts::_Month;
3690 if (__mod ==
'E') [[unlikely]]
3692 else if (__mod ==
'O')
3695 __tmget.get(__is, {}, __is, __err, &__tm,
3697 if (!__is_failed(__err))
3702 auto __val = __read_unsigned(__num ? __num : 2);
3703 if (0 <= __val && __val < 60)
3707 if (_M_need & _ChronoParts::_TimeOfDay)
3712 __parts |= _ChronoParts::_TimeOfDay;
3722 const _CharT* __ampms[2];
3723 __tmpunct._M_am_pm(__ampms);
3724 int __n = 0, __which = 3;
3725 while (__which != 0)
3727 auto __i = __is.peek();
3728 if (_Traits::eq_int_type(__i, _Traits::eof()))
3738 else if (__ampms[0][__n + 1] == _CharT())
3749 else if (__ampms[1][__n + 1] == _CharT())
3760 if (__which == 0 || __which == 3)
3773 __tmget.get(__is, {}, __is, __err, &__tm,
3775 if (!__is_failed(__err))
3777 __h =
hours(__tm.tm_hour);
3782 __parts |= _ChronoParts::_TimeOfDay;
3787 if (__mod || __num) [[unlikely]]
3794 auto __val = __read_unsigned(2);
3795 if (__val == -1 || __val > 23) [[unlikely]]
3797 if (_M_need & _ChronoParts::_TimeOfDay)
3801 if (!__read_chr(
':')) [[unlikely]]
3805 __val = __read_unsigned(2);
3806 if (__val == -1 || __val > 60) [[unlikely]]
3808 if (_M_need & _ChronoParts::_TimeOfDay)
3816 __parts |= _ChronoParts::_TimeOfDay;
3819 else if (!__read_chr(
':')) [[unlikely]]
3825 if (__mod ==
'E') [[unlikely]]
3827 else if (__mod ==
'O')
3830 __tmget.get(__is, {}, __is, __err, &__tm,
3832 if (!__is_failed(__err))
3835 else if constexpr (_Duration::period::den == 1
3838 auto __val = __read_unsigned(__num ? __num : 2);
3839 if (0 <= __val && __val <= 59) [[likely]]
3843 if (_M_need & _ChronoParts::_TimeOfDay)
3850 basic_stringstream<_CharT> __buf;
3851 auto __digit = _S_try_read_digit(__is, __err);
3854 __buf.put(_CharT(
'0') + __digit);
3855 __digit = _S_try_read_digit(__is, __err);
3857 __buf.put(_CharT(
'0') + __digit);
3860 auto __i = __is.peek();
3861 if (_Traits::eq_int_type(__i, _Traits::eof()))
3869 __dp = __np.decimal_point();
3871 _CharT __c = _Traits::to_char_type(__i);
3877 = hh_mm_ss<_Duration>::fractional_width;
3880 __digit = _S_try_read_digit(__is, __err);
3882 __buf.put(_CharT(
'0') + __digit);
3890 if (!__is_failed(__err)) [[likely]]
3892 long double __val{};
3893#if __cpp_lib_to_chars
3895 auto __first = __str.data();
3896 auto __last = __first + __str.size();
3900 if ((
bool)ec || ptr != __last) [[unlikely]]
3908 if constexpr (__is_floating)
3915 __parts |= _ChronoParts::_TimeOfDay;
3920 if (__mod ==
'E') [[unlikely]]
3922 else if (__mod ==
'O')
3927 __tmget.get(__is, {}, __is, __err, &__tm,
3929 if (!__is_failed(__err))
3930 __wday = weekday(__tm.tm_wday);
3937 const int __lo = __c ==
'u' ? 1 : 0;
3938 const int __hi = __lo + 6;
3939 auto __val = __read_unsigned(__num ? __num : 1);
3940 if (__lo <= __val && __val <= __hi)
3941 __wday = weekday(__val);
3944 __wday = __bad_wday;
3948 __parts |= _ChronoParts::_Weekday;
3954 if (__mod ==
'E') [[unlikely]]
3956 else if (__mod ==
'O')
3958 if (__c ==
'V') [[unlikely]]
3968 const int __lo = __c ==
'V' ? 1 : 0;
3969 const int __hi = 53;
3970 auto __val = __read_unsigned(__num ? __num : 2);
3971 if (__lo <= __val && __val <= __hi)
3976 __sunday_wk = __val;
3982 __monday_wk = __val;
3987 __iso_wk = __sunday_wk = __monday_wk = -1;
3993 if (__mod ==
'O' || __num) [[unlikely]]
3998 __tmget.get(__is, {}, __is, __err, &__tm,
3999 __fmt - 2 - (__mod ==
'E'), __fmt);
4000 if (!__is_failed(__err))
4002 __y = year(__tm.tm_year + 1900);
4003 __m = month(__tm.tm_mon + 1);
4004 __d = day(__tm.tm_mday);
4007 __parts |= _ChronoParts::_Date;
4011 if (__mod ==
'O' || __num) [[unlikely]]
4016 __tmget.get(__is, {}, __is, __err, &__tm,
4017 __fmt - 2 - (__mod ==
'E'), __fmt);
4018 if (!__is_failed(__err))
4020 __h =
hours(__tm.tm_hour);
4025 __parts |= _ChronoParts::_TimeOfDay;
4029 if (__mod) [[unlikely]]
4032 __tmget.get(__is, {}, __is, __err, &__tm,
4034 if (!__is_failed(__err))
4036 int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
4037 __yy = year(__tm.tm_year - __cent);
4038 if (__century == -1)
4044 auto __val = __read_unsigned(__num ? __num : 2);
4045 if (__val >= 0 && __val <= 99)
4048 if (__century == -1)
4049 __century = __val < 69 ? 2000 : 1900;
4052 __y = __yy = __iso_yy = __iso_y = __bad_y;
4054 __parts |= _ChronoParts::_Year;
4058 if (__mod ==
'O') [[unlikely]]
4060 else if (__mod ==
'E')
4063 __tmget.get(__is, {}, __is, __err, &__tm,
4065 if (!__is_failed(__err))
4066 __y = year(__tm.tm_year);
4070 auto __val = __read_unsigned(__num ? __num : 4);
4071 if (!__is_failed(__err))
4074 __parts |= _ChronoParts::_Year;
4078 if (__num) [[unlikely]]
4085 auto __i = __is.peek();
4086 if (_Traits::eq_int_type(__i, _Traits::eof()))
4091 _CharT __ic = _Traits::to_char_type(__i);
4092 const bool __neg = __ic == _CharT(
'-');
4093 if (__ic == _CharT(
'-') || __ic == _CharT(
'+'))
4100 __hh = __read_unsigned(2);
4105 __hh = 10 * _S_try_read_digit(__is, __err);
4106 __hh += _S_try_read_digit(__is, __err);
4109 if (__is_failed(__err))
4113 if (_Traits::eq_int_type(__i, _Traits::eof()))
4116 __tz_offset =
minutes(__hh * (__neg ? -60 : 60));
4119 __ic = _Traits::to_char_type(__i);
4121 bool __read_mm =
false;
4124 if (__ic == _GLIBCXX_WIDEN(
":")[0])
4131 else if (_CharT(
'0') <= __ic && __ic <= _CharT(
'9'))
4137 int_least32_t __mm = 0;
4140 __mm = 10 * _S_try_read_digit(__is, __err);
4141 __mm += _S_try_read_digit(__is, __err);
4144 if (!__is_failed(__err))
4146 auto __z = __hh * 60 + __mm;
4147 __tz_offset =
minutes(__neg ? -__z : __z);
4153 if (__mod || __num) [[unlikely]]
4157 basic_string_view<_CharT> __x = _GLIBCXX_WIDEN(
"_/-+");
4161 auto __i = __is.peek();
4162 if (!_Traits::eq_int_type(__i, _Traits::eof()))
4164 _CharT __a = _Traits::to_char_type(__i);
4166 || __x.find(__a) != __x.npos)
4168 __tz_abbr.push_back(__a);
4177 if (__tz_abbr.empty())
4183 if (__mod || __num) [[unlikely]]
4187 _CharT __i = __is.peek();
4188 if (_Traits::eq_int_type(__i, _Traits::eof()))
4190 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4198 if (__mod || __num) [[unlikely]]
4202 _CharT __i = __is.peek();
4203 if (_Traits::eq_int_type(__i, _Traits::eof()))
4205 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4211 if (__mod || __num) [[unlikely]]
4219 if (__mod || __num) [[unlikely]]
4228 if (_CharT(
'1') <= __c && __c <= _CharT(
'9'))
4230 if (!__mod) [[likely]]
4233 auto __end = __fmt + _Traits::length(__fmt);
4235 = __format::__parse_integer(__fmt - 1, __end);
4236 if (__ptr) [[likely]]
4247 if (__is_failed(__err)) [[unlikely]]
4257 if (__yy != __bad_y && __y == __bad_y)
4258 __y =
years(__century) + __yy;
4259 if (__iso_yy != __bad_y && __iso_y == __bad_y)
4260 __iso_y =
years(__century) + __iso_yy;
4263 bool __can_use_doy =
false;
4264 bool __can_use_iso_wk =
false;
4265 bool __can_use_sun_wk =
false;
4266 bool __can_use_mon_wk =
false;
4269 if (__y != __bad_y && __dayofyear >= 0)
4271 __can_use_doy =
true;
4272 __parts |= _ChronoParts::_Date;
4274 else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
4276 __can_use_sun_wk =
true;
4277 __parts |= _ChronoParts::_Date;
4279 else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
4281 __can_use_mon_wk =
true;
4282 __parts |= _ChronoParts::_Date;
4284 else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
4287 __can_use_iso_wk =
true;
4288 __parts |= _ChronoParts::_Date;
4291 if (__is_failed(__err)) [[unlikely]]
4293 else if (__is_flag) [[unlikely]]
4295 else if ((_M_need & __parts) == _M_need) [[likely]]
4317 const bool __need_wday = _M_need & _ChronoParts::_Weekday;
4321 const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;
4323 if (__need_wday && __wday != __bad_wday)
4325 else if (_M_need & _ChronoParts::_Date)
4329 const bool __need_ymd = !__need_wday && !__need_time;
4331 if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
4332 || (_M_need & _ChronoParts::_Month && __m == __bad_mon)
4333 || (_M_need & _ChronoParts::_Day && __d == __bad_day))
4340 if ((0 < __dayofyear && __dayofyear <= 365)
4341 || (__dayofyear == 366 && __y.is_leap()))
4344 _M_sys_days = sys_days(__y/January/1)
4345 +
days(__dayofyear - 1);
4347 _M_ymd = year_month_day(_M_sys_days);
4352 else if (__can_use_iso_wk)
4360 const sys_days __jan4(__iso_y/January/4);
4361 weekday __wd1(__jan4 -
days(3));
4362 if (__wd1 != Thursday)
4363 if (__wd1 != Wednesday || !__iso_y.is_leap())
4367 if (!__is_failed(__err)) [[likely]]
4370 sys_days __w(Thursday[1]/January/__iso_y);
4372 __w -= Thursday - Monday;
4374 __w += __wday - Monday;
4378 _M_ymd = year_month_day(_M_sys_days);
4381 else if (__can_use_sun_wk)
4384 sys_days __wk1(__y/January/Sunday[1]);
4385 _M_sys_days = __wk1 +
weeks(__sunday_wk - 1)
4386 +
days(__wday.c_encoding());
4387 _M_ymd = year_month_day(_M_sys_days);
4388 if (_M_ymd.year() != __y) [[unlikely]]
4391 else if (__can_use_mon_wk)
4394 sys_days __wk1(__y/January/Monday[1]);
4395 _M_sys_days = __wk1 +
weeks(__monday_wk - 1)
4396 +
days(__wday.c_encoding() - 1);
4397 _M_ymd = year_month_day(_M_sys_days);
4398 if (_M_ymd.year() != __y) [[unlikely]]
4410 if (_M_need & _ChronoParts::_Year)
4412 if (!__y.ok()) [[unlikely]]
4415 else if (__y == __bad_y)
4418 if (_M_need & _ChronoParts::_Month)
4420 if (!__m.ok()) [[unlikely]]
4423 else if (__m == __bad_mon)
4426 if (_M_need & _ChronoParts::_Day)
4428 if (__d < day(1) || __d > (__y/__m/last).day())
4431 else if (__d == __bad_day)
4434 if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
4437 if (__need_wday || __need_time)
4438 _M_sys_days = sys_days(_M_ymd);
4445 _M_wd = weekday(_M_sys_days);
4451 if (__h == __bad_h && __h12 != __bad_h)
4455 else if (__ampm == 2)
4456 __h = __h12 ==
hours(12) ? __h12 : __h12 +
hours(12);
4461 auto __t = _M_time.zero();
4470 if (__min != __bad_min)
4476 if (__s != __bad_sec)
4480 _M_is_leap_second = __s >=
seconds(60);
4489 if (!__is_failed(__err)) [[likely]]
4491 if (__offset && __tz_offset != __bad_min)
4492 *__offset = __tz_offset;
4493 if (__abbrev && !__tz_abbr.empty())
4501 __is.setstate(__err);
4505#undef _GLIBCXX_WIDEN
4510_GLIBCXX_END_NAMESPACE_VERSION
__detail::__local_time_fmt< _Duration > local_time_format(local_time< _Duration > __time, const string *__abbrev=nullptr, const seconds *__offset_sec=nullptr)
duration< int64_t, ratio< 604800 > > weeks
weeks
constexpr __enable_if_is_duration< _ToDur > floor(const duration< _Rep, _Period > &__d)
constexpr enable_if_t< __and_< __is_duration< _ToDur >, __not_< treat_as_floating_point< typename _ToDur::rep > > >::value, _ToDur > round(const duration< _Rep, _Period > &__d)
duration< int64_t, ratio< 86400 > > days
days
duration< int64_t, ratio< 31556952 > > years
years
duration< int64_t, ratio< 3600 > > hours
hours
duration< int64_t, ratio< 60 > > minutes
minutes
basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const duration< _Rep, _Period > &__d)
duration< int64_t > seconds
seconds
constexpr __enable_if_is_duration< _ToDur > duration_cast(const duration< _Rep, _Period > &__d)
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
const _Facet & use_facet(const locale &__loc)
Return a facet.
ISO C++ entities toplevel namespace is std.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
chars_format
floating-point format for primitive numerical conversion
bool isspace(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::space, __c).
_CharT toupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.toupper(__c).
bool isalnum(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::alnum, __c).
ios_base & dec(ios_base &__base)
Calls base.setf(ios_base::dec, ios_base::basefield).
ios_base & skipws(ios_base &__base)
Calls base.setf(ios_base::skipws).
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
basic_istream< _CharT, _Traits > & ws(basic_istream< _CharT, _Traits > &__is)
Quick and easy way to eat whitespace.
constexpr from_chars_result from_chars(const char *__first, const char *__last, _Tp &__value, int __base=10)
std::from_chars for integral types.
ISO C++ 2011 namespace for date and time utilities.
locale imbue(const locale &__loc)
Moves to a new locale.
Template class basic_istream.
Template class basic_ostream.
Controlling output for std::string.
Controlling input and output for std::string.
Provides output iterator semantics for streambufs.
Provides compile-time rational arithmetic.
A non-owning reference to a string.
Managing sequences of characters and character-like objects.
constexpr iterator begin() noexcept
chrono::duration represents a distance between two points in time
_Ios_Iostate iostate
This is a bitmask type.
streamsize precision() const
Flags access.
fmtflags flags() const
Access to format flags.
static const iostate eofbit
Indicates that an input operation reached the end of an input sequence.
static const iostate goodbit
Indicates all is well.
locale getloc() const
Locale access.
static const iostate failbit
Indicates that an input operation failed to read the expected characters, or that an output operation...
static const locale & classic()
Return reference to the C locale.