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
65 template<
typename _CharT>
67 _Widen(
const char* __narrow,
const wchar_t* __wide)
69 if constexpr (is_same_v<_CharT, wchar_t>)
74#define _GLIBCXX_WIDEN_(C, S) ::std::chrono::__detail::_Widen<C>(S, L##S)
75#define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
77 template<
typename _Period,
typename _CharT>
79 __units_suffix()
noexcept
84#define _GLIBCXX_UNITS_SUFFIX(period, suffix) \
85 if constexpr (is_same_v<_Period, period>) \
86 return _GLIBCXX_WIDEN(suffix); \
89 _GLIBCXX_UNITS_SUFFIX(atto,
"as")
90 _GLIBCXX_UNITS_SUFFIX(femto,
"fs")
91 _GLIBCXX_UNITS_SUFFIX(pico,
"ps")
92 _GLIBCXX_UNITS_SUFFIX(nano,
"ns")
93 _GLIBCXX_UNITS_SUFFIX(milli,
"ms")
94#if _GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX
97 _GLIBCXX_UNITS_SUFFIX(micro,
"\u00b5s")
99 _GLIBCXX_UNITS_SUFFIX(micro,
"us")
101 _GLIBCXX_UNITS_SUFFIX(centi,
"cs")
102 _GLIBCXX_UNITS_SUFFIX(deci,
"ds")
103 _GLIBCXX_UNITS_SUFFIX(
ratio<1>,
"s")
104 _GLIBCXX_UNITS_SUFFIX(deca,
"das")
105 _GLIBCXX_UNITS_SUFFIX(hecto,
"hs")
106 _GLIBCXX_UNITS_SUFFIX(kilo,
"ks")
107 _GLIBCXX_UNITS_SUFFIX(mega,
"Ms")
108 _GLIBCXX_UNITS_SUFFIX(giga,
"Gs")
109 _GLIBCXX_UNITS_SUFFIX(tera,
"Ts")
110 _GLIBCXX_UNITS_SUFFIX(tera,
"Ts")
111 _GLIBCXX_UNITS_SUFFIX(peta,
"Ps")
112 _GLIBCXX_UNITS_SUFFIX(exa,
"Es")
116#undef _GLIBCXX_UNITS_SUFFIX
120 template<
typename _Period,
typename _CharT,
typename _Out>
122 __fmt_units_suffix(_Out __out)
noexcept
124 if (
auto __s = __detail::__units_suffix<_Period, _CharT>(); __s.size())
125 return __format::__write(
std::move(__out), __s);
126 else if constexpr (_Period::den == 1)
127 return std::format_to(
std::move(__out), _GLIBCXX_WIDEN(
"[{}]s"),
128 (uintmax_t)_Period::num);
130 return std::format_to(
std::move(__out), _GLIBCXX_WIDEN(
"[{}/{}]s"),
131 (uintmax_t)_Period::num,
132 (uintmax_t)_Period::den);
141 template<
typename _CharT,
typename _Traits,
142 typename _Rep,
typename _Period>
148 using period =
typename _Period::type;
156 __detail::__fmt_units_suffix<period, _CharT>(_Out(__s));
166 template<
typename _Duration>
167 struct __local_time_fmt
170 const string* _M_abbrev;
176 template<
typename _Duration>
177 using __local_time_fmt_for
178 = __local_time_fmt<common_type_t<_Duration, seconds>>;
191 template<
typename _Duration>
192 inline __detail::__local_time_fmt<_Duration>
194 const string* __abbrev =
nullptr,
195 const seconds* __offset_sec =
nullptr)
196 {
return {__time, __abbrev, __offset_sec}; }
204 [[noreturn,__gnu__::__always_inline__]]
206 __no_timezone_available()
207 { __throw_format_error(
"format error: no timezone available for %Z or %z"); }
209 [[noreturn,__gnu__::__always_inline__]]
211 __not_valid_for_duration()
212 { __throw_format_error(
"format error: chrono-format-spec not valid for "
213 "chrono::duration"); }
215 [[noreturn,__gnu__::__always_inline__]]
217 __invalid_chrono_spec()
218 { __throw_format_error(
"format error: chrono-format-spec not valid for "
221 template<
typename _CharT>
222 struct _ChronoSpec : _Spec<_CharT>
224 basic_string_view<_CharT> _M_chrono_specs;
233 _M_locale_specific() const noexcept
234 {
return this->_M_reserved; }
237 _M_locale_specific(
bool __b)
noexcept
238 { this->_M_reserved = __b; }
245 _Year = 1, _Month = 2, _Day = 4, _Weekday = 8, _TimeOfDay = 16,
247 _Date = _Year | _Month | _Day | _Weekday,
248 _DateTime = _Date | _TimeOfDay,
249 _ZonedDateTime = _DateTime | _TimeZone,
253 constexpr _ChronoParts
254 operator|(_ChronoParts __x, _ChronoParts __y)
noexcept
255 {
return static_cast<_ChronoParts
>((int)__x | (
int)__y); }
257 constexpr _ChronoParts&
258 operator|=(_ChronoParts& __x, _ChronoParts __y)
noexcept
259 {
return __x = __x | __y; }
262 template<
typename _CharT>
263 struct __formatter_chrono
265 using __string_view = basic_string_view<_CharT>;
266 using __string = basic_string<_CharT>;
268 template<
typename _ParseContext>
269 constexpr typename _ParseContext::iterator
270 _M_parse(_ParseContext& __pc, _ChronoParts __parts)
272 auto __first = __pc.
begin();
273 auto __last = __pc.end();
275 _ChronoSpec<_CharT> __spec{};
277 auto __finalize = [
this, &__spec] {
281 auto __finished = [&] {
282 if (__first == __last || *__first ==
'}')
293 __first = __spec._M_parse_fill_and_align(__first, __last);
297 __first = __spec._M_parse_width(__first, __last, __pc);
301 if (__parts & _ChronoParts::_Duration)
303 __first = __spec._M_parse_precision(__first, __last, __pc);
308 __first = __spec._M_parse_locale(__first, __last);
315 __string_view __str(__first, __last - __first);
316 auto __end = __str.find(
'}');
317 if (__end != __str.npos)
319 __str.remove_suffix(__str.length() - __end);
320 __last = __first + __end;
322 if (__str.find(
'{') != __str.npos)
323 __throw_format_error(
"chrono format error: '{' in chrono-specs");
330 const auto __chrono_specs = __first++;
331 if (*__chrono_specs !=
'%')
332 __throw_format_error(
"chrono format error: no '%' at start of "
338 bool __locale_specific =
false;
340 while (__first != __last)
342 enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
343 _Mods __allowed_mods = _Mod_none;
345 _CharT __c = *__first++;
351 __locale_specific =
true;
357 __locale_specific =
true;
360 __needed = _DateTime;
361 __allowed_mods = _Mod_E;
362 __locale_specific =
true;
366 __allowed_mods = _Mod_E;
371 __allowed_mods = _Mod_O;
383 __needed = _TimeOfDay;
384 __allowed_mods = _Mod_O;
387 if (!(__parts & _Duration))
392 __allowed_mods = _Mod_O;
395 __needed = _TimeOfDay;
396 __allowed_mods = _Mod_O;
400 __locale_specific =
true;
404 __needed = _TimeOfDay;
408 __needed = _Duration;
411 __needed = _TimeOfDay;
412 __allowed_mods = _Mod_O;
417 __allowed_mods = _Mod_O;
423 __allowed_mods = _Mod_O;
427 __locale_specific =
true;
428 __allowed_mods = _Mod_E;
431 __needed = _TimeOfDay;
432 __locale_specific =
true;
433 __allowed_mods = _Mod_E;
437 __allowed_mods = _Mod_E_O;
441 __allowed_mods = _Mod_E;
444 __needed = _TimeZone;
445 __allowed_mods = _Mod_E_O;
448 __needed = _TimeZone;
456 if (__mod) [[unlikely]]
458 __allowed_mods = _Mod_none;
464 __throw_format_error(
"chrono format error: invalid "
465 " specifier in chrono-specs");
468 if ((__mod ==
'E' && !(__allowed_mods & _Mod_E))
469 || (__mod ==
'O' && !(__allowed_mods & _Mod_O)))
470 __throw_format_error(
"chrono format error: invalid "
471 " modifier in chrono-specs");
472 if (__mod && __c !=
'z')
473 __locale_specific =
true;
476 if ((__parts & __needed) != __needed)
477 __throw_format_error(
"chrono format error: format argument "
478 "does not contain the information "
479 "required by the chrono-specs");
482 size_t __pos = __string_view(__first, __last - __first).find(
'%');
487 if (__pos == __string_view::npos)
493 __first += __pos + 1;
498 if (__conv || __mod != _CharT())
499 __throw_format_error(
"chrono format error: unescaped '%' in "
503 _M_spec._M_chrono_specs
504 = __string_view(__chrono_specs, __first - __chrono_specs);
505 _M_spec._M_locale_specific(__locale_specific);
515 template<
typename _Tp,
typename _FormatContext>
516 typename _FormatContext::iterator
517 _M_format(
const _Tp& __t, _FormatContext& __fc,
518 bool __is_neg =
false)
const
520 auto __first = _M_spec._M_chrono_specs.begin();
521 const auto __last = _M_spec._M_chrono_specs.end();
522 if (__first == __last)
523 return _M_format_to_ostream(__t, __fc, __is_neg);
525#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
529 if constexpr (is_same_v<_CharT, char>)
530 if constexpr (__unicode::__literal_encoding_is_utf8())
531 if (_M_spec._M_localized && _M_spec._M_locale_specific())
533 extern locale __with_encoding_conversion(
const locale&);
537 locale __loc = __fc.locale();
538 if (__loc != locale::classic())
539 __fc._M_loc = __with_encoding_conversion(__loc);
543 _Sink_iter<_CharT> __out;
544 __format::_Str_sink<_CharT> __sink;
545 bool __write_direct =
false;
546 if constexpr (is_same_v<
typename _FormatContext::iterator,
549 if (_M_spec._M_width_kind == __format::_WP_none)
552 __write_direct =
true;
555 __out = __sink.out();
558 __out = __sink.out();
562 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
563 __is_neg = __t.is_negative();
565 auto __print_sign = [&__is_neg, &__out] {
566 if constexpr (chrono::__is_duration_v<_Tp>
567 || __is_specialization_of<_Tp, chrono::hh_mm_ss>)
570 *__out++ = _S_plus_minus[1];
577 constexpr const _CharT* __literals = _GLIBCXX_WIDEN(
"\n\t%");
584 _CharT __c = *__first++;
589 __out = _M_a_A(__t,
std::move(__out), __fc, __c ==
'A');
594 __out = _M_b_B(__t,
std::move(__out), __fc, __c ==
'B');
597 __out = _M_c(__t,
std::move(__out), __fc, __mod ==
'E');
602 __out = _M_C_y_Y(__t,
std::move(__out), __fc, __c, __mod);
606 __out = _M_d_e(__t,
std::move(__out), __fc, __c, __mod ==
'O');
609 __out = _M_D(__t,
std::move(__out), __fc);
612 __out = _M_F(__t,
std::move(__out), __fc);
616 __out = _M_g_G(__t,
std::move(__out), __fc, __c ==
'G');
620 __out = _M_H_I(__t, __print_sign(), __fc, __c, __mod ==
'O');
623 __out = _M_j(__t, __print_sign(), __fc);
626 __out = _M_m(__t,
std::move(__out), __fc, __mod ==
'O');
629 __out = _M_M(__t, __print_sign(), __fc, __mod ==
'O');
632 __out = _M_p(__t,
std::move(__out), __fc);
635 __out = _M_q(__t,
std::move(__out), __fc);
639 if constexpr (chrono::__is_duration_v<_Tp>)
642 __out = std::format_to(__print_sign(), _S_empty_spec,
645 __throw_format_error(
"chrono format error: argument is "
649 __out = _M_r(__t, __print_sign(), __fc);
653 __out = _M_R_T(__t, __print_sign(), __fc, __c ==
'T');
656 __out = _M_S(__t, __print_sign(), __fc, __mod ==
'O');
660 __out = _M_u_w(__t,
std::move(__out), __fc, __c, __mod ==
'O');
665 __out = _M_U_V_W(__t,
std::move(__out), __fc, __c,
669 __out = _M_x(__t,
std::move(__out), __fc, __mod ==
'E');
672 __out = _M_X(__t, __print_sign(), __fc, __mod ==
'E');
675 __out = _M_z(__t,
std::move(__out), __fc, (
bool)__mod);
678 __out = _M_Z(__t,
std::move(__out), __fc);
681 *__out++ = __literals[0];
684 *__out++ = __literals[1];
687 *__out++ = __literals[2];
699 __string_view __str(__first, __last - __first);
700 size_t __pos = __str.find(
'%');
705 if (__pos == __str.npos)
709 __str.remove_suffix(__str.length() - __pos);
710 __first += __pos + 1;
712 __out = __format::__write(
std::move(__out), __str);
715 while (__first != __last);
717 if constexpr (is_same_v<
typename _FormatContext::iterator,
723 return __format::__write_padded_as_spec(__str, __str.size(),
727 _ChronoSpec<_CharT> _M_spec;
731 template<
typename _FormatContext>
733 _M_locale(_FormatContext& __fc)
const
735 if (!_M_spec._M_localized)
738 return __fc.locale();
746 template<
typename _Tp,
typename _FormatContext>
747 typename _FormatContext::iterator
748 _M_format_to_ostream(
const _Tp& __t, _FormatContext& __fc,
751 using ::std::chrono::__detail::__utc_leap_second;
752 using ::std::chrono::__detail::__local_time_fmt;
754 basic_ostringstream<_CharT> __os;
755 __os.imbue(_M_locale(__fc));
757 if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
760 auto __days = chrono::floor<chrono::days>(__t._M_time);
761 __os << chrono::year_month_day(__days) <<
' '
762 << chrono::hh_mm_ss(__t._M_time - __days);
768 if (!__t._M_abbrev) [[unlikely]]
769 __format::__no_timezone_available();
770 else if constexpr (is_same_v<_CharT, char>)
771 __os <<
' ' << *__t._M_abbrev;
775 for (
char __c : *__t._M_abbrev)
782 if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
783 __os << __t._M_date <<
' ' << __t._M_time;
784 else if constexpr (chrono::__is_time_point_v<_Tp>)
791 if constexpr (is_convertible_v<_Tp, chrono::sys_days>)
792 __os << _S_date(__t);
795 auto __days = chrono::floor<chrono::days>(__t);
796 __os << chrono::year_month_day(__days) <<
' '
797 << chrono::hh_mm_ss(__t - __days);
802 if constexpr (chrono::__is_duration_v<_Tp>)
803 if (__is_neg) [[unlikely]]
804 __os << _S_plus_minus[1];
810 return __format::__write_padded_as_spec(__str, __str.size(),
814 static constexpr const _CharT* _S_chars
815 = _GLIBCXX_WIDEN(
"0123456789+-:/ {}");
816 static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
817 static constexpr _CharT _S_colon = _S_chars[12];
818 static constexpr _CharT _S_slash = _S_chars[13];
819 static constexpr _CharT _S_space = _S_chars[14];
820 static constexpr const _CharT* _S_empty_spec = _S_chars + 15;
822 template<
typename _OutIter>
824 _M_write(_OutIter __out,
const locale& __loc, __string_view __s)
const
826#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
831 if constexpr (is_same_v<_CharT, char>)
832 if constexpr (__unicode::__literal_encoding_is_utf8())
833 if (_M_spec._M_localized && _M_spec._M_locale_specific()
834 && __loc != locale::classic())
837 __locale_encoding_to_utf8(
const locale&, string_view,
void*);
839 __s = __locale_encoding_to_utf8(__loc, __s, &__buf);
842 return __format::__write(
std::move(__out), __s);
845 template<
typename _Tp,
typename _FormatContext>
846 typename _FormatContext::iterator
847 _M_a_A(
const _Tp& __t,
typename _FormatContext::iterator __out,
848 _FormatContext& __ctx,
bool __full)
const
852 chrono::weekday __wd = _S_weekday(__t);
854 __throw_format_error(
"format error: invalid weekday");
856 locale __loc = _M_locale(__ctx);
857 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
858 const _CharT* __days[7];
860 __tp._M_days(__days);
862 __tp._M_days_abbreviated(__days);
863 __string_view __str(__days[__wd.c_encoding()]);
864 return _M_write(
std::move(__out), __loc, __str);
867 template<
typename _Tp,
typename _FormatContext>
868 typename _FormatContext::iterator
869 _M_b_B(
const _Tp& __t,
typename _FormatContext::iterator __out,
870 _FormatContext& __ctx,
bool __full)
const
874 chrono::month __m = _S_month(__t);
876 __throw_format_error(
"format error: invalid month");
877 locale __loc = _M_locale(__ctx);
878 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
879 const _CharT* __months[12];
881 __tp._M_months(__months);
883 __tp._M_months_abbreviated(__months);
884 __string_view __str(__months[(
unsigned)__m - 1]);
885 return _M_write(
std::move(__out), __loc, __str);
888 template<
typename _Tp,
typename _FormatContext>
889 typename _FormatContext::iterator
890 _M_c(
const _Tp& __t,
typename _FormatContext::iterator __out,
891 _FormatContext& __ctx,
bool __mod =
false)
const
896 using namespace chrono;
897 using ::std::chrono::__detail::__utc_leap_second;
898 using ::std::chrono::__detail::__local_time_fmt;
908#ifdef _GLIBCXX_USE_STRUCT_TM_TM_ZONE
911 if constexpr (__is_time_point_v<_Tp>)
914 if constexpr (!is_same_v<typename _Tp::clock, local_t>)
915 __tm.tm_zone =
const_cast<char*
>(
"UTC");
917 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
922 __tm.tm_zone =
const_cast<char*
>(__t._M_abbrev->c_str());
925 __tm.tm_zone =
const_cast<char*
>(
"UTC");
928 auto __d = _S_days(__t);
929 using _TDays =
decltype(__d);
930 const year_month_day __ymd(__d);
931 const auto __y = __ymd.year();
932 const auto __hms = _S_hms(__t);
934 __tm.tm_year = (int)__y - 1900;
935 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
936 __tm.tm_mon = (unsigned)__ymd.month() - 1;
937 __tm.tm_mday = (unsigned)__ymd.day();
938 __tm.tm_wday = weekday(__d).c_encoding();
939 __tm.tm_hour = __hms.hours().count();
940 __tm.tm_min = __hms.minutes().count();
941 __tm.tm_sec = __hms.seconds().count();
943 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
'c',
947 template<
typename _Tp,
typename _FormatContext>
948 typename _FormatContext::iterator
949 _M_C_y_Y(
const _Tp& __t,
typename _FormatContext::iterator __out,
950 _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0)
const
960 chrono::year __y = _S_year(__t);
962 if (__mod && _M_spec._M_localized) [[unlikely]]
963 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
966 __tm.tm_year = (int)__y - 1900;
967 return _M_locale_fmt(
std::move(__out), __loc, __tm,
971 basic_string<_CharT> __s;
973 const bool __is_neg = __yi < 0;
974 __yi = __builtin_abs(__yi);
976 if (__conv ==
'Y' || __conv ==
'C')
978 int __ci = __yi / 100;
979 if (__is_neg) [[unlikely]]
981 __s.assign(1, _S_plus_minus[1]);
983 if (__conv ==
'C' && (__ci * 100) != __yi)
986 if (__ci >= 100) [[unlikely]]
988 __s += std::format(_S_empty_spec, __ci / 100);
991 __s += _S_two_digits(__ci);
994 if (__conv ==
'Y' || __conv ==
'y')
995 __s += _S_two_digits(__yi % 100);
997 return __format::__write(
std::move(__out), __string_view(__s));
1000 template<
typename _Tp,
typename _FormatContext>
1001 typename _FormatContext::iterator
1002 _M_D(
const _Tp& __t,
typename _FormatContext::iterator __out,
1003 _FormatContext&)
const
1005 auto __ymd = _S_date(__t);
1006 basic_string<_CharT> __s;
1007#if ! _GLIBCXX_USE_CXX11_ABI
1010 __s = _S_two_digits((
unsigned)__ymd.month());
1012 __s += _S_two_digits((
unsigned)__ymd.day());
1014 __s += _S_two_digits(__builtin_abs((
int)__ymd.year()) % 100);
1015 return __format::__write(
std::move(__out), __string_view(__s));
1018 template<
typename _Tp,
typename _FormatContext>
1019 typename _FormatContext::iterator
1020 _M_d_e(
const _Tp& __t,
typename _FormatContext::iterator __out,
1021 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1028 chrono::day __d = _S_day(__t);
1029 unsigned __i = (unsigned)__d;
1031 if (__mod && _M_spec._M_localized) [[unlikely]]
1032 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1036 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1040 auto __sv = _S_two_digits(__i);
1042 if (__conv == _CharT(
'e') && __i < 10)
1044 __buf[0] = _S_space;
1048 return __format::__write(
std::move(__out), __sv);
1051 template<
typename _Tp,
typename _FormatContext>
1052 typename _FormatContext::iterator
1053 _M_F(
const _Tp& __t,
typename _FormatContext::iterator __out,
1054 _FormatContext&)
const
1056 auto __ymd = _S_date(__t);
1057 auto __s = std::format(_GLIBCXX_WIDEN(
"{:04d}- - "),
1059 auto __sv = _S_two_digits((
unsigned)__ymd.month());
1060 __s[__s.size() - 5] = __sv[0];
1061 __s[__s.size() - 4] = __sv[1];
1062 __sv = _S_two_digits((
unsigned)__ymd.day());
1063 __s[__s.size() - 2] = __sv[0];
1064 __s[__s.size() - 1] = __sv[1];
1066 return __format::__write(
std::move(__out), __sv);
1069 template<
typename _Tp,
typename _FormatContext>
1070 typename _FormatContext::iterator
1071 _M_g_G(
const _Tp& __t,
typename _FormatContext::iterator __out,
1072 _FormatContext& __ctx,
bool __full)
const
1076 using namespace chrono;
1077 auto __d = _S_days(__t);
1079 __d -= (weekday(__d) - Monday) -
days(3);
1081 year __y = year_month_day(__d).year();
1082 return _M_C_y_Y(__y,
std::move(__out), __ctx,
"yY"[__full]);
1085 template<
typename _Tp,
typename _FormatContext>
1086 typename _FormatContext::iterator
1087 _M_H_I(
const _Tp& __t,
typename _FormatContext::iterator __out,
1088 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1095 const auto __hms = _S_hms(__t);
1096 int __i = __hms.hours().count();
1098 if (__mod && _M_spec._M_localized) [[unlikely]]
1099 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1103 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1107 if (__conv == _CharT(
'I'))
1114 return __format::__write(
std::move(__out), _S_two_digits(__i));
1117 template<
typename _Tp,
typename _FormatContext>
1118 typename _FormatContext::iterator
1119 _M_j(
const _Tp& __t,
typename _FormatContext::iterator __out,
1120 _FormatContext&)
const
1122 if constexpr (chrono::__is_duration_v<_Tp>)
1125 unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
1126 return std::format_to(
std::move(__out), _S_empty_spec, __d);
1131 using namespace chrono;
1132 auto __day = _S_days(__t);
1133 auto __ymd = _S_date(__t);
1137 if constexpr (is_same_v<
typename decltype(__day)::clock, local_t>)
1138 __d = __day - local_days(__ymd.year()/January/0);
1140 __d = __day - sys_days(__ymd.year()/January/0);
1141 return std::format_to(
std::move(__out), _GLIBCXX_WIDEN(
"{:03d}"),
1146 template<
typename _Tp,
typename _FormatContext>
1147 typename _FormatContext::iterator
1148 _M_m(
const _Tp& __t,
typename _FormatContext::iterator __out,
1149 _FormatContext& __ctx,
bool __mod)
const
1154 auto __m = _S_month(__t);
1155 auto __i = (unsigned)__m;
1157 if (__mod && _M_spec._M_localized) [[unlikely]]
1158 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1161 __tm.tm_mon = __i - 1;
1162 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1166 return __format::__write(
std::move(__out), _S_two_digits(__i));
1169 template<
typename _Tp,
typename _FormatContext>
1170 typename _FormatContext::iterator
1171 _M_M(
const _Tp& __t,
typename _FormatContext::iterator __out,
1172 _FormatContext& __ctx,
bool __mod)
const
1177 auto __m = _S_hms(__t).minutes();
1178 auto __i = __m.count();
1180 if (__mod && _M_spec._M_localized) [[unlikely]]
1181 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1185 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1189 return __format::__write(
std::move(__out), _S_two_digits(__i));
1192 template<
typename _Tp,
typename _FormatContext>
1193 typename _FormatContext::iterator
1194 _M_p(
const _Tp& __t,
typename _FormatContext::iterator __out,
1195 _FormatContext& __ctx)
const
1198 auto __hms = _S_hms(__t);
1199 locale __loc = _M_locale(__ctx);
1200 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1201 const _CharT* __ampm[2];
1202 __tp._M_am_pm(__ampm);
1203 return _M_write(
std::move(__out), __loc,
1204 __ampm[__hms.hours().count() >= 12]);
1207 template<
typename _Tp,
typename _FormatContext>
1208 typename _FormatContext::iterator
1209 _M_q(
const _Tp&,
typename _FormatContext::iterator __out,
1210 _FormatContext&)
const
1213 if constexpr (!chrono::__is_duration_v<_Tp>)
1214 __throw_format_error(
"format error: argument is not a duration");
1217 namespace __d = chrono::__detail;
1218 using period =
typename _Tp::period;
1219 return __d::__fmt_units_suffix<period, _CharT>(
std::move(__out));
1225 template<
typename _Tp,
typename _FormatContext>
1226 typename _FormatContext::iterator
1227 _M_r(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1228 _FormatContext& __ctx)
const
1231 auto __t = _S_floor_seconds(__tt);
1232 locale __loc = _M_locale(__ctx);
1233 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1234 const _CharT* __ampm_fmt;
1235 __tp._M_am_pm_format(&__ampm_fmt);
1236 basic_string<_CharT> __fmt(_S_empty_spec);
1237 __fmt.insert(1u, 1u, _S_colon);
1238 __fmt.insert(2u, __ampm_fmt);
1239 using _FmtStr = _Runtime_format_string<_CharT>;
1240 return _M_write(
std::move(__out), __loc,
1241 std::format(__loc, _FmtStr(__fmt), __t));
1244 template<
typename _Tp,
typename _FormatContext>
1245 typename _FormatContext::iterator
1246 _M_R_T(
const _Tp& __t,
typename _FormatContext::iterator __out,
1247 _FormatContext& __ctx,
bool __secs)
const
1251 auto __hms = _S_hms(__t);
1253 auto __s = std::format(_GLIBCXX_WIDEN(
"{:02d}:00"),
1254 __hms.hours().count());
1255 auto __sv = _S_two_digits(__hms.minutes().count());
1256 __s[__s.size() - 2] = __sv[0];
1257 __s[__s.size() - 1] = __sv[1];
1259 __out = __format::__write(
std::move(__out), __sv);
1262 *__out++ = _S_colon;
1263 __out = _M_S(__hms,
std::move(__out), __ctx);
1268 template<
typename _Tp,
typename _FormatContext>
1269 typename _FormatContext::iterator
1270 _M_S(
const _Tp& __t,
typename _FormatContext::iterator __out,
1271 _FormatContext& __ctx,
bool __mod =
false)
const
1275 auto __hms = _S_hms(__t);
1276 auto __s = __hms.seconds();
1278 if (__mod) [[unlikely]]
1280 if (_M_spec._M_localized)
1281 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1284 __tm.tm_sec = (int)__s.count();
1285 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1290 return __format::__write(
std::move(__out),
1291 _S_two_digits(__s.count()));
1294 if constexpr (__hms.fractional_width == 0)
1295 __out = __format::__write(
std::move(__out),
1296 _S_two_digits(__s.count()));
1299 locale __loc = _M_locale(__ctx);
1300 auto __ss = __hms.subseconds();
1301 using rep =
typename decltype(__ss)::rep;
1302 if constexpr (is_floating_point_v<rep>)
1304 chrono::duration<rep> __fs = __s + __ss;
1305 __out = std::format_to(
std::move(__out), __loc,
1306 _GLIBCXX_WIDEN(
"{:#0{}.{}Lf}"),
1308 3 + __hms.fractional_width,
1309 __hms.fractional_width);
1314 = use_facet<numpunct<_CharT>>(__loc);
1315 __out = __format::__write(
std::move(__out),
1316 _S_two_digits(__s.count()));
1317 *__out++ = __np.decimal_point();
1318 if constexpr (is_integral_v<rep>)
1319 __out = std::format_to(
std::move(__out),
1320 _GLIBCXX_WIDEN(
"{:0{}}"),
1322 __hms.fractional_width);
1325 auto __str = std::format(_S_empty_spec, __ss.count());
1326 __out = std::format_to(_GLIBCXX_WIDEN(
"{:0>{}s}"),
1328 __hms.fractional_width);
1337 template<
typename _Tp,
typename _FormatContext>
1338 typename _FormatContext::iterator
1339 _M_u_w(
const _Tp& __t,
typename _FormatContext::iterator __out,
1340 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1347 chrono::weekday __wd = _S_weekday(__t);
1349 if (__mod && _M_spec._M_localized) [[unlikely]]
1350 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1353 __tm.tm_wday = __wd.c_encoding();
1354 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1358 unsigned __wdi = __conv ==
'u' ? __wd.iso_encoding()
1359 : __wd.c_encoding();
1360 const _CharT __d = _S_digit(__wdi);
1361 return __format::__write(
std::move(__out), __string_view(&__d, 1));
1364 template<
typename _Tp,
typename _FormatContext>
1365 typename _FormatContext::iterator
1366 _M_U_V_W(
const _Tp& __t,
typename _FormatContext::iterator __out,
1367 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1375 using namespace chrono;
1376 auto __d = _S_days(__t);
1377 using _TDays =
decltype(__d);
1379 if (__mod && _M_spec._M_localized) [[unlikely]]
1380 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1382 const year_month_day __ymd(__d);
1383 const year __y = __ymd.year();
1385 __tm.tm_year = (int)__y - 1900;
1386 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
1387 __tm.tm_wday = weekday(__d).c_encoding();
1388 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1396 __d -= (weekday(__d) - Monday) -
days(3);
1399 __first = _TDays(year_month_day(__d).year()/January/1);
1404 if constexpr (
requires { __t.year(); })
1407 __y = year_month_day(__d).year();
1408 const weekday __weekstart = __conv ==
'U' ? Sunday : Monday;
1409 __first = _TDays(__y/January/__weekstart[1]);
1411 auto __weeks = chrono::floor<weeks>(__d - __first);
1412 __string_view __sv = _S_two_digits(__weeks.count() + 1);
1413 return __format::__write(
std::move(__out), __sv);
1416 template<
typename _Tp,
typename _FormatContext>
1417 typename _FormatContext::iterator
1418 _M_x(
const _Tp& __t,
typename _FormatContext::iterator __out,
1419 _FormatContext& __ctx,
bool __mod =
false)
const
1423 locale __loc = _M_locale(__ctx);
1424 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1425 const _CharT* __date_reps[2];
1426 __tp._M_date_formats(__date_reps);
1427 const _CharT* __rep = __date_reps[__mod];
1429 return _M_D(__t,
std::move(__out), __ctx);
1431 basic_string<_CharT> __fmt(_S_empty_spec);
1432 __fmt.insert(1u, 1u, _S_colon);
1433 __fmt.insert(2u, __rep);
1434 using _FmtStr = _Runtime_format_string<_CharT>;
1435 return _M_write(
std::move(__out), __loc,
1436 std::format(__loc, _FmtStr(__fmt), __t));
1439 template<
typename _Tp,
typename _FormatContext>
1440 typename _FormatContext::iterator
1441 _M_X(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1442 _FormatContext& __ctx,
bool __mod =
false)
const
1446 auto __t = _S_floor_seconds(__tt);
1447 locale __loc = _M_locale(__ctx);
1448 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1449 const _CharT* __time_reps[2];
1450 __tp._M_time_formats(__time_reps);
1451 const _CharT* __rep = __time_reps[__mod];
1453 return _M_R_T(__t,
std::move(__out), __ctx,
true);
1455 basic_string<_CharT> __fmt(_S_empty_spec);
1456 __fmt.insert(1u, 1u, _S_colon);
1457 __fmt.insert(2u, __rep);
1458 using _FmtStr = _Runtime_format_string<_CharT>;
1459 return _M_write(
std::move(__out), __loc,
1460 std::format(__loc, _FmtStr(__fmt), __t));
1463 template<
typename _Tp,
typename _FormatContext>
1464 typename _FormatContext::iterator
1465 _M_z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1466 _FormatContext&,
bool __mod =
false)
const
1468 using ::std::chrono::__detail::__utc_leap_second;
1469 using ::std::chrono::__detail::__local_time_fmt;
1471 auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN(
"+00:00"), 6)
1472 : __string_view(_GLIBCXX_WIDEN(
"+0000"), 5);
1474 if constexpr (chrono::__is_time_point_v<_Tp>)
1476 if constexpr (is_same_v<
typename _Tp::clock,
1477 chrono::system_clock>)
1478 return __format::__write(
std::move(__out), __utc);
1480 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1482 if (__t._M_offset_sec)
1485 basic_string<_CharT> __s;
1486 if (*__t._M_offset_sec != 0s)
1488 chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
1489 __s = _S_plus_minus[__hms.is_negative()];
1490 __s += _S_two_digits(__hms.hours().count());
1493 __s += _S_two_digits(__hms.minutes().count());
1496 return __format::__write(
std::move(__out), __sv);
1499 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1500 return __format::__write(
std::move(__out), __utc);
1502 __no_timezone_available();
1505 template<
typename _Tp,
typename _FormatContext>
1506 typename _FormatContext::iterator
1507 _M_Z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1508 _FormatContext& __ctx)
const
1510 using ::std::chrono::__detail::__utc_leap_second;
1511 using ::std::chrono::__detail::__local_time_fmt;
1513 __string_view __utc(_GLIBCXX_WIDEN(
"UTC"), 3);
1514 if constexpr (chrono::__is_time_point_v<_Tp>)
1516 if constexpr (is_same_v<
typename _Tp::clock,
1517 chrono::system_clock>)
1518 return __format::__write(
std::move(__out), __utc);
1520 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1524 string_view __sv = *__t._M_abbrev;
1525 if constexpr (is_same_v<_CharT, char>)
1526 return __format::__write(
std::move(__out), __sv);
1530 basic_string<_CharT> __ws(__sv.size(), _CharT());
1531 auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
1532 __ct.widen(__sv.begin(), __sv.end(), __ws.data());
1533 __string_view __wsv = __ws;
1534 return __format::__write(
std::move(__out), __wsv);
1538 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1539 return __format::__write(
std::move(__out), __utc);
1541 __no_timezone_available();
1548 _S_digit(
int __n)
noexcept
1551 return _GLIBCXX_WIDEN(
"0123456789999999")[__n & 0xf];
1555 static basic_string_view<_CharT>
1556 _S_two_digits(
int __n)
noexcept
1559 _GLIBCXX_WIDEN(
"0001020304050607080910111213141516171819"
1560 "2021222324252627282930313233343536373839"
1561 "4041424344454647484950515253545556575859"
1562 "6061626364656667686970717273747576777879"
1563 "8081828384858687888990919293949596979899"
1564 "9999999999999999999999999999999999999999"
1565 "9999999999999999") + 2 * (__n & 0x7f),
1573 template<
typename _Tp>
1574 static decltype(
auto)
1575 _S_hms(
const _Tp& __t)
1577 using ::std::chrono::__detail::__utc_leap_second;
1578 using ::std::chrono::__detail::__local_time_fmt;
1580 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1582 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1584 else if constexpr (chrono::__is_duration_v<_Tp>)
1585 return chrono::hh_mm_ss<_Tp>(__t);
1586 else if constexpr (chrono::__is_time_point_v<_Tp>)
1587 return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
1588 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1589 return _S_hms(__t._M_time);
1592 __invalid_chrono_spec();
1593 return chrono::hh_mm_ss<chrono::seconds>();
1598 template<
typename _Tp>
1600 _S_days(
const _Tp& __t)
1602 using namespace chrono;
1603 using ::std::chrono::__detail::__utc_leap_second;
1604 using ::std::chrono::__detail::__local_time_fmt;
1606 if constexpr (__is_time_point_v<_Tp>)
1607 return chrono::floor<days>(__t);
1608 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1610 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1611 return chrono::floor<days>(__t._M_time);
1612 else if constexpr (is_same_v<_Tp, year_month_day>
1613 || is_same_v<_Tp, year_month_day_last>
1614 || is_same_v<_Tp, year_month_weekday>
1615 || is_same_v<_Tp, year_month_weekday_last>)
1616 return sys_days(__t);
1619 if constexpr (__is_duration_v<_Tp>)
1620 __not_valid_for_duration();
1622 __invalid_chrono_spec();
1623 return chrono::sys_days();
1628 template<
typename _Tp>
1629 static chrono::year_month_day
1630 _S_date(
const _Tp& __t)
1632 if constexpr (is_same_v<_Tp, chrono::year_month_day>)
1635 return chrono::year_month_day(_S_days(__t));
1638 template<
typename _Tp>
1640 _S_day(
const _Tp& __t)
1642 using namespace chrono;
1644 if constexpr (is_same_v<_Tp, day>)
1646 else if constexpr (
requires { __t.day(); })
1649 return _S_date(__t).day();
1652 template<
typename _Tp>
1653 static chrono::month
1654 _S_month(
const _Tp& __t)
1656 using namespace chrono;
1658 if constexpr (is_same_v<_Tp, month>)
1660 else if constexpr (
requires { __t.month(); })
1663 return _S_date(__t).month();
1666 template<
typename _Tp>
1668 _S_year(
const _Tp& __t)
1670 using namespace chrono;
1672 if constexpr (is_same_v<_Tp, year>)
1674 else if constexpr (
requires { __t.year(); })
1677 return _S_date(__t).year();
1680 template<
typename _Tp>
1681 static chrono::weekday
1682 _S_weekday(
const _Tp& __t)
1685 using ::std::chrono::__detail::__local_time_fmt;
1687 if constexpr (is_same_v<_Tp, weekday>)
1689 else if constexpr (
requires { __t.weekday(); })
1691 else if constexpr (is_same_v<_Tp, month_weekday>)
1692 return __t.weekday_indexed().weekday();
1693 else if constexpr (is_same_v<_Tp, month_weekday_last>)
1694 return __t.weekday_last().weekday();
1696 return weekday(_S_days(__t));
1700 template<
typename _Tp>
1702 _S_floor_seconds(
const _Tp& __t)
1704 using chrono::__detail::__local_time_fmt;
1705 if constexpr (chrono::__is_time_point_v<_Tp>
1706 || chrono::__is_duration_v<_Tp>)
1708 if constexpr (_Tp::period::den != 1)
1709 return chrono::floor<chrono::seconds>(__t);
1713 else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1715 if constexpr (_Tp::fractional_width != 0)
1716 return chrono::floor<chrono::seconds>(__t.to_duration());
1720 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1721 return _S_floor_seconds(__t._M_time);
1728 template<
typename _Iter>
1730 _M_locale_fmt(_Iter __out,
const locale& __loc,
const struct tm& __tm,
1731 char __fmt,
char __mod)
const
1733 basic_ostringstream<_CharT> __os;
1735 const auto& __tp = use_facet<time_put<_CharT>>(__loc);
1736 __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
1738 __out = _M_write(
std::move(__out), __loc, __os.view());
1746 template<
typename _Rep,
typename _Period,
typename _CharT>
1747 requires __format::__formattable_impl<_Rep, _CharT>
1748 struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1750 constexpr typename basic_format_parse_context<_CharT>::iterator
1751 parse(basic_format_parse_context<_CharT>& __pc)
1753 using namespace __format;
1754 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1755 if constexpr (!is_floating_point_v<_Rep>)
1756 if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1757 __throw_format_error(
"format error: invalid precision for duration");
1761 template<
typename _Out>
1762 typename basic_format_context<_Out, _CharT>::iterator
1763 format(
const chrono::duration<_Rep, _Period>& __d,
1764 basic_format_context<_Out, _CharT>& __fc)
const
1766 if constexpr (numeric_limits<_Rep>::is_signed)
1767 if (__d < __d.zero()) [[unlikely]]
1769 if constexpr (is_integral_v<_Rep>)
1773 using _URep = make_unsigned_t<_Rep>;
1774 auto __ucnt = -
static_cast<_URep
>(__d.count());
1775 auto __ud = chrono::duration<_URep, _Period>(__ucnt);
1776 return _M_f._M_format(__ud, __fc,
true);
1779 return _M_f._M_format(-__d, __fc,
true);
1781 return _M_f._M_format(__d, __fc,
false);
1785 __format::__formatter_chrono<_CharT> _M_f;
1788 template<__format::__
char _CharT>
1789 struct formatter<chrono::day, _CharT>
1791 constexpr typename basic_format_parse_context<_CharT>::iterator
1792 parse(basic_format_parse_context<_CharT>& __pc)
1793 {
return _M_f._M_parse(__pc, __format::_Day); }
1795 template<
typename _Out>
1796 typename basic_format_context<_Out, _CharT>::iterator
1797 format(
const chrono::day& __t,
1798 basic_format_context<_Out, _CharT>& __fc)
const
1799 {
return _M_f._M_format(__t, __fc); }
1802 __format::__formatter_chrono<_CharT> _M_f;
1805 template<__format::__
char _CharT>
1806 struct formatter<chrono::month, _CharT>
1808 constexpr typename basic_format_parse_context<_CharT>::iterator
1809 parse(basic_format_parse_context<_CharT>& __pc)
1810 {
return _M_f._M_parse(__pc, __format::_Month); }
1812 template<
typename _Out>
1813 typename basic_format_context<_Out, _CharT>::iterator
1814 format(
const chrono::month& __t,
1815 basic_format_context<_Out, _CharT>& __fc)
const
1816 {
return _M_f._M_format(__t, __fc); }
1819 __format::__formatter_chrono<_CharT> _M_f;
1822 template<__format::__
char _CharT>
1823 struct formatter<chrono::year, _CharT>
1825 constexpr typename basic_format_parse_context<_CharT>::iterator
1826 parse(basic_format_parse_context<_CharT>& __pc)
1827 {
return _M_f._M_parse(__pc, __format::_Year); }
1829 template<
typename _Out>
1830 typename basic_format_context<_Out, _CharT>::iterator
1831 format(
const chrono::year& __t,
1832 basic_format_context<_Out, _CharT>& __fc)
const
1833 {
return _M_f._M_format(__t, __fc); }
1836 __format::__formatter_chrono<_CharT> _M_f;
1839 template<__format::__
char _CharT>
1840 struct formatter<chrono::weekday, _CharT>
1842 constexpr typename basic_format_parse_context<_CharT>::iterator
1843 parse(basic_format_parse_context<_CharT>& __pc)
1844 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1846 template<
typename _Out>
1847 typename basic_format_context<_Out, _CharT>::iterator
1848 format(
const chrono::weekday& __t,
1849 basic_format_context<_Out, _CharT>& __fc)
const
1850 {
return _M_f._M_format(__t, __fc); }
1853 __format::__formatter_chrono<_CharT> _M_f;
1856 template<__format::__
char _CharT>
1857 struct formatter<chrono::weekday_indexed, _CharT>
1859 constexpr typename basic_format_parse_context<_CharT>::iterator
1860 parse(basic_format_parse_context<_CharT>& __pc)
1861 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1863 template<
typename _Out>
1864 typename basic_format_context<_Out, _CharT>::iterator
1865 format(
const chrono::weekday_indexed& __t,
1866 basic_format_context<_Out, _CharT>& __fc)
const
1867 {
return _M_f._M_format(__t, __fc); }
1870 __format::__formatter_chrono<_CharT> _M_f;
1873 template<__format::__
char _CharT>
1874 struct formatter<chrono::weekday_last, _CharT>
1876 constexpr typename basic_format_parse_context<_CharT>::iterator
1877 parse(basic_format_parse_context<_CharT>& __pc)
1878 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1880 template<
typename _Out>
1881 typename basic_format_context<_Out, _CharT>::iterator
1882 format(
const chrono::weekday_last& __t,
1883 basic_format_context<_Out, _CharT>& __fc)
const
1884 {
return _M_f._M_format(__t, __fc); }
1887 __format::__formatter_chrono<_CharT> _M_f;
1890 template<__format::__
char _CharT>
1891 struct formatter<chrono::month_day, _CharT>
1893 constexpr typename basic_format_parse_context<_CharT>::iterator
1894 parse(basic_format_parse_context<_CharT>& __pc)
1895 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1897 template<
typename _Out>
1898 typename basic_format_context<_Out, _CharT>::iterator
1899 format(
const chrono::month_day& __t,
1900 basic_format_context<_Out, _CharT>& __fc)
const
1901 {
return _M_f._M_format(__t, __fc); }
1904 __format::__formatter_chrono<_CharT> _M_f;
1907 template<__format::__
char _CharT>
1908 struct formatter<chrono::month_day_last, _CharT>
1910 constexpr typename basic_format_parse_context<_CharT>::iterator
1911 parse(basic_format_parse_context<_CharT>& __pc)
1912 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1914 template<
typename _Out>
1915 typename basic_format_context<_Out, _CharT>::iterator
1916 format(
const chrono::month_day_last& __t,
1917 basic_format_context<_Out, _CharT>& __fc)
const
1918 {
return _M_f._M_format(__t, __fc); }
1921 __format::__formatter_chrono<_CharT> _M_f;
1924 template<__format::__
char _CharT>
1925 struct formatter<chrono::month_weekday, _CharT>
1927 constexpr typename basic_format_parse_context<_CharT>::iterator
1928 parse(basic_format_parse_context<_CharT>& __pc)
1929 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1931 template<
typename _Out>
1932 typename basic_format_context<_Out, _CharT>::iterator
1933 format(
const chrono::month_weekday& __t,
1934 basic_format_context<_Out, _CharT>& __fc)
const
1935 {
return _M_f._M_format(__t, __fc); }
1938 __format::__formatter_chrono<_CharT> _M_f;
1941 template<__format::__
char _CharT>
1942 struct formatter<chrono::month_weekday_last, _CharT>
1944 constexpr typename basic_format_parse_context<_CharT>::iterator
1945 parse(basic_format_parse_context<_CharT>& __pc)
1946 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1948 template<
typename _Out>
1949 typename basic_format_context<_Out, _CharT>::iterator
1950 format(
const chrono::month_weekday_last& __t,
1951 basic_format_context<_Out, _CharT>& __fc)
const
1952 {
return _M_f._M_format(__t, __fc); }
1955 __format::__formatter_chrono<_CharT> _M_f;
1958 template<__format::__
char _CharT>
1959 struct formatter<chrono::year_month, _CharT>
1961 constexpr typename basic_format_parse_context<_CharT>::iterator
1962 parse(basic_format_parse_context<_CharT>& __pc)
1963 {
return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }
1965 template<
typename _Out>
1966 typename basic_format_context<_Out, _CharT>::iterator
1967 format(
const chrono::year_month& __t,
1968 basic_format_context<_Out, _CharT>& __fc)
const
1969 {
return _M_f._M_format(__t, __fc); }
1972 __format::__formatter_chrono<_CharT> _M_f;
1975 template<__format::__
char _CharT>
1976 struct formatter<chrono::year_month_day, _CharT>
1978 constexpr typename basic_format_parse_context<_CharT>::iterator
1979 parse(basic_format_parse_context<_CharT>& __pc)
1980 {
return _M_f._M_parse(__pc, __format::_Date); }
1982 template<
typename _Out>
1983 typename basic_format_context<_Out, _CharT>::iterator
1984 format(
const chrono::year_month_day& __t,
1985 basic_format_context<_Out, _CharT>& __fc)
const
1986 {
return _M_f._M_format(__t, __fc); }
1989 __format::__formatter_chrono<_CharT> _M_f;
1992 template<__format::__
char _CharT>
1993 struct formatter<chrono::year_month_day_last, _CharT>
1995 constexpr typename basic_format_parse_context<_CharT>::iterator
1996 parse(basic_format_parse_context<_CharT>& __pc)
1997 {
return _M_f._M_parse(__pc, __format::_Date); }
1999 template<
typename _Out>
2000 typename basic_format_context<_Out, _CharT>::iterator
2001 format(
const chrono::year_month_day_last& __t,
2002 basic_format_context<_Out, _CharT>& __fc)
const
2003 {
return _M_f._M_format(__t, __fc); }
2006 __format::__formatter_chrono<_CharT> _M_f;
2009 template<__format::__
char _CharT>
2010 struct formatter<chrono::year_month_weekday, _CharT>
2012 constexpr typename basic_format_parse_context<_CharT>::iterator
2013 parse(basic_format_parse_context<_CharT>& __pc)
2014 {
return _M_f._M_parse(__pc, __format::_Date); }
2016 template<
typename _Out>
2017 typename basic_format_context<_Out, _CharT>::iterator
2018 format(
const chrono::year_month_weekday& __t,
2019 basic_format_context<_Out, _CharT>& __fc)
const
2020 {
return _M_f._M_format(__t, __fc); }
2023 __format::__formatter_chrono<_CharT> _M_f;
2026 template<__format::__
char _CharT>
2027 struct formatter<chrono::year_month_weekday_last, _CharT>
2029 constexpr typename basic_format_parse_context<_CharT>::iterator
2030 parse(basic_format_parse_context<_CharT>& __pc)
2031 {
return _M_f._M_parse(__pc, __format::_Date); }
2033 template<
typename _Out>
2034 typename basic_format_context<_Out, _CharT>::iterator
2035 format(
const chrono::year_month_weekday_last& __t,
2036 basic_format_context<_Out, _CharT>& __fc)
const
2037 {
return _M_f._M_format(__t, __fc); }
2040 __format::__formatter_chrono<_CharT> _M_f;
2043 template<
typename _Rep,
typename _Period, __format::__
char _CharT>
2044 struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
2046 constexpr typename basic_format_parse_context<_CharT>::iterator
2047 parse(basic_format_parse_context<_CharT>& __pc)
2048 {
return _M_f._M_parse(__pc, __format::_TimeOfDay); }
2050 template<
typename _Out>
2051 typename basic_format_context<_Out, _CharT>::iterator
2052 format(
const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
2053 basic_format_context<_Out, _CharT>& __fc)
const
2054 {
return _M_f._M_format(__t, __fc); }
2057 __format::__formatter_chrono<_CharT> _M_f;
2060#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2061 template<__format::__
char _CharT>
2062 struct formatter<chrono::sys_info, _CharT>
2064 constexpr typename basic_format_parse_context<_CharT>::iterator
2065 parse(basic_format_parse_context<_CharT>& __pc)
2066 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2068 template<
typename _Out>
2069 typename basic_format_context<_Out, _CharT>::iterator
2070 format(
const chrono::sys_info& __i,
2071 basic_format_context<_Out, _CharT>& __fc)
const
2072 {
return _M_f._M_format(__i, __fc); }
2075 __format::__formatter_chrono<_CharT> _M_f;
2078 template<__format::__
char _CharT>
2079 struct formatter<chrono::local_info, _CharT>
2081 constexpr typename basic_format_parse_context<_CharT>::iterator
2082 parse(basic_format_parse_context<_CharT>& __pc)
2083 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2085 template<
typename _Out>
2086 typename basic_format_context<_Out, _CharT>::iterator
2087 format(
const chrono::local_info& __i,
2088 basic_format_context<_Out, _CharT>& __fc)
const
2089 {
return _M_f._M_format(__i, __fc); }
2092 __format::__formatter_chrono<_CharT> _M_f;
2096 template<
typename _Duration, __format::__
char _CharT>
2097 struct formatter<chrono::sys_time<_Duration>, _CharT>
2099 constexpr typename basic_format_parse_context<_CharT>::iterator
2100 parse(basic_format_parse_context<_CharT>& __pc)
2102 auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
2103 if constexpr (!__stream_insertable)
2104 if (_M_f._M_spec._M_chrono_specs.empty())
2105 __format::__invalid_chrono_spec();
2109 template<
typename _Out>
2110 typename basic_format_context<_Out, _CharT>::iterator
2111 format(
const chrono::sys_time<_Duration>& __t,
2112 basic_format_context<_Out, _CharT>& __fc)
const
2113 {
return _M_f._M_format(__t, __fc); }
2116 static constexpr bool __stream_insertable
2117 =
requires (basic_ostream<_CharT>& __os,
2118 chrono::sys_time<_Duration> __t) { __os << __t; };
2120 __format::__formatter_chrono<_CharT> _M_f;
2123 template<
typename _Duration, __format::__
char _CharT>
2124 struct formatter<chrono::utc_time<_Duration>, _CharT>
2125 : __format::__formatter_chrono<_CharT>
2127 constexpr typename basic_format_parse_context<_CharT>::iterator
2128 parse(basic_format_parse_context<_CharT>& __pc)
2129 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2131 template<
typename _Out>
2132 typename basic_format_context<_Out, _CharT>::iterator
2133 format(
const chrono::utc_time<_Duration>& __t,
2134 basic_format_context<_Out, _CharT>& __fc)
const
2139 using chrono::__detail::__utc_leap_second;
2140 using chrono::seconds;
2141 using chrono::sys_time;
2142 using _CDur = common_type_t<_Duration, seconds>;
2143 const auto __li = chrono::get_leap_second_info(__t);
2144 sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
2145 if (!__li.is_leap_second) [[likely]]
2146 return _M_f._M_format(__s, __fc);
2148 return _M_f._M_format(__utc_leap_second(__s), __fc);
2152 friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;
2154 __format::__formatter_chrono<_CharT> _M_f;
2157 template<
typename _Duration, __format::__
char _CharT>
2158 struct formatter<chrono::tai_time<_Duration>, _CharT>
2159 : __format::__formatter_chrono<_CharT>
2161 constexpr typename basic_format_parse_context<_CharT>::iterator
2162 parse(basic_format_parse_context<_CharT>& __pc)
2163 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2165 template<
typename _Out>
2166 typename basic_format_context<_Out, _CharT>::iterator
2167 format(
const chrono::tai_time<_Duration>& __t,
2168 basic_format_context<_Out, _CharT>& __fc)
const
2175 constexpr chrono::days __tai_offset = chrono::days(4383);
2176 using _CDur = common_type_t<_Duration, chrono::days>;
2177 chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
2178 const string __abbrev(
"TAI", 3);
2179 const chrono::seconds __off = 0s;
2180 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2181 return _M_f._M_format(__lf, __fc);
2185 __format::__formatter_chrono<_CharT> _M_f;
2188 template<
typename _Duration, __format::__
char _CharT>
2189 struct formatter<chrono::gps_time<_Duration>, _CharT>
2190 : __format::__formatter_chrono<_CharT>
2192 constexpr typename basic_format_parse_context<_CharT>::iterator
2193 parse(basic_format_parse_context<_CharT>& __pc)
2194 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2196 template<
typename _Out>
2197 typename basic_format_context<_Out, _CharT>::iterator
2198 format(
const chrono::gps_time<_Duration>& __t,
2199 basic_format_context<_Out, _CharT>& __fc)
const
2206 constexpr chrono::days __gps_offset = chrono::days(3657);
2207 using _CDur = common_type_t<_Duration, chrono::days>;
2208 chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
2209 const string __abbrev(
"GPS", 3);
2210 const chrono::seconds __off = 0s;
2211 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2212 return _M_f._M_format(__lf, __fc);
2216 __format::__formatter_chrono<_CharT> _M_f;
2219 template<
typename _Duration, __format::__
char _CharT>
2220 struct formatter<chrono::file_time<_Duration>, _CharT>
2222 constexpr typename basic_format_parse_context<_CharT>::iterator
2223 parse(basic_format_parse_context<_CharT>& __pc)
2224 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2226 template<
typename _Out>
2227 typename basic_format_context<_Out, _CharT>::iterator
2228 format(
const chrono::file_time<_Duration>& __t,
2229 basic_format_context<_Out, _CharT>& __fc)
const
2231 using namespace chrono;
2232 return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __fc);
2236 __format::__formatter_chrono<_CharT> _M_f;
2239 template<
typename _Duration, __format::__
char _CharT>
2240 struct formatter<chrono::local_time<_Duration>, _CharT>
2242 constexpr typename basic_format_parse_context<_CharT>::iterator
2243 parse(basic_format_parse_context<_CharT>& __pc)
2244 {
return _M_f._M_parse(__pc, __format::_DateTime); }
2246 template<
typename _Out>
2247 typename basic_format_context<_Out, _CharT>::iterator
2248 format(
const chrono::local_time<_Duration>& __t,
2249 basic_format_context<_Out, _CharT>& __fc)
const
2250 {
return _M_f._M_format(__t, __fc); }
2253 __format::__formatter_chrono<_CharT> _M_f;
2256 template<
typename _Duration, __format::__
char _CharT>
2257 struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2259 constexpr typename basic_format_parse_context<_CharT>::iterator
2260 parse(basic_format_parse_context<_CharT>& __pc)
2261 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2263 template<
typename _Out>
2264 typename basic_format_context<_Out, _CharT>::iterator
2265 format(
const chrono::__detail::__local_time_fmt<_Duration>& __t,
2266 basic_format_context<_Out, _CharT>& __fc)
const
2267 {
return _M_f._M_format(__t, __fc,
true); }
2270 __format::__formatter_chrono<_CharT> _M_f;
2273#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2274 template<
typename _Duration,
typename _TimeZonePtr, __format::__
char _CharT>
2275 struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
2276 : formatter<chrono::__detail::__local_time_fmt_for<_Duration>, _CharT>
2278 template<
typename _Out>
2279 typename basic_format_context<_Out, _CharT>::iterator
2280 format(
const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
2281 basic_format_context<_Out, _CharT>& __fc)
const
2283 using _Ltf = chrono::__detail::__local_time_fmt_for<_Duration>;
2284 using _Base = formatter<_Ltf, _CharT>;
2285 const chrono::sys_info __info = __tp.get_info();
2286 const auto __lf = chrono::local_time_format(__tp.get_local_time(),
2289 return _Base::format(__lf, __fc);
2295 template<
typename _Duration, __format::__
char _CharT>
2296 struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
2297 : formatter<chrono::utc_time<_Duration>, _CharT>
2299 template<
typename _Out>
2300 typename basic_format_context<_Out, _CharT>::iterator
2301 format(
const chrono::__detail::__utc_leap_second<_Duration>& __t,
2302 basic_format_context<_Out, _CharT>& __fc)
const
2303 {
return this->_M_f._M_format(__t, __fc); }
2314 template<
typename _Duration = seconds>
2317 static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);
2320 _Parser(__format::_ChronoParts __need) : _M_need(__need) { }
2322 _Parser(_Parser&&) =
delete;
2323 void operator=(_Parser&&) =
delete;
2325 _Duration _M_time{};
2326 sys_days _M_sys_days{};
2327 year_month_day _M_ymd{};
2329 __format::_ChronoParts _M_need;
2330 unsigned _M_is_leap_second : 1 {};
2331 unsigned _M_reserved : 15 {};
2333 template<
typename _CharT,
typename _Traits,
typename _Alloc>
2334 basic_istream<_CharT, _Traits>&
2335 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2336 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2337 minutes* __offset =
nullptr);
2342 template<
typename _CharT,
typename _Traits>
2343 static int_least32_t
2344 _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
2345 ios_base::iostate& __err,
int __n)
2347 int_least32_t __val = _S_try_read_digit(__is, __err);
2348 if (__val == -1) [[unlikely]]
2349 __err |= ios_base::failbit;
2354 for (
int __i = 1; __i < __n1; ++__i)
2355 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2361 while (__n1++ < __n) [[unlikely]]
2362 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2364 if (__builtin_mul_overflow(__val, 10, &__val)
2365 || __builtin_add_overflow(__val, __dig, &__val))
2367 __err |= ios_base::failbit;
2377 template<
typename _CharT,
typename _Traits>
2378 static int_least32_t
2379 _S_read_signed(basic_istream<_CharT, _Traits>& __is,
2380 ios_base::iostate& __err,
int __n)
2382 auto __sign = __is.peek();
2383 if (__sign ==
'-' || __sign ==
'+')
2385 int_least32_t __val = _S_read_unsigned(__is, __err, __n);
2386 if (__err & ios_base::failbit)
2388 if (__sign ==
'-') [[unlikely]]
2396 template<
typename _CharT,
typename _Traits>
2397 static int_least32_t
2398 _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
2399 ios_base::iostate& __err)
2401 int_least32_t __val = -1;
2402 auto __i = __is.peek();
2403 if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
2405 _CharT __c = _Traits::to_char_type(__i);
2406 if (_CharT(
'0') <= __c && __c <= _CharT(
'9')) [[likely]]
2409 __val = __c - _CharT(
'0');
2413 __err |= ios_base::eofbit;
2419 template<
typename _CharT,
typename _Traits>
2421 _S_read_chr(basic_istream<_CharT, _Traits>& __is,
2422 ios_base::iostate& __err, _CharT __c)
2424 auto __i = __is.peek();
2425 if (_Traits::eq_int_type(__i, _Traits::eof()))
2426 __err |= ios_base::eofbit;
2427 else if (_Traits::to_char_type(__i) == __c) [[likely]]
2432 __err |= ios_base::failbit;
2437 template<
typename _Duration>
2438 using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;
2440 template<
typename _Duration>
2444 if constexpr (_Duration::period::den == 1)
2446 switch (_Duration::period::num)
2448 case minutes::period::num:
2449 case hours::period::num:
2450 case days::period::num:
2451 case weeks::period::num:
2452 case years::period::num:
2469 template<
typename _ToDur,
typename _Tp>
2471 __round(
const _Tp& __t)
2473 if constexpr (__is_duration_v<_Tp>)
2475 if constexpr (treat_as_floating_point_v<typename _Tp::rep>)
2476 return chrono::duration_cast<_ToDur>(__t);
2477 else if constexpr (__detail::__use_floor<_ToDur>())
2478 return chrono::floor<_ToDur>(__t);
2480 return chrono::round<_ToDur>(__t);
2484 static_assert(__is_time_point_v<_Tp>);
2485 using _Tpt = time_point<typename _Tp::clock, _ToDur>;
2486 return _Tpt(__detail::__round<_ToDur>(__t.time_since_epoch()));
2493 template<
typename _CharT,
typename _Traits,
typename _Rep,
typename _Period,
2494 typename _Alloc = allocator<_CharT>>
2495 inline basic_istream<_CharT, _Traits>&
2496 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2497 duration<_Rep, _Period>& __d,
2498 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2501 auto __need = __format::_ChronoParts::_TimeOfDay;
2502 __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
2503 if (__p(__is, __fmt, __abbrev, __offset))
2504 __d = __detail::__round<duration<_Rep, _Period>>(__p._M_time);
2508 template<
typename _CharT,
typename _Traits>
2509 inline basic_ostream<_CharT, _Traits>&
2510 operator<<(basic_ostream<_CharT, _Traits>& __os,
const day& __d)
2512 using _Ctx = __format::__format_context<_CharT>;
2513 using _Str = basic_string_view<_CharT>;
2514 _Str __s = _GLIBCXX_WIDEN(
"{:02d} is not a valid day");
2516 __s = __s.substr(0, 6);
2517 auto __u = (unsigned)__d;
2518 __os << std::vformat(__s, make_format_args<_Ctx>(__u));
2522 template<
typename _CharT,
typename _Traits,
2523 typename _Alloc = allocator<_CharT>>
2524 inline basic_istream<_CharT, _Traits>&
2525 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2527 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2530 __detail::_Parser<> __p(__format::_ChronoParts::_Day);
2531 if (__p(__is, __fmt, __abbrev, __offset))
2532 __d = __p._M_ymd.day();
2536 template<
typename _CharT,
typename _Traits>
2537 inline basic_ostream<_CharT, _Traits>&
2538 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month& __m)
2540 using _Ctx = __format::__format_context<_CharT>;
2541 using _Str = basic_string_view<_CharT>;
2542 _Str __s = _GLIBCXX_WIDEN(
"{:L%b}{} is not a valid month");
2544 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
2545 make_format_args<_Ctx>(__m));
2548 auto __u = (unsigned)__m;
2549 __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
2554 template<
typename _CharT,
typename _Traits,
2555 typename _Alloc = allocator<_CharT>>
2556 inline basic_istream<_CharT, _Traits>&
2557 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2559 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2562 __detail::_Parser<> __p(__format::_ChronoParts::_Month);
2563 if (__p(__is, __fmt, __abbrev, __offset))
2564 __m = __p._M_ymd.month();
2568 template<
typename _CharT,
typename _Traits>
2569 inline basic_ostream<_CharT, _Traits>&
2570 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year& __y)
2572 using _Ctx = __format::__format_context<_CharT>;
2573 using _Str = basic_string_view<_CharT>;
2574 _Str __s = _GLIBCXX_WIDEN(
"-{:04d} is not a valid year");
2576 __s = __s.substr(0, 7);
2578 if (__i >= 0) [[likely]]
2579 __s.remove_prefix(1);
2582 __os << std::vformat(__s, make_format_args<_Ctx>(__i));
2586 template<
typename _CharT,
typename _Traits,
2587 typename _Alloc = allocator<_CharT>>
2588 inline basic_istream<_CharT, _Traits>&
2589 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2591 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2594 __detail::_Parser<> __p(__format::_ChronoParts::_Year);
2595 if (__p(__is, __fmt, __abbrev, __offset))
2596 __y = __p._M_ymd.year();
2600 template<
typename _CharT,
typename _Traits>
2601 inline basic_ostream<_CharT, _Traits>&
2602 operator<<(basic_ostream<_CharT, _Traits>& __os,
const weekday& __wd)
2604 using _Ctx = __format::__format_context<_CharT>;
2605 using _Str = basic_string_view<_CharT>;
2606 _Str __s = _GLIBCXX_WIDEN(
"{:L%a}{} is not a valid weekday");
2608 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
2609 make_format_args<_Ctx>(__wd));
2612 auto __c = __wd.c_encoding();
2613 __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
2618 template<
typename _CharT,
typename _Traits,
2619 typename _Alloc = allocator<_CharT>>
2620 inline basic_istream<_CharT, _Traits>&
2621 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2623 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2626 __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
2627 if (__p(__is, __fmt, __abbrev, __offset))
2632 template<
typename _CharT,
typename _Traits>
2633 inline basic_ostream<_CharT, _Traits>&
2634 operator<<(basic_ostream<_CharT, _Traits>& __os,
2635 const weekday_indexed& __wdi)
2640 basic_stringstream<_CharT> __os2;
2641 __os2.imbue(__os.getloc());
2642 __os2 << __wdi.weekday();
2643 const auto __i = __wdi.index();
2644 basic_string_view<_CharT> __s
2645 = _GLIBCXX_WIDEN(
"[ is not a valid index]");
2647 __os2 << std::format(_GLIBCXX_WIDEN(
"{}"), __i);
2648 if (__i >= 1 && __i <= 5)
2649 __os2 << __s.back();
2651 __os2 << __s.substr(1);
2652 __os << __os2.view();
2656 template<
typename _CharT,
typename _Traits>
2657 inline basic_ostream<_CharT, _Traits>&
2658 operator<<(basic_ostream<_CharT, _Traits>& __os,
2659 const weekday_last& __wdl)
2662 basic_stringstream<_CharT> __os2;
2663 __os2.imbue(__os.getloc());
2664 __os2 << __wdl.weekday() << _GLIBCXX_WIDEN(
"[last]");
2665 __os << __os2.view();
2669 template<
typename _CharT,
typename _Traits>
2670 inline basic_ostream<_CharT, _Traits>&
2671 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month_day& __md)
2674 basic_stringstream<_CharT> __os2;
2675 __os2.imbue(__os.getloc());
2676 __os2 << __md.month();
2677 if constexpr (is_same_v<_CharT, char>)
2681 __os2 << __md.day();
2682 __os << __os2.view();
2686 template<
typename _CharT,
typename _Traits,
2687 typename _Alloc = allocator<_CharT>>
2688 inline basic_istream<_CharT, _Traits>&
2689 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2691 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2694 using __format::_ChronoParts;
2695 auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
2696 __detail::_Parser<> __p(__need);
2697 if (__p(__is, __fmt, __abbrev, __offset))
2698 __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
2702 template<
typename _CharT,
typename _Traits>
2703 inline basic_ostream<_CharT, _Traits>&
2704 operator<<(basic_ostream<_CharT, _Traits>& __os,
2705 const month_day_last& __mdl)
2708 basic_stringstream<_CharT> __os2;
2709 __os2.imbue(__os.getloc());
2710 __os2 << __mdl.month() << _GLIBCXX_WIDEN(
"/last");
2711 __os << __os2.view();
2715 template<
typename _CharT,
typename _Traits>
2716 inline basic_ostream<_CharT, _Traits>&
2717 operator<<(basic_ostream<_CharT, _Traits>& __os,
2718 const month_weekday& __mwd)
2721 basic_stringstream<_CharT> __os2;
2722 __os2.imbue(__os.getloc());
2723 __os2 << __mwd.month();
2724 if constexpr (is_same_v<_CharT, char>)
2728 __os2 << __mwd.weekday_indexed();
2729 __os << __os2.view();
2733 template<
typename _CharT,
typename _Traits>
2734 inline basic_ostream<_CharT, _Traits>&
2735 operator<<(basic_ostream<_CharT, _Traits>& __os,
2736 const month_weekday_last& __mwdl)
2739 basic_stringstream<_CharT> __os2;
2740 __os2.imbue(__os.getloc());
2741 __os2 << __mwdl.month();
2742 if constexpr (is_same_v<_CharT, char>)
2746 __os2 << __mwdl.weekday_last();
2747 __os << __os2.view();
2751 template<
typename _CharT,
typename _Traits>
2752 inline basic_ostream<_CharT, _Traits>&
2753 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year_month& __ym)
2756 basic_stringstream<_CharT> __os2;
2757 __os2.imbue(__os.getloc());
2758 __os2 << __ym.year();
2759 if constexpr (is_same_v<_CharT, char>)
2763 __os2 << __ym.month();
2764 __os << __os2.view();
2768 template<
typename _CharT,
typename _Traits,
2769 typename _Alloc = allocator<_CharT>>
2770 inline basic_istream<_CharT, _Traits>&
2771 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2773 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2776 using __format::_ChronoParts;
2777 auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
2778 __detail::_Parser<> __p(__need);
2779 if (__p(__is, __fmt, __abbrev, __offset))
2780 __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
2784 template<
typename _CharT,
typename _Traits>
2785 inline basic_ostream<_CharT, _Traits>&
2786 operator<<(basic_ostream<_CharT, _Traits>& __os,
2787 const year_month_day& __ymd)
2789 using _Ctx = __format::__format_context<_CharT>;
2790 using _Str = basic_string_view<_CharT>;
2791 _Str __s = _GLIBCXX_WIDEN(
"{:%F} is not a valid date");
2792 __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
2793 make_format_args<_Ctx>(__ymd));
2797 template<
typename _CharT,
typename _Traits,
2798 typename _Alloc = allocator<_CharT>>
2799 inline basic_istream<_CharT, _Traits>&
2801 year_month_day& __ymd,
2805 using __format::_ChronoParts;
2806 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2807 | _ChronoParts::_Day;
2808 __detail::_Parser<> __p(__need);
2809 if (__p(__is, __fmt, __abbrev, __offset))
2814 template<
typename _CharT,
typename _Traits>
2817 const year_month_day_last& __ymdl)
2822 __os2 << __ymdl.year();
2823 if constexpr (is_same_v<_CharT, char>)
2827 __os2 << __ymdl.month_day_last();
2828 __os << __os2.view();
2832 template<
typename _CharT,
typename _Traits>
2833 inline basic_ostream<_CharT, _Traits>&
2834 operator<<(basic_ostream<_CharT, _Traits>& __os,
2835 const year_month_weekday& __ymwd)
2839 basic_stringstream<_CharT> __os2;
2840 __os2.
imbue(__os.getloc());
2842 if constexpr (is_same_v<_CharT, char>)
2846 __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
2847 << __ymwd.weekday_indexed();
2848 __os << __os2.view();
2852 template<
typename _CharT,
typename _Traits>
2853 inline basic_ostream<_CharT, _Traits>&
2854 operator<<(basic_ostream<_CharT, _Traits>& __os,
2855 const year_month_weekday_last& __ymwdl)
2859 basic_stringstream<_CharT> __os2;
2860 __os2.imbue(__os.getloc());
2862 if constexpr (is_same_v<_CharT, char>)
2866 __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
2867 << __ymwdl.weekday_last();
2868 __os << __os2.view();
2872 template<
typename _CharT,
typename _Traits,
typename _Duration>
2873 inline basic_ostream<_CharT, _Traits>&
2874 operator<<(basic_ostream<_CharT, _Traits>& __os,
2875 const hh_mm_ss<_Duration>& __hms)
2877 return __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%T}"), __hms);
2880#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2882 template<
typename _CharT,
typename _Traits>
2883 basic_ostream<_CharT, _Traits>&
2884 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_info& __i)
2886 __os <<
'[' << __i.begin <<
',' << __i.end
2887 <<
',' << hh_mm_ss(__i.offset) <<
',' << __i.save
2888 <<
',' << __i.abbrev <<
']';
2893 template<
typename _CharT,
typename _Traits>
2894 basic_ostream<_CharT, _Traits>&
2895 operator<<(basic_ostream<_CharT, _Traits>& __os,
const local_info& __li)
2898 if (__li.result == local_info::unique)
2902 if (__li.result == local_info::nonexistent)
2903 __os <<
"nonexistent";
2905 __os <<
"ambiguous";
2906 __os <<
" local time between " << __li.first;
2907 __os <<
" and " << __li.second;
2913 template<
typename _CharT,
typename _Traits,
typename _Duration,
2914 typename _TimeZonePtr>
2915 inline basic_ostream<_CharT, _Traits>&
2916 operator<<(basic_ostream<_CharT, _Traits>& __os,
2917 const zoned_time<_Duration, _TimeZonePtr>& __t)
2919 __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T %Z}"), __t);
2924 template<
typename _CharT,
typename _Traits,
typename _Duration>
2925 requires (!treat_as_floating_point_v<typename _Duration::rep>)
2926 && ratio_less_v<typename _Duration::period, days::period>
2927 inline basic_ostream<_CharT, _Traits>&
2928 operator<<(basic_ostream<_CharT, _Traits>& __os,
2929 const sys_time<_Duration>& __tp)
2931 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __tp);
2935 template<
typename _CharT,
typename _Traits>
2936 inline basic_ostream<_CharT, _Traits>&
2937 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_days& __dp)
2939 __os << year_month_day{__dp};
2943 template<
typename _CharT,
typename _Traits,
typename _Duration,
2944 typename _Alloc = allocator<_CharT>>
2945 basic_istream<_CharT, _Traits>&
2946 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2947 sys_time<_Duration>& __tp,
2948 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2954 using __format::_ChronoParts;
2955 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2956 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2957 __detail::_Parser_t<_Duration> __p(__need);
2958 if (__p(__is, __fmt, __abbrev, __offset))
2960 if (__p._M_is_leap_second)
2964 auto __st = __p._M_sys_days + __p._M_time - *__offset;
2965 __tp = __detail::__round<_Duration>(__st);
2971 template<
typename _CharT,
typename _Traits,
typename _Duration>
2972 inline basic_ostream<_CharT, _Traits>&
2973 operator<<(basic_ostream<_CharT, _Traits>& __os,
2974 const utc_time<_Duration>& __t)
2976 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2980 template<
typename _CharT,
typename _Traits,
typename _Duration,
2981 typename _Alloc = allocator<_CharT>>
2982 inline basic_istream<_CharT, _Traits>&
2983 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2984 utc_time<_Duration>& __tp,
2985 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2991 using __format::_ChronoParts;
2992 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2993 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2994 __detail::_Parser_t<_Duration> __p(__need);
2995 if (__p(__is, __fmt, __abbrev, __offset))
2999 auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
3001 __tp = __detail::__round<_Duration>(__ut);
3006 template<
typename _CharT,
typename _Traits,
typename _Duration>
3007 inline basic_ostream<_CharT, _Traits>&
3008 operator<<(basic_ostream<_CharT, _Traits>& __os,
3009 const tai_time<_Duration>& __t)
3011 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3015 template<
typename _CharT,
typename _Traits,
typename _Duration,
3016 typename _Alloc = allocator<_CharT>>
3017 inline basic_istream<_CharT, _Traits>&
3018 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3019 tai_time<_Duration>& __tp,
3020 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3026 using __format::_ChronoParts;
3027 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3028 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3029 __detail::_Parser_t<_Duration> __p(__need);
3030 if (__p(__is, __fmt, __abbrev, __offset))
3032 if (__p._M_is_leap_second)
3036 constexpr sys_days __epoch(-
days(4383));
3037 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3038 tai_time<common_type_t<_Duration, seconds>> __tt(__d);
3039 __tp = __detail::__round<_Duration>(__tt);
3045 template<
typename _CharT,
typename _Traits,
typename _Duration>
3046 inline basic_ostream<_CharT, _Traits>&
3047 operator<<(basic_ostream<_CharT, _Traits>& __os,
3048 const gps_time<_Duration>& __t)
3050 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3054 template<
typename _CharT,
typename _Traits,
typename _Duration,
3055 typename _Alloc = allocator<_CharT>>
3056 inline basic_istream<_CharT, _Traits>&
3057 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3058 gps_time<_Duration>& __tp,
3059 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3065 using __format::_ChronoParts;
3066 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3067 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3068 __detail::_Parser_t<_Duration> __p(__need);
3069 if (__p(__is, __fmt, __abbrev, __offset))
3071 if (__p._M_is_leap_second)
3075 constexpr sys_days __epoch(
days(3657));
3076 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3077 gps_time<common_type_t<_Duration, seconds>> __gt(__d);
3078 __tp = __detail::__round<_Duration>(__gt);
3084 template<
typename _CharT,
typename _Traits,
typename _Duration>
3085 inline basic_ostream<_CharT, _Traits>&
3086 operator<<(basic_ostream<_CharT, _Traits>& __os,
3087 const file_time<_Duration>& __t)
3089 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3093 template<
typename _CharT,
typename _Traits,
typename _Duration,
3094 typename _Alloc = allocator<_CharT>>
3095 inline basic_istream<_CharT, _Traits>&
3096 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3097 file_time<_Duration>& __tp,
3098 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3101 sys_time<_Duration> __st;
3102 if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
3103 __tp = __detail::__round<_Duration>(file_clock::from_sys(__st));
3107 template<
typename _CharT,
typename _Traits,
typename _Duration>
3108 inline basic_ostream<_CharT, _Traits>&
3109 operator<<(basic_ostream<_CharT, _Traits>& __os,
3110 const local_time<_Duration>& __lt)
3112 __os << sys_time<_Duration>{__lt.time_since_epoch()};
3116 template<
typename _CharT,
typename _Traits,
typename _Duration,
3117 typename _Alloc = allocator<_CharT>>
3118 basic_istream<_CharT, _Traits>&
3119 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3120 local_time<_Duration>& __tp,
3121 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3124 using __format::_ChronoParts;
3125 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3126 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3127 __detail::_Parser_t<_Duration> __p(__need);
3128 if (__p(__is, __fmt, __abbrev, __offset))
3130 days __d = __p._M_sys_days.time_since_epoch();
3131 auto __t = local_days(__d) + __p._M_time;
3132 __tp = __detail::__round<_Duration>(__t);
3143 void from_stream() =
delete;
3145 template<
typename _Parsable,
typename _CharT,
3147 typename... _OptArgs>
3148 concept __parsable =
requires (basic_istream<_CharT, _Traits>& __is,
3149 const _CharT* __fmt, _Parsable& __tp,
3150 _OptArgs*... __args)
3151 { from_stream(__is, __fmt, __tp, __args...); };
3153 template<
typename _Parsable,
typename _CharT,
3154 typename _Traits = char_traits<_CharT>,
3155 typename _Alloc = allocator<_CharT>>
3159 using __string_type = basic_string<_CharT, _Traits, _Alloc>;
3162 _Parse(
const _CharT* __fmt, _Parsable& __tp,
3163 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3166 _M_abbrev(__abbrev), _M_offset(__offset)
3169 _Parse(_Parse&&) =
delete;
3170 _Parse& operator=(_Parse&&) =
delete;
3173 using __stream_type = basic_istream<_CharT, _Traits>;
3175 const _CharT*
const _M_fmt;
3176 _Parsable*
const _M_tp;
3177 __string_type*
const _M_abbrev;
3180 friend __stream_type&
3181 operator>>(__stream_type& __is, _Parse&& __p)
3184 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
3186 else if (__p._M_abbrev)
3187 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
3189 from_stream(__is, __p._M_fmt, *__p._M_tp);
3193 friend void operator>>(__stream_type&, _Parse&) =
delete;
3194 friend void operator>>(__stream_type&,
const _Parse&) =
delete;
3198 template<
typename _CharT, __detail::__parsable<_CharT> _Parsable>
3199 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3201 parse(
const _CharT* __fmt, _Parsable& __tp)
3202 {
return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }
3204 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3205 __detail::__parsable<_CharT, _Traits> _Parsable>
3208 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
3210 return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
3213 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3214 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3215 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3216 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3218 parse(
const _CharT* __fmt, _Parsable& __tp,
3219 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3222 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3226 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3227 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3228 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3231 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3232 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3235 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3239 template<
typename _CharT,
typename _Traits =
char_traits<_CharT>,
3240 typename _StrT = basic_
string<_CharT, _Traits>,
3241 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3242 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3244 parse(
const _CharT* __fmt, _Parsable& __tp,
minutes& __offset)
3246 return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp,
nullptr,
3250 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3251 typename _StrT = basic_string<_CharT, _Traits>,
3252 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3255 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3258 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3263 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3264 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3265 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3266 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3268 parse(
const _CharT* __fmt, _Parsable& __tp,
3269 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3272 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3277 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3278 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3279 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3282 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3283 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3286 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3292 template<
typename _Duration>
3293 template<
typename _CharT,
typename _Traits,
typename _Alloc>
3294 basic_istream<_CharT, _Traits>&
3295 __detail::_Parser<_Duration>::
3296 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3297 basic_string<_CharT, _Traits, _Alloc>* __abbrev,
3300 using sentry =
typename basic_istream<_CharT, _Traits>::sentry;
3302 if (sentry __cerb(__is,
true); __cerb)
3304 locale __loc = __is.getloc();
3305 auto& __tmget = std::use_facet<std::time_get<_CharT>>(__loc);
3306 auto& __tmpunct = std::use_facet<std::__timepunct<_CharT>>(__loc);
3309 struct _Stream_state
3312 _Stream_state(basic_istream<_CharT, _Traits>& __i)
3314 _M_flags(__i.flags(ios_base::
skipws | ios_base::
dec)),
3320 _M_is.flags(_M_flags);
3324 _Stream_state(_Stream_state&&) =
delete;
3326 basic_istream<_CharT, _Traits>& _M_is;
3327 ios_base::fmtflags _M_flags;
3337 auto __read_unsigned = [&] (
int __n) {
3338 return _S_read_unsigned(__is, __err, __n);
3343 auto __read_signed = [&] (
int __n) {
3344 return _S_read_signed(__is, __err, __n);
3348 auto __read_chr = [&__is, &__err] (_CharT __c) {
3349 return _S_read_chr(__is, __err, __c);
3352 using __format::_ChronoParts;
3353 _ChronoParts __parts{};
3355 const year __bad_y = --year::min();
3356 const month __bad_mon(255);
3357 const day __bad_day(255);
3358 const weekday __bad_wday(255);
3359 const hours __bad_h(-1);
3360 const minutes __bad_min(-9999);
3363 year __y = __bad_y, __yy = __bad_y;
3364 year __iso_y = __bad_y, __iso_yy = __bad_y;
3365 month __m = __bad_mon;
3366 day __d = __bad_day;
3367 weekday __wday = __bad_wday;
3368 hours __h = __bad_h, __h12 = __bad_h;
3370 _Duration __s = __bad_sec;
3372 int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1;
3374 int __dayofyear = -1;
3376 minutes __tz_offset = __bad_min;
3377 basic_string<_CharT, _Traits> __tz_abbr;
3379 if ((_M_need & _ChronoParts::_TimeOfDay)
3380 && (_M_need & _ChronoParts::_Year))
3386 __parts = _ChronoParts::_TimeOfDay;
3393 bool __is_flag =
false;
3395 constexpr bool __is_floating
3396 = treat_as_floating_point_v<typename _Duration::rep>;
3415 _CharT __c = *__fmt++;
3422 else if (!__read_chr(__c)) [[unlikely]]
3433 if (__mod || __num) [[unlikely]]
3438 __tmget.get(__is, {}, __is, __err, &__tm,
3440 if (!__is_failed(__err))
3441 __wday = weekday(__tm.tm_wday);
3443 __parts |= _ChronoParts::_Weekday;
3449 if (__mod || __num) [[unlikely]]
3457 __tmget.get(__is, {}, __is, __err, &__tm,
3459 if (!__is_failed(__err))
3460 __m = month(__tm.tm_mon + 1);
3462 __parts |= _ChronoParts::_Month;
3466 if (__mod ==
'O' || __num) [[unlikely]]
3471 __tmget.get(__is, {}, __is, __err, &__tm,
3472 __fmt - 2 - (__mod ==
'E'), __fmt);
3473 if (!__is_failed(__err))
3475 __y = year(__tm.tm_year + 1900);
3476 __m = month(__tm.tm_mon + 1);
3477 __d = day(__tm.tm_mday);
3478 __h =
hours(__tm.tm_hour);
3483 __parts |= _ChronoParts::_DateTime;
3487 if (!__mod) [[likely]]
3489 auto __v = __read_signed(__num ? __num : 2);
3490 if (!__is_failed(__err))
3492 int __cmin = (int)year::min() / 100;
3493 int __cmax = (int)year::max() / 100;
3494 if (__cmin <= __v && __v <= __cmax)
3495 __century = __v * 100;
3500 else if (__mod ==
'E')
3503 __tmget.get(__is, {}, __is, __err, &__tm,
3505 if (!__is_failed(__err))
3506 __century = __tm.tm_year;
3515 if (!__mod) [[likely]]
3517 auto __v = __read_unsigned(__num ? __num : 2);
3518 if (!__is_failed(__err))
3521 else if (__mod ==
'O')
3524 __tmget.get(__is, {}, __is, __err, &__tm,
3526 if (!__is_failed(__err))
3527 __d = day(__tm.tm_mday);
3531 __parts |= _ChronoParts::_Day;
3535 if (__mod || __num) [[unlikely]]
3539 auto __month = __read_unsigned(2);
3541 auto __day = __read_unsigned(2);
3543 auto __year = __read_unsigned(2);
3544 if (__is_failed(__err))
3546 __y = year(__year + 1900 + 100 *
int(__year < 69));
3547 __m = month(__month);
3549 if (!year_month_day(__y, __m, __d).ok())
3551 __y = __yy = __iso_y = __iso_yy = __bad_y;
3557 __parts |= _ChronoParts::_Date;
3561 if (__mod) [[unlikely]]
3565 auto __year = __read_signed(__num ? __num : 4);
3567 auto __month = __read_unsigned(2);
3569 auto __day = __read_unsigned(2);
3570 if (__is_failed(__err))
3573 __m = month(__month);
3575 if (!year_month_day(__y, __m, __d).ok())
3577 __y = __yy = __iso_y = __iso_yy = __bad_y;
3583 __parts |= _ChronoParts::_Date;
3587 if (__mod) [[unlikely]]
3591 auto __val = __read_unsigned(__num ? __num : 2);
3592 if (__val >= 0 && __val <= 99)
3594 __iso_yy = year(__val);
3595 if (__century == -1)
3599 __iso_yy = __iso_y = __y = __yy = __bad_y;
3601 __parts |= _ChronoParts::_Year;
3605 if (__mod) [[unlikely]]
3608 __iso_y = year(__read_unsigned(__num ? __num : 4));
3609 __parts |= _ChronoParts::_Year;
3614 if (__mod ==
'E') [[unlikely]]
3616 else if (__mod ==
'O')
3621 __tmget.get(__is, {}, __is, __err, &__tm,
3623 if (!__is_failed(__err))
3627 __h12 =
hours(__tm.tm_hour);
3631 __h =
hours(__tm.tm_hour);
3640 auto __val = __read_unsigned(__num ? __num : 2);
3641 if (__c ==
'I' && __val >= 1 && __val <= 12)
3643 __h12 =
hours(__val);
3646 else if (__c ==
'H' && __val >= 0 && __val <= 23)
3653 if (_M_need & _ChronoParts::_TimeOfDay)
3658 __parts |= _ChronoParts::_TimeOfDay;
3662 if (__mod) [[unlikely]]
3664 else if (_M_need == _ChronoParts::_TimeOfDay)
3666 auto __val = __read_signed(__num ? __num : 3);
3667 if (!__is_failed(__err))
3670 __parts |= _ChronoParts::_TimeOfDay;
3675 __dayofyear = __read_unsigned(__num ? __num : 3);
3682 if (__mod ==
'E') [[unlikely]]
3684 else if (__mod ==
'O')
3687 __tmget.get(__is, {}, __is, __err, &__tm,
3689 if (!__is_failed(__err))
3690 __m = month(__tm.tm_mon + 1);
3694 auto __val = __read_unsigned(__num ? __num : 2);
3695 if (__val >= 1 && __val <= 12)
3700 __parts |= _ChronoParts::_Month;
3704 if (__mod ==
'E') [[unlikely]]
3706 else if (__mod ==
'O')
3709 __tmget.get(__is, {}, __is, __err, &__tm,
3711 if (!__is_failed(__err))
3716 auto __val = __read_unsigned(__num ? __num : 2);
3717 if (0 <= __val && __val < 60)
3721 if (_M_need & _ChronoParts::_TimeOfDay)
3726 __parts |= _ChronoParts::_TimeOfDay;
3736 const _CharT* __ampms[2];
3737 __tmpunct._M_am_pm(__ampms);
3738 int __n = 0, __which = 3;
3739 while (__which != 0)
3741 auto __i = __is.peek();
3742 if (_Traits::eq_int_type(__i, _Traits::eof()))
3752 else if (__ampms[0][__n + 1] == _CharT())
3763 else if (__ampms[1][__n + 1] == _CharT())
3774 if (__which == 0 || __which == 3)
3787 __tmget.get(__is, {}, __is, __err, &__tm,
3789 if (!__is_failed(__err))
3791 __h =
hours(__tm.tm_hour);
3796 __parts |= _ChronoParts::_TimeOfDay;
3801 if (__mod || __num) [[unlikely]]
3808 auto __val = __read_unsigned(2);
3809 if (__val == -1 || __val > 23) [[unlikely]]
3811 if (_M_need & _ChronoParts::_TimeOfDay)
3815 if (!__read_chr(
':')) [[unlikely]]
3819 __val = __read_unsigned(2);
3820 if (__val == -1 || __val > 60) [[unlikely]]
3822 if (_M_need & _ChronoParts::_TimeOfDay)
3830 __parts |= _ChronoParts::_TimeOfDay;
3833 else if (!__read_chr(
':')) [[unlikely]]
3839 if (__mod ==
'E') [[unlikely]]
3841 else if (__mod ==
'O')
3844 __tmget.get(__is, {}, __is, __err, &__tm,
3846 if (!__is_failed(__err))
3849 else if constexpr (_Duration::period::den == 1
3852 auto __val = __read_unsigned(__num ? __num : 2);
3853 if (0 <= __val && __val <= 59) [[likely]]
3857 if (_M_need & _ChronoParts::_TimeOfDay)
3864 basic_stringstream<_CharT> __buf;
3865 auto __digit = _S_try_read_digit(__is, __err);
3868 __buf.put(_CharT(
'0') + __digit);
3869 __digit = _S_try_read_digit(__is, __err);
3871 __buf.put(_CharT(
'0') + __digit);
3874 auto __i = __is.peek();
3875 if (_Traits::eq_int_type(__i, _Traits::eof()))
3882 auto& __np = use_facet<numpunct<_CharT>>(__loc);
3883 __dp = __np.decimal_point();
3885 _CharT __c = _Traits::to_char_type(__i);
3891 = hh_mm_ss<_Duration>::fractional_width;
3894 __digit = _S_try_read_digit(__is, __err);
3896 __buf.put(_CharT(
'0') + __digit);
3904 if (!__is_failed(__err)) [[likely]]
3906 long double __val{};
3907#if __cpp_lib_to_chars
3909 auto __first = __str.data();
3910 auto __last = __first + __str.size();
3914 if ((
bool)ec || ptr != __last) [[unlikely]]
3921 duration<long double> __fs(__val);
3922 if constexpr (__is_floating)
3925 __s = chrono::round<_Duration>(__fs);
3929 __parts |= _ChronoParts::_TimeOfDay;
3934 if (__mod ==
'E') [[unlikely]]
3936 else if (__mod ==
'O')
3941 __tmget.get(__is, {}, __is, __err, &__tm,
3943 if (!__is_failed(__err))
3944 __wday = weekday(__tm.tm_wday);
3951 const int __lo = __c ==
'u' ? 1 : 0;
3952 const int __hi = __lo + 6;
3953 auto __val = __read_unsigned(__num ? __num : 1);
3954 if (__lo <= __val && __val <= __hi)
3955 __wday = weekday(__val);
3958 __wday = __bad_wday;
3962 __parts |= _ChronoParts::_Weekday;
3968 if (__mod ==
'E') [[unlikely]]
3970 else if (__mod ==
'O')
3972 if (__c ==
'V') [[unlikely]]
3982 const int __lo = __c ==
'V' ? 1 : 0;
3983 const int __hi = 53;
3984 auto __val = __read_unsigned(__num ? __num : 2);
3985 if (__lo <= __val && __val <= __hi)
3990 __sunday_wk = __val;
3996 __monday_wk = __val;
4001 __iso_wk = __sunday_wk = __monday_wk = -1;
4007 if (__mod ==
'O' || __num) [[unlikely]]
4012 __tmget.get(__is, {}, __is, __err, &__tm,
4013 __fmt - 2 - (__mod ==
'E'), __fmt);
4014 if (!__is_failed(__err))
4016 __y = year(__tm.tm_year + 1900);
4017 __m = month(__tm.tm_mon + 1);
4018 __d = day(__tm.tm_mday);
4021 __parts |= _ChronoParts::_Date;
4025 if (__mod ==
'O' || __num) [[unlikely]]
4030 __tmget.get(__is, {}, __is, __err, &__tm,
4031 __fmt - 2 - (__mod ==
'E'), __fmt);
4032 if (!__is_failed(__err))
4034 __h =
hours(__tm.tm_hour);
4039 __parts |= _ChronoParts::_TimeOfDay;
4043 if (__mod) [[unlikely]]
4046 __tmget.get(__is, {}, __is, __err, &__tm,
4048 if (!__is_failed(__err))
4050 int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
4051 __yy = year(__tm.tm_year - __cent);
4052 if (__century == -1)
4058 auto __val = __read_unsigned(__num ? __num : 2);
4059 if (__val >= 0 && __val <= 99)
4062 if (__century == -1)
4063 __century = __val < 69 ? 2000 : 1900;
4066 __y = __yy = __iso_yy = __iso_y = __bad_y;
4068 __parts |= _ChronoParts::_Year;
4072 if (__mod ==
'O') [[unlikely]]
4074 else if (__mod ==
'E')
4077 __tmget.get(__is, {}, __is, __err, &__tm,
4079 if (!__is_failed(__err))
4080 __y = year(__tm.tm_year);
4084 auto __val = __read_unsigned(__num ? __num : 4);
4085 if (!__is_failed(__err))
4088 __parts |= _ChronoParts::_Year;
4092 if (__num) [[unlikely]]
4099 auto __i = __is.peek();
4100 if (_Traits::eq_int_type(__i, _Traits::eof()))
4105 _CharT __ic = _Traits::to_char_type(__i);
4106 const bool __neg = __ic == _CharT(
'-');
4107 if (__ic == _CharT(
'-') || __ic == _CharT(
'+'))
4114 __hh = __read_unsigned(2);
4119 __hh = 10 * _S_try_read_digit(__is, __err);
4120 __hh += _S_try_read_digit(__is, __err);
4123 if (__is_failed(__err))
4127 if (_Traits::eq_int_type(__i, _Traits::eof()))
4130 __tz_offset =
minutes(__hh * (__neg ? -60 : 60));
4133 __ic = _Traits::to_char_type(__i);
4135 bool __read_mm =
false;
4138 if (__ic == _GLIBCXX_WIDEN(
":")[0])
4145 else if (_CharT(
'0') <= __ic && __ic <= _CharT(
'9'))
4151 int_least32_t __mm = 0;
4154 __mm = 10 * _S_try_read_digit(__is, __err);
4155 __mm += _S_try_read_digit(__is, __err);
4158 if (!__is_failed(__err))
4160 auto __z = __hh * 60 + __mm;
4161 __tz_offset =
minutes(__neg ? -__z : __z);
4167 if (__mod || __num) [[unlikely]]
4171 basic_string_view<_CharT> __x = _GLIBCXX_WIDEN(
"_/-+");
4175 auto __i = __is.peek();
4176 if (!_Traits::eq_int_type(__i, _Traits::eof()))
4178 _CharT __a = _Traits::to_char_type(__i);
4180 || __x.find(__a) != __x.npos)
4182 __tz_abbr.push_back(__a);
4191 if (__tz_abbr.empty())
4197 if (__mod || __num) [[unlikely]]
4201 _CharT __i = __is.peek();
4202 if (_Traits::eq_int_type(__i, _Traits::eof()))
4204 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4212 if (__mod || __num) [[unlikely]]
4216 _CharT __i = __is.peek();
4217 if (_Traits::eq_int_type(__i, _Traits::eof()))
4219 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4225 if (__mod || __num) [[unlikely]]
4233 if (__mod || __num) [[unlikely]]
4242 if (_CharT(
'1') <= __c && __c <= _CharT(
'9'))
4244 if (!__mod) [[likely]]
4247 auto __end = __fmt + _Traits::length(__fmt);
4249 = __format::__parse_integer(__fmt - 1, __end);
4250 if (__ptr) [[likely]]
4261 if (__is_failed(__err)) [[unlikely]]
4271 if (__yy != __bad_y && __y == __bad_y)
4272 __y =
years(__century) + __yy;
4273 if (__iso_yy != __bad_y && __iso_y == __bad_y)
4274 __iso_y =
years(__century) + __iso_yy;
4277 bool __can_use_doy =
false;
4278 bool __can_use_iso_wk =
false;
4279 bool __can_use_sun_wk =
false;
4280 bool __can_use_mon_wk =
false;
4283 if (__y != __bad_y && __dayofyear >= 0)
4285 __can_use_doy =
true;
4286 __parts |= _ChronoParts::_Date;
4288 else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
4290 __can_use_sun_wk =
true;
4291 __parts |= _ChronoParts::_Date;
4293 else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
4295 __can_use_mon_wk =
true;
4296 __parts |= _ChronoParts::_Date;
4298 else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
4301 __can_use_iso_wk =
true;
4302 __parts |= _ChronoParts::_Date;
4305 if (__is_failed(__err)) [[unlikely]]
4307 else if (__is_flag) [[unlikely]]
4309 else if ((_M_need & __parts) == _M_need) [[likely]]
4331 const bool __need_wday = _M_need & _ChronoParts::_Weekday;
4335 const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;
4337 if (__need_wday && __wday != __bad_wday)
4339 else if (_M_need & _ChronoParts::_Date)
4343 const bool __need_ymd = !__need_wday && !__need_time;
4345 if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
4346 || (_M_need & _ChronoParts::_Month && __m == __bad_mon)
4347 || (_M_need & _ChronoParts::_Day && __d == __bad_day))
4354 if ((0 < __dayofyear && __dayofyear <= 365)
4355 || (__dayofyear == 366 && __y.is_leap()))
4358 _M_sys_days = sys_days(__y/January/1)
4359 +
days(__dayofyear - 1);
4361 _M_ymd = year_month_day(_M_sys_days);
4366 else if (__can_use_iso_wk)
4374 const sys_days __jan4(__iso_y/January/4);
4375 weekday __wd1(__jan4 -
days(3));
4376 if (__wd1 != Thursday)
4377 if (__wd1 != Wednesday || !__iso_y.is_leap())
4381 if (!__is_failed(__err)) [[likely]]
4384 sys_days __w(Thursday[1]/January/__iso_y);
4386 __w -= Thursday - Monday;
4388 __w += __wday - Monday;
4392 _M_ymd = year_month_day(_M_sys_days);
4395 else if (__can_use_sun_wk)
4398 sys_days __wk1(__y/January/Sunday[1]);
4399 _M_sys_days = __wk1 +
weeks(__sunday_wk - 1)
4400 +
days(__wday.c_encoding());
4401 _M_ymd = year_month_day(_M_sys_days);
4402 if (_M_ymd.year() != __y) [[unlikely]]
4405 else if (__can_use_mon_wk)
4408 sys_days __wk1(__y/January/Monday[1]);
4409 _M_sys_days = __wk1 +
weeks(__monday_wk - 1)
4410 +
days(__wday.c_encoding() - 1);
4411 _M_ymd = year_month_day(_M_sys_days);
4412 if (_M_ymd.year() != __y) [[unlikely]]
4424 if (_M_need & _ChronoParts::_Year)
4426 if (!__y.ok()) [[unlikely]]
4429 else if (__y == __bad_y)
4432 if (_M_need & _ChronoParts::_Month)
4434 if (!__m.ok()) [[unlikely]]
4437 else if (__m == __bad_mon)
4440 if (_M_need & _ChronoParts::_Day)
4442 if (__d < day(1) || __d > (__y/__m/last).day())
4445 else if (__d == __bad_day)
4448 if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
4451 if (__need_wday || __need_time)
4452 _M_sys_days = sys_days(_M_ymd);
4459 _M_wd = weekday(_M_sys_days);
4465 if (__h == __bad_h && __h12 != __bad_h)
4469 else if (__ampm == 2)
4470 __h = __h12 ==
hours(12) ? __h12 : __h12 +
hours(12);
4475 auto __t = _M_time.zero();
4484 if (__min != __bad_min)
4490 if (__s != __bad_sec)
4494 _M_is_leap_second = __s >=
seconds(60);
4503 if (!__is_failed(__err)) [[likely]]
4505 if (__offset && __tz_offset != __bad_min)
4506 *__offset = __tz_offset;
4507 if (__abbrev && !__tz_abbr.empty())
4515 __is.setstate(__err);
4519#undef _GLIBCXX_WIDEN
4524_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 > seconds
seconds
duration< int64_t, ratio< 604800 > > weeks
weeks
duration< int64_t, ratio< 3600 > > hours
hours
duration< int64_t, ratio< 86400 > > days
days
basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const duration< _Rep, _Period > &__d)
duration< int64_t, ratio< 60 > > minutes
minutes
duration< int64_t, ratio< 31556952 > > years
years
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.
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).
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
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.
Basis for explicit traits specializations.
chrono::duration represents a distance between two points in time
chrono::time_point represents a point in time as measured by a clock
Managing sequences of characters and character-like objects.
_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...
Container class for localization functionality.
static const locale & classic()
Return reference to the C locale.