30#ifndef _GLIBCXX_CHRONO_IO_H
31#define _GLIBCXX_CHRONO_IO_H 1
34#pragma GCC system_header
37#if __cplusplus >= 202002L
50_GLIBCXX_BEGIN_NAMESPACE_VERSION
60#define _GLIBCXX_WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
61#define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
63 template<
typename _Period,
typename _CharT>
70#define _GLIBCXX_UNITS_SUFFIX(period, suffix) \
71 if constexpr (is_same_v<_Period, period>) \
72 return _GLIBCXX_WIDEN(suffix); \
80#if _GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX
102#undef _GLIBCXX_UNITS_SUFFIX
106 template<
typename _Period,
typename _CharT,
typename _Out>
110 if (
auto __s = __detail::__units_suffix<_Period, _CharT>();
__s.size())
112 else if constexpr (_Period::den == 1)
114 (uintmax_t)_Period::num);
117 (uintmax_t)_Period::num,
118 (uintmax_t)_Period::den);
127 template<
typename _CharT,
typename _Traits,
128 typename _Rep,
typename _Period>
134 using period =
typename _Period::type;
138 __s.precision(
__os.precision());
142 __detail::__fmt_units_suffix<period, _CharT>(_Out(
__s));
152 template<
typename _Duration>
156 const string* _M_abbrev;
162 template<
typename _Duration>
177 template<
typename _Duration>
178 inline __detail::__local_time_fmt<_Duration>
190 [[noreturn,__gnu__::__always_inline__]]
192 __no_timezone_available()
193 { __throw_format_error(
"format error: no timezone available for %Z or %z"); }
195 [[noreturn,__gnu__::__always_inline__]]
197 __not_valid_for_duration()
198 { __throw_format_error(
"format error: chrono-format-spec not valid for "
199 "chrono::duration"); }
201 [[noreturn,__gnu__::__always_inline__]]
203 __invalid_chrono_spec()
204 { __throw_format_error(
"format error: chrono-format-spec not valid for "
207 template<
typename _CharT>
208 struct _ChronoSpec : _Spec<_CharT>
210 basic_string_view<_CharT> _M_chrono_specs;
219 _M_locale_specific() const noexcept
220 {
return this->_M_reserved; }
223 _M_locale_specific(
bool __b)
noexcept
224 { this->_M_reserved = __b; }
231 _Year = 1, _Month = 2, _Day = 4, _Weekday = 8, _TimeOfDay = 16,
233 _Date = _Year | _Month | _Day | _Weekday,
234 _DateTime = _Date | _TimeOfDay,
235 _ZonedDateTime = _DateTime | _TimeZone,
239 constexpr _ChronoParts
240 operator|(_ChronoParts __x, _ChronoParts __y)
noexcept
241 {
return static_cast<_ChronoParts
>((int)__x | (
int)__y); }
243 constexpr _ChronoParts&
244 operator|=(_ChronoParts& __x, _ChronoParts __y)
noexcept
245 {
return __x = __x | __y; }
248 template<
typename _CharT>
249 struct __formatter_chrono
251 using __string_view = basic_string_view<_CharT>;
252 using __string = basic_string<_CharT>;
254 template<
typename _ParseContext>
255 constexpr typename _ParseContext::iterator
256 _M_parse(_ParseContext& __pc, _ChronoParts __parts)
258 auto __first = __pc.
begin();
259 auto __last = __pc.end();
261 _ChronoSpec<_CharT> __spec{};
263 auto __finalize = [
this, &__spec] {
267 auto __finished = [&] {
268 if (__first == __last || *__first ==
'}')
279 __first = __spec._M_parse_fill_and_align(__first, __last);
283 __first = __spec._M_parse_width(__first, __last, __pc);
287 if (__parts & _ChronoParts::_Duration)
289 __first = __spec._M_parse_precision(__first, __last, __pc);
294 __first = __spec._M_parse_locale(__first, __last);
301 __string_view __str(__first, __last - __first);
302 auto __end = __str.find(
'}');
303 if (__end != __str.npos)
305 __str.remove_suffix(__str.length() - __end);
306 __last = __first + __end;
308 if (__str.find(
'{') != __str.npos)
309 __throw_format_error(
"chrono format error: '{' in chrono-specs");
316 const auto __chrono_specs = __first++;
317 if (*__chrono_specs !=
'%')
318 __throw_format_error(
"chrono format error: no '%' at start of "
324 bool __locale_specific =
false;
326 while (__first != __last)
328 enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
329 _Mods __allowed_mods = _Mod_none;
331 _CharT __c = *__first++;
337 __locale_specific =
true;
343 __locale_specific =
true;
346 __needed = _DateTime;
347 __allowed_mods = _Mod_E;
348 __locale_specific =
true;
352 __allowed_mods = _Mod_E;
357 __allowed_mods = _Mod_O;
369 __needed = _TimeOfDay;
370 __allowed_mods = _Mod_O;
373 if (!(__parts & _Duration))
378 __allowed_mods = _Mod_O;
381 __needed = _TimeOfDay;
382 __allowed_mods = _Mod_O;
386 __locale_specific =
true;
390 __needed = _TimeOfDay;
394 __needed = _Duration;
397 __needed = _TimeOfDay;
398 __allowed_mods = _Mod_O;
403 __allowed_mods = _Mod_O;
409 __allowed_mods = _Mod_O;
413 __locale_specific =
true;
414 __allowed_mods = _Mod_E;
417 __needed = _TimeOfDay;
418 __locale_specific =
true;
419 __allowed_mods = _Mod_E;
423 __allowed_mods = _Mod_E_O;
427 __allowed_mods = _Mod_E;
430 __needed = _TimeZone;
431 __allowed_mods = _Mod_E_O;
434 __needed = _TimeZone;
442 if (__mod) [[unlikely]]
444 __allowed_mods = _Mod_none;
450 __throw_format_error(
"chrono format error: invalid "
451 " specifier in chrono-specs");
454 if ((__mod ==
'E' && !(__allowed_mods & _Mod_E))
455 || (__mod ==
'O' && !(__allowed_mods & _Mod_O)))
456 __throw_format_error(
"chrono format error: invalid "
457 " modifier in chrono-specs");
458 if (__mod && __c !=
'z')
459 __locale_specific =
true;
462 if ((__parts & __needed) != __needed)
463 __throw_format_error(
"chrono format error: format argument "
464 "does not contain the information "
465 "required by the chrono-specs");
468 size_t __pos = __string_view(__first, __last - __first).find(
'%');
473 if (__pos == __string_view::npos)
479 __first += __pos + 1;
484 if (__conv || __mod != _CharT())
485 __throw_format_error(
"chrono format error: unescaped '%' in "
489 _M_spec._M_chrono_specs
490 = __string_view(__chrono_specs, __first - __chrono_specs);
491 _M_spec._M_locale_specific(__locale_specific);
501 template<
typename _Tp,
typename _FormatContext>
502 typename _FormatContext::iterator
503 _M_format(
const _Tp& __t, _FormatContext& __fc,
504 bool __is_neg =
false)
const
506 auto __first = _M_spec._M_chrono_specs.begin();
507 const auto __last = _M_spec._M_chrono_specs.end();
508 if (__first == __last)
509 return _M_format_to_ostream(__t, __fc, __is_neg);
511#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
515 if constexpr (is_same_v<_CharT, char>)
516 if constexpr (__unicode::__literal_encoding_is_utf8())
517 if (_M_spec._M_localized && _M_spec._M_locale_specific())
519 extern locale __with_encoding_conversion(
const locale&);
523 locale __loc = __fc.locale();
524 if (__loc != locale::classic())
525 __fc._M_loc = __with_encoding_conversion(__loc);
529 _Sink_iter<_CharT> __out;
530 __format::_Str_sink<_CharT> __sink;
531 bool __write_direct =
false;
532 if constexpr (is_same_v<
typename _FormatContext::iterator,
535 if (_M_spec._M_width_kind == __format::_WP_none)
538 __write_direct =
true;
541 __out = __sink.out();
544 __out = __sink.out();
548 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
549 __is_neg = __t.is_negative();
551 auto __print_sign = [&__is_neg, &__out] {
552 if constexpr (chrono::__is_duration_v<_Tp>
553 || __is_specialization_of<_Tp, chrono::hh_mm_ss>)
556 *__out++ = _S_plus_minus[1];
563 constexpr const _CharT* __literals = _GLIBCXX_WIDEN(
"\n\t%");
570 _CharT __c = *__first++;
575 __out = _M_a_A(__t,
std::move(__out), __fc, __c ==
'A');
580 __out = _M_b_B(__t,
std::move(__out), __fc, __c ==
'B');
583 __out = _M_c(__t,
std::move(__out), __fc, __mod ==
'E');
588 __out = _M_C_y_Y(__t,
std::move(__out), __fc, __c, __mod);
592 __out = _M_d_e(__t,
std::move(__out), __fc, __c, __mod ==
'O');
595 __out = _M_D(__t,
std::move(__out), __fc);
598 __out = _M_F(__t,
std::move(__out), __fc);
602 __out = _M_g_G(__t,
std::move(__out), __fc, __c ==
'G');
606 __out = _M_H_I(__t, __print_sign(), __fc, __c, __mod ==
'O');
609 __out = _M_j(__t, __print_sign(), __fc);
612 __out = _M_m(__t,
std::move(__out), __fc, __mod ==
'O');
615 __out = _M_M(__t, __print_sign(), __fc, __mod ==
'O');
618 __out = _M_p(__t,
std::move(__out), __fc);
621 __out = _M_q(__t,
std::move(__out), __fc);
625 if constexpr (chrono::__is_duration_v<_Tp>)
631 __throw_format_error(
"chrono format error: argument is "
635 __out = _M_r(__t, __print_sign(), __fc);
639 __out = _M_R_T(__t, __print_sign(), __fc, __c ==
'T');
642 __out = _M_S(__t, __print_sign(), __fc, __mod ==
'O');
646 __out = _M_u_w(__t,
std::move(__out), __fc, __c, __mod ==
'O');
651 __out = _M_U_V_W(__t,
std::move(__out), __fc, __c,
655 __out = _M_x(__t,
std::move(__out), __fc, __mod ==
'E');
658 __out = _M_X(__t, __print_sign(), __fc, __mod ==
'E');
661 __out = _M_z(__t,
std::move(__out), __fc, (
bool)__mod);
664 __out = _M_Z(__t,
std::move(__out), __fc);
667 *__out++ = __literals[0];
670 *__out++ = __literals[1];
673 *__out++ = __literals[2];
685 __string_view __str(__first, __last - __first);
686 size_t __pos = __str.find(
'%');
691 if (__pos == __str.npos)
695 __str.remove_suffix(__str.length() - __pos);
696 __first += __pos + 1;
698 __out = __format::__write(
std::move(__out), __str);
701 while (__first != __last);
703 if constexpr (is_same_v<
typename _FormatContext::iterator,
708 auto __span = __sink.view();
709 __string_view __str(__span.data(), __span.size());
711 if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
712 __width = __unicode::__field_width(__str);
714 __width = __str.size();
715 return __format::__write_padded_as_spec(__str, __width,
719 _ChronoSpec<_CharT> _M_spec;
723 template<
typename _FormatContext>
725 _M_locale(_FormatContext& __fc)
const
727 if (!_M_spec._M_localized)
730 return __fc.locale();
738 template<
typename _Tp,
typename _FormatContext>
739 typename _FormatContext::iterator
740 _M_format_to_ostream(
const _Tp& __t, _FormatContext& __fc,
743 using ::std::chrono::__detail::__utc_leap_second;
744 using ::std::chrono::__detail::__local_time_fmt;
746 basic_ostringstream<_CharT> __os;
747 __os.imbue(_M_locale(__fc));
749 if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
752 auto __days = chrono::floor<chrono::days>(__t._M_time);
753 __os << chrono::year_month_day(__days) <<
' '
754 << chrono::hh_mm_ss(__t._M_time - __days);
760 if (!__t._M_abbrev) [[unlikely]]
761 __format::__no_timezone_available();
762 else if constexpr (is_same_v<_CharT, char>)
763 __os <<
' ' << *__t._M_abbrev;
767 for (
char __c : *__t._M_abbrev)
774 if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
775 __os << __t._M_date <<
' ' << __t._M_time;
776 else if constexpr (chrono::__is_time_point_v<_Tp>)
783 if constexpr (is_convertible_v<_Tp, chrono::sys_days>)
784 __os << _S_date(__t);
787 auto __days = chrono::floor<chrono::days>(__t);
788 __os << chrono::year_month_day(__days) <<
' '
789 << chrono::hh_mm_ss(__t - __days);
794 if constexpr (chrono::__is_duration_v<_Tp>)
795 if (__is_neg) [[unlikely]]
796 __os << _S_plus_minus[1];
802 return __format::__write_padded_as_spec(__str, __str.size(),
806 static constexpr const _CharT* _S_chars
807 = _GLIBCXX_WIDEN(
"0123456789+-:/ {}");
808 static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
809 static constexpr _CharT _S_colon = _S_chars[12];
810 static constexpr _CharT _S_slash = _S_chars[13];
811 static constexpr _CharT _S_space = _S_chars[14];
812 static constexpr const _CharT* _S_empty_spec = _S_chars + 15;
814 template<
typename _OutIter>
816 _M_write(_OutIter __out,
const locale& __loc, __string_view __s)
const
818#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
823 if constexpr (is_same_v<_CharT, char>)
824 if constexpr (__unicode::__literal_encoding_is_utf8())
825 if (_M_spec._M_localized && _M_spec._M_locale_specific()
826 && __loc != locale::classic())
829 __locale_encoding_to_utf8(
const locale&, string_view,
void*);
831 __s = __locale_encoding_to_utf8(__loc, __s, &__buf);
834 return __format::__write(
std::move(__out), __s);
837 template<
typename _Tp,
typename _FormatContext>
838 typename _FormatContext::iterator
839 _M_a_A(
const _Tp& __t,
typename _FormatContext::iterator __out,
840 _FormatContext& __ctx,
bool __full)
const
844 chrono::weekday __wd = _S_weekday(__t);
846 __throw_format_error(
"format error: invalid weekday");
848 locale __loc = _M_locale(__ctx);
849 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
850 const _CharT* __days[7];
852 __tp._M_days(__days);
854 __tp._M_days_abbreviated(__days);
855 __string_view __str(__days[__wd.c_encoding()]);
856 return _M_write(
std::move(__out), __loc, __str);
859 template<
typename _Tp,
typename _FormatContext>
860 typename _FormatContext::iterator
861 _M_b_B(
const _Tp& __t,
typename _FormatContext::iterator __out,
862 _FormatContext& __ctx,
bool __full)
const
866 chrono::month __m = _S_month(__t);
868 __throw_format_error(
"format error: invalid month");
869 locale __loc = _M_locale(__ctx);
870 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
871 const _CharT* __months[12];
873 __tp._M_months(__months);
875 __tp._M_months_abbreviated(__months);
876 __string_view __str(__months[(
unsigned)__m - 1]);
877 return _M_write(
std::move(__out), __loc, __str);
880 template<
typename _Tp,
typename _FormatContext>
881 typename _FormatContext::iterator
882 _M_c(
const _Tp& __t,
typename _FormatContext::iterator __out,
883 _FormatContext& __ctx,
bool __mod =
false)
const
888 using namespace chrono;
889 using ::std::chrono::__detail::__utc_leap_second;
890 using ::std::chrono::__detail::__local_time_fmt;
900#ifdef _GLIBCXX_USE_STRUCT_TM_TM_ZONE
903 if constexpr (__is_time_point_v<_Tp>)
906 if constexpr (!is_same_v<typename _Tp::clock, local_t>)
907 __tm.tm_zone =
const_cast<char*
>(
"UTC");
909 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
914 __tm.tm_zone =
const_cast<char*
>(__t._M_abbrev->c_str());
917 __tm.tm_zone =
const_cast<char*
>(
"UTC");
920 auto __d = _S_days(__t);
921 using _TDays =
decltype(__d);
922 const year_month_day __ymd(__d);
923 const auto __y = __ymd.year();
924 const auto __hms = _S_hms(__t);
926 __tm.tm_year = (int)__y - 1900;
927 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
928 __tm.tm_mon = (unsigned)__ymd.month() - 1;
929 __tm.tm_mday = (unsigned)__ymd.day();
930 __tm.tm_wday = weekday(__d).c_encoding();
931 __tm.tm_hour = __hms.hours().count();
932 __tm.tm_min = __hms.minutes().count();
933 __tm.tm_sec = __hms.seconds().count();
935 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
'c',
939 template<
typename _Tp,
typename _FormatContext>
940 typename _FormatContext::iterator
941 _M_C_y_Y(
const _Tp& __t,
typename _FormatContext::iterator __out,
942 _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0)
const
952 chrono::year __y = _S_year(__t);
954 if (__mod && _M_spec._M_localized) [[unlikely]]
955 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
958 __tm.tm_year = (int)__y - 1900;
959 return _M_locale_fmt(
std::move(__out), __loc, __tm,
963 basic_string<_CharT> __s;
965 const bool __is_neg = __yi < 0;
966 __yi = __builtin_abs(__yi);
968 if (__conv ==
'Y' || __conv ==
'C')
970 int __ci = __yi / 100;
971 if (__is_neg) [[unlikely]]
973 __s.assign(1, _S_plus_minus[1]);
975 if (__conv ==
'C' && (__ci * 100) != __yi)
978 if (__ci >= 100) [[unlikely]]
980 __s += std::format(_S_empty_spec, __ci / 100);
983 __s += _S_two_digits(__ci);
986 if (__conv ==
'Y' || __conv ==
'y')
987 __s += _S_two_digits(__yi % 100);
989 return __format::__write(
std::move(__out), __string_view(__s));
992 template<
typename _Tp,
typename _FormatContext>
993 typename _FormatContext::iterator
994 _M_D(
const _Tp& __t,
typename _FormatContext::iterator __out,
995 _FormatContext&)
const
997 auto __ymd = _S_date(__t);
998 basic_string<_CharT> __s;
999#if ! _GLIBCXX_USE_CXX11_ABI
1002 __s = _S_two_digits((
unsigned)__ymd.month());
1004 __s += _S_two_digits((
unsigned)__ymd.day());
1006 __s += _S_two_digits(__builtin_abs((
int)__ymd.year()) % 100);
1007 return __format::__write(
std::move(__out), __string_view(__s));
1010 template<
typename _Tp,
typename _FormatContext>
1011 typename _FormatContext::iterator
1012 _M_d_e(
const _Tp& __t,
typename _FormatContext::iterator __out,
1013 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1020 chrono::day __d = _S_day(__t);
1021 unsigned __i = (unsigned)__d;
1023 if (__mod && _M_spec._M_localized) [[unlikely]]
1024 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1028 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1032 auto __sv = _S_two_digits(__i);
1034 if (__conv == _CharT(
'e') && __i < 10)
1036 __buf[0] = _S_space;
1040 return __format::__write(
std::move(__out), __sv);
1043 template<
typename _Tp,
typename _FormatContext>
1044 typename _FormatContext::iterator
1045 _M_F(
const _Tp& __t,
typename _FormatContext::iterator __out,
1046 _FormatContext&)
const
1048 auto __ymd = _S_date(__t);
1049 auto __s = std::format(_GLIBCXX_WIDEN(
"{:04d}- - "),
1051 auto __sv = _S_two_digits((
unsigned)__ymd.month());
1052 __s[__s.size() - 5] = __sv[0];
1053 __s[__s.size() - 4] = __sv[1];
1054 __sv = _S_two_digits((
unsigned)__ymd.day());
1055 __s[__s.size() - 2] = __sv[0];
1056 __s[__s.size() - 1] = __sv[1];
1058 return __format::__write(
std::move(__out), __sv);
1061 template<
typename _Tp,
typename _FormatContext>
1062 typename _FormatContext::iterator
1063 _M_g_G(
const _Tp& __t,
typename _FormatContext::iterator __out,
1064 _FormatContext& __ctx,
bool __full)
const
1068 using namespace chrono;
1069 auto __d = _S_days(__t);
1071 __d -= (weekday(__d) - Monday) -
days(3);
1073 year __y = year_month_day(__d).year();
1074 return _M_C_y_Y(__y,
std::move(__out), __ctx,
"yY"[__full]);
1077 template<
typename _Tp,
typename _FormatContext>
1078 typename _FormatContext::iterator
1079 _M_H_I(
const _Tp& __t,
typename _FormatContext::iterator __out,
1080 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1087 const auto __hms = _S_hms(__t);
1088 int __i = __hms.hours().count();
1090 if (__mod && _M_spec._M_localized) [[unlikely]]
1091 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1095 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1099 if (__conv == _CharT(
'I'))
1106 return __format::__write(
std::move(__out), _S_two_digits(__i));
1109 template<
typename _Tp,
typename _FormatContext>
1110 typename _FormatContext::iterator
1111 _M_j(
const _Tp& __t,
typename _FormatContext::iterator __out,
1112 _FormatContext&)
const
1114 if constexpr (chrono::__is_duration_v<_Tp>)
1117 unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
1123 using namespace chrono;
1124 auto __day = _S_days(__t);
1125 auto __ymd = _S_date(__t);
1129 if constexpr (is_same_v<
typename decltype(__day)::clock, local_t>)
1130 __d = __day - local_days(__ymd.year()/January/0);
1132 __d = __day - sys_days(__ymd.year()/January/0);
1138 template<
typename _Tp,
typename _FormatContext>
1139 typename _FormatContext::iterator
1140 _M_m(
const _Tp& __t,
typename _FormatContext::iterator __out,
1141 _FormatContext& __ctx,
bool __mod)
const
1146 auto __m = _S_month(__t);
1147 auto __i = (unsigned)__m;
1149 if (__mod && _M_spec._M_localized) [[unlikely]]
1150 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1153 __tm.tm_mon = __i - 1;
1154 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1158 return __format::__write(
std::move(__out), _S_two_digits(__i));
1161 template<
typename _Tp,
typename _FormatContext>
1162 typename _FormatContext::iterator
1163 _M_M(
const _Tp& __t,
typename _FormatContext::iterator __out,
1164 _FormatContext& __ctx,
bool __mod)
const
1169 auto __m = _S_hms(__t).minutes();
1170 auto __i = __m.count();
1172 if (__mod && _M_spec._M_localized) [[unlikely]]
1173 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1177 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1181 return __format::__write(
std::move(__out), _S_two_digits(__i));
1184 template<
typename _Tp,
typename _FormatContext>
1185 typename _FormatContext::iterator
1186 _M_p(
const _Tp& __t,
typename _FormatContext::iterator __out,
1187 _FormatContext& __ctx)
const
1190 auto __hms = _S_hms(__t);
1191 locale __loc = _M_locale(__ctx);
1192 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1193 const _CharT* __ampm[2];
1194 __tp._M_am_pm(__ampm);
1195 return _M_write(
std::move(__out), __loc,
1196 __ampm[__hms.hours().count() >= 12]);
1199 template<
typename _Tp,
typename _FormatContext>
1200 typename _FormatContext::iterator
1201 _M_q(
const _Tp&,
typename _FormatContext::iterator __out,
1202 _FormatContext&)
const
1205 if constexpr (!chrono::__is_duration_v<_Tp>)
1206 __throw_format_error(
"format error: argument is not a duration");
1209 namespace __d = chrono::__detail;
1210 using period =
typename _Tp::period;
1211 return __d::__fmt_units_suffix<period, _CharT>(
std::move(__out));
1217 template<
typename _Tp,
typename _FormatContext>
1218 typename _FormatContext::iterator
1219 _M_r(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1220 _FormatContext& __ctx)
const
1223 auto __t = _S_floor_seconds(__tt);
1224 locale __loc = _M_locale(__ctx);
1225 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1226 const _CharT* __ampm_fmt;
1227 __tp._M_am_pm_format(&__ampm_fmt);
1228 basic_string<_CharT> __fmt(_S_empty_spec);
1229 __fmt.insert(1u, 1u, _S_colon);
1230 __fmt.insert(2u, __ampm_fmt);
1231 using _FmtStr = _Runtime_format_string<_CharT>;
1232 return _M_write(
std::move(__out), __loc,
1233 std::format(__loc, _FmtStr(__fmt), __t));
1236 template<
typename _Tp,
typename _FormatContext>
1237 typename _FormatContext::iterator
1238 _M_R_T(
const _Tp& __t,
typename _FormatContext::iterator __out,
1239 _FormatContext& __ctx,
bool __secs)
const
1243 auto __hms = _S_hms(__t);
1245 auto __s = std::format(_GLIBCXX_WIDEN(
"{:02d}:00"),
1246 __hms.hours().count());
1247 auto __sv = _S_two_digits(__hms.minutes().count());
1248 __s[__s.size() - 2] = __sv[0];
1249 __s[__s.size() - 1] = __sv[1];
1251 __out = __format::__write(
std::move(__out), __sv);
1254 *__out++ = _S_colon;
1255 __out = _M_S(__hms,
std::move(__out), __ctx);
1260 template<
typename _Tp,
typename _FormatContext>
1261 typename _FormatContext::iterator
1262 _M_S(
const _Tp& __t,
typename _FormatContext::iterator __out,
1263 _FormatContext& __ctx,
bool __mod =
false)
const
1267 auto __hms = _S_hms(__t);
1268 auto __s = __hms.seconds();
1270 if (__mod) [[unlikely]]
1272 if (_M_spec._M_localized)
1273 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1276 __tm.tm_sec = (int)__s.count();
1277 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1282 return __format::__write(
std::move(__out),
1283 _S_two_digits(__s.count()));
1286 if constexpr (__hms.fractional_width == 0)
1287 __out = __format::__write(
std::move(__out),
1288 _S_two_digits(__s.count()));
1291 locale __loc = _M_locale(__ctx);
1292 auto __ss = __hms.subseconds();
1293 using rep =
typename decltype(__ss)::rep;
1294 if constexpr (is_floating_point_v<rep>)
1296 chrono::duration<rep> __fs = __s + __ss;
1298 _GLIBCXX_WIDEN(
"{:#0{}.{}Lf}"),
1300 3 + __hms.fractional_width,
1301 __hms.fractional_width);
1306 = use_facet<numpunct<_CharT>>(__loc);
1307 __out = __format::__write(
std::move(__out),
1308 _S_two_digits(__s.count()));
1309 *__out++ = __np.decimal_point();
1310 if constexpr (is_integral_v<rep>)
1312 _GLIBCXX_WIDEN(
"{:0{}}"),
1314 __hms.fractional_width);
1317 auto __str = std::format(_S_empty_spec, __ss.count());
1320 __hms.fractional_width);
1329 template<
typename _Tp,
typename _FormatContext>
1330 typename _FormatContext::iterator
1331 _M_u_w(
const _Tp& __t,
typename _FormatContext::iterator __out,
1332 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1339 chrono::weekday __wd = _S_weekday(__t);
1341 if (__mod && _M_spec._M_localized) [[unlikely]]
1342 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1345 __tm.tm_wday = __wd.c_encoding();
1346 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1350 unsigned __wdi = __conv ==
'u' ? __wd.iso_encoding()
1351 : __wd.c_encoding();
1352 const _CharT __d = _S_digit(__wdi);
1353 return __format::__write(
std::move(__out), __string_view(&__d, 1));
1356 template<
typename _Tp,
typename _FormatContext>
1357 typename _FormatContext::iterator
1358 _M_U_V_W(
const _Tp& __t,
typename _FormatContext::iterator __out,
1359 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1367 using namespace chrono;
1368 auto __d = _S_days(__t);
1369 using _TDays =
decltype(__d);
1371 if (__mod && _M_spec._M_localized) [[unlikely]]
1372 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1374 const year_month_day __ymd(__d);
1375 const year __y = __ymd.year();
1377 __tm.tm_year = (int)__y - 1900;
1378 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
1379 __tm.tm_wday = weekday(__d).c_encoding();
1380 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1388 __d -= (weekday(__d) - Monday) -
days(3);
1391 __first = _TDays(year_month_day(__d).year()/January/1);
1396 if constexpr (
requires { __t.year(); })
1399 __y = year_month_day(__d).year();
1400 const weekday __weekstart = __conv ==
'U' ? Sunday : Monday;
1401 __first = _TDays(__y/January/__weekstart[1]);
1403 auto __weeks = chrono::floor<weeks>(__d - __first);
1404 __string_view __sv = _S_two_digits(__weeks.count() + 1);
1405 return __format::__write(
std::move(__out), __sv);
1408 template<
typename _Tp,
typename _FormatContext>
1409 typename _FormatContext::iterator
1410 _M_x(
const _Tp& __t,
typename _FormatContext::iterator __out,
1411 _FormatContext& __ctx,
bool __mod =
false)
const
1415 locale __loc = _M_locale(__ctx);
1416 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1417 const _CharT* __date_reps[2];
1418 __tp._M_date_formats(__date_reps);
1419 const _CharT* __rep = __date_reps[__mod];
1421 return _M_D(__t,
std::move(__out), __ctx);
1423 basic_string<_CharT> __fmt(_S_empty_spec);
1424 __fmt.insert(1u, 1u, _S_colon);
1425 __fmt.insert(2u, __rep);
1426 using _FmtStr = _Runtime_format_string<_CharT>;
1427 return _M_write(
std::move(__out), __loc,
1428 std::format(__loc, _FmtStr(__fmt), __t));
1431 template<
typename _Tp,
typename _FormatContext>
1432 typename _FormatContext::iterator
1433 _M_X(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1434 _FormatContext& __ctx,
bool __mod =
false)
const
1438 auto __t = _S_floor_seconds(__tt);
1439 locale __loc = _M_locale(__ctx);
1440 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1441 const _CharT* __time_reps[2];
1442 __tp._M_time_formats(__time_reps);
1443 const _CharT* __rep = __time_reps[__mod];
1445 return _M_R_T(__t,
std::move(__out), __ctx,
true);
1447 basic_string<_CharT> __fmt(_S_empty_spec);
1448 __fmt.insert(1u, 1u, _S_colon);
1449 __fmt.insert(2u, __rep);
1450 using _FmtStr = _Runtime_format_string<_CharT>;
1451 return _M_write(
std::move(__out), __loc,
1452 std::format(__loc, _FmtStr(__fmt), __t));
1455 template<
typename _Tp,
typename _FormatContext>
1456 typename _FormatContext::iterator
1457 _M_z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1458 _FormatContext&,
bool __mod =
false)
const
1460 using ::std::chrono::__detail::__utc_leap_second;
1461 using ::std::chrono::__detail::__local_time_fmt;
1463 auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN(
"+00:00"), 6)
1464 : __string_view(_GLIBCXX_WIDEN(
"+0000"), 5);
1466 if constexpr (chrono::__is_time_point_v<_Tp>)
1468 if constexpr (is_same_v<
typename _Tp::clock,
1469 chrono::system_clock>)
1470 return __format::__write(
std::move(__out), __utc);
1472 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1474 if (__t._M_offset_sec)
1477 basic_string<_CharT> __s;
1478 if (*__t._M_offset_sec != 0s)
1480 chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
1481 __s = _S_plus_minus[__hms.is_negative()];
1482 __s += _S_two_digits(__hms.hours().count());
1485 __s += _S_two_digits(__hms.minutes().count());
1488 return __format::__write(
std::move(__out), __sv);
1491 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1492 return __format::__write(
std::move(__out), __utc);
1494 __no_timezone_available();
1497 template<
typename _Tp,
typename _FormatContext>
1498 typename _FormatContext::iterator
1499 _M_Z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1500 _FormatContext& __ctx)
const
1502 using ::std::chrono::__detail::__utc_leap_second;
1503 using ::std::chrono::__detail::__local_time_fmt;
1505 __string_view __utc(_GLIBCXX_WIDEN(
"UTC"), 3);
1506 if constexpr (chrono::__is_time_point_v<_Tp>)
1508 if constexpr (is_same_v<
typename _Tp::clock,
1509 chrono::system_clock>)
1510 return __format::__write(
std::move(__out), __utc);
1512 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1516 string_view __sv = *__t._M_abbrev;
1517 if constexpr (is_same_v<_CharT, char>)
1518 return __format::__write(
std::move(__out), __sv);
1522 basic_string<_CharT> __ws(__sv.size(), _CharT());
1523 auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
1524 __ct.widen(__sv.begin(), __sv.end(), __ws.data());
1525 __string_view __wsv = __ws;
1526 return __format::__write(
std::move(__out), __wsv);
1530 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1531 return __format::__write(
std::move(__out), __utc);
1533 __no_timezone_available();
1540 _S_digit(
int __n)
noexcept
1543 return _GLIBCXX_WIDEN(
"0123456789999999")[__n & 0xf];
1547 static basic_string_view<_CharT>
1548 _S_two_digits(
int __n)
noexcept
1551 _GLIBCXX_WIDEN(
"0001020304050607080910111213141516171819"
1552 "2021222324252627282930313233343536373839"
1553 "4041424344454647484950515253545556575859"
1554 "6061626364656667686970717273747576777879"
1555 "8081828384858687888990919293949596979899"
1556 "9999999999999999999999999999999999999999"
1557 "9999999999999999") + 2 * (__n & 0x7f),
1565 template<
typename _Tp>
1566 static decltype(
auto)
1567 _S_hms(
const _Tp& __t)
1569 using ::std::chrono::__detail::__utc_leap_second;
1570 using ::std::chrono::__detail::__local_time_fmt;
1572 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1574 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1576 else if constexpr (chrono::__is_duration_v<_Tp>)
1577 return chrono::hh_mm_ss<_Tp>(__t);
1578 else if constexpr (chrono::__is_time_point_v<_Tp>)
1579 return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
1580 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1581 return _S_hms(__t._M_time);
1584 __invalid_chrono_spec();
1585 return chrono::hh_mm_ss<chrono::seconds>();
1590 template<
typename _Tp>
1592 _S_days(
const _Tp& __t)
1594 using namespace chrono;
1595 using ::std::chrono::__detail::__utc_leap_second;
1596 using ::std::chrono::__detail::__local_time_fmt;
1598 if constexpr (__is_time_point_v<_Tp>)
1599 return chrono::floor<days>(__t);
1600 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1602 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1603 return chrono::floor<days>(__t._M_time);
1604 else if constexpr (is_same_v<_Tp, year_month_day>
1605 || is_same_v<_Tp, year_month_day_last>
1606 || is_same_v<_Tp, year_month_weekday>
1607 || is_same_v<_Tp, year_month_weekday_last>)
1608 return sys_days(__t);
1611 if constexpr (__is_duration_v<_Tp>)
1612 __not_valid_for_duration();
1614 __invalid_chrono_spec();
1615 return chrono::sys_days();
1620 template<
typename _Tp>
1621 static chrono::year_month_day
1622 _S_date(
const _Tp& __t)
1624 if constexpr (is_same_v<_Tp, chrono::year_month_day>)
1627 return chrono::year_month_day(_S_days(__t));
1630 template<
typename _Tp>
1632 _S_day(
const _Tp& __t)
1634 using namespace chrono;
1636 if constexpr (is_same_v<_Tp, day>)
1638 else if constexpr (
requires { __t.day(); })
1641 return _S_date(__t).day();
1644 template<
typename _Tp>
1645 static chrono::month
1646 _S_month(
const _Tp& __t)
1648 using namespace chrono;
1650 if constexpr (is_same_v<_Tp, month>)
1652 else if constexpr (
requires { __t.month(); })
1655 return _S_date(__t).month();
1658 template<
typename _Tp>
1660 _S_year(
const _Tp& __t)
1662 using namespace chrono;
1664 if constexpr (is_same_v<_Tp, year>)
1666 else if constexpr (
requires { __t.year(); })
1669 return _S_date(__t).year();
1672 template<
typename _Tp>
1673 static chrono::weekday
1674 _S_weekday(
const _Tp& __t)
1677 using ::std::chrono::__detail::__local_time_fmt;
1679 if constexpr (is_same_v<_Tp, weekday>)
1681 else if constexpr (
requires { __t.weekday(); })
1683 else if constexpr (is_same_v<_Tp, month_weekday>)
1684 return __t.weekday_indexed().weekday();
1685 else if constexpr (is_same_v<_Tp, month_weekday_last>)
1686 return __t.weekday_last().weekday();
1688 return weekday(_S_days(__t));
1692 template<
typename _Tp>
1694 _S_floor_seconds(
const _Tp& __t)
1696 using chrono::__detail::__local_time_fmt;
1697 if constexpr (chrono::__is_time_point_v<_Tp>
1698 || chrono::__is_duration_v<_Tp>)
1700 if constexpr (_Tp::period::den != 1)
1701 return chrono::floor<chrono::seconds>(__t);
1705 else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1707 if constexpr (_Tp::fractional_width != 0)
1708 return chrono::floor<chrono::seconds>(__t.to_duration());
1712 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1713 return _S_floor_seconds(__t._M_time);
1720 template<
typename _Iter>
1722 _M_locale_fmt(_Iter __out,
const locale& __loc,
const struct tm& __tm,
1723 char __fmt,
char __mod)
const
1725 basic_ostringstream<_CharT> __os;
1727 const auto& __tp = use_facet<time_put<_CharT>>(__loc);
1728 __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
1730 __out = _M_write(
std::move(__out), __loc, __os.view());
1738 template<
typename _Rep,
typename _Period,
typename _CharT>
1739 requires __format::__formattable_impl<_Rep, _CharT>
1740 struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1742 constexpr typename basic_format_parse_context<_CharT>::iterator
1743 parse(basic_format_parse_context<_CharT>& __pc)
1745 using namespace __format;
1746 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1747 if constexpr (!is_floating_point_v<_Rep>)
1748 if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1749 __throw_format_error(
"format error: invalid precision for duration");
1753 template<
typename _Out>
1754 typename basic_format_context<_Out, _CharT>::iterator
1755 format(
const chrono::duration<_Rep, _Period>& __d,
1756 basic_format_context<_Out, _CharT>& __fc)
const
1758 if constexpr (numeric_limits<_Rep>::is_signed)
1759 if (__d < __d.zero()) [[unlikely]]
1761 if constexpr (is_integral_v<_Rep>)
1765 using _URep = make_unsigned_t<_Rep>;
1766 auto __ucnt = -
static_cast<_URep
>(__d.count());
1767 auto __ud = chrono::duration<_URep, _Period>(__ucnt);
1768 return _M_f._M_format(__ud, __fc,
true);
1771 return _M_f._M_format(-__d, __fc,
true);
1773 return _M_f._M_format(__d, __fc,
false);
1777 __format::__formatter_chrono<_CharT> _M_f;
1780 template<__format::__
char _CharT>
1781 struct formatter<chrono::day, _CharT>
1783 constexpr typename basic_format_parse_context<_CharT>::iterator
1784 parse(basic_format_parse_context<_CharT>& __pc)
1785 {
return _M_f._M_parse(__pc, __format::_Day); }
1787 template<
typename _Out>
1788 typename basic_format_context<_Out, _CharT>::iterator
1789 format(
const chrono::day& __t,
1790 basic_format_context<_Out, _CharT>& __fc)
const
1791 {
return _M_f._M_format(__t, __fc); }
1794 __format::__formatter_chrono<_CharT> _M_f;
1797 template<__format::__
char _CharT>
1798 struct formatter<chrono::month, _CharT>
1800 constexpr typename basic_format_parse_context<_CharT>::iterator
1801 parse(basic_format_parse_context<_CharT>& __pc)
1802 {
return _M_f._M_parse(__pc, __format::_Month); }
1804 template<
typename _Out>
1805 typename basic_format_context<_Out, _CharT>::iterator
1806 format(
const chrono::month& __t,
1807 basic_format_context<_Out, _CharT>& __fc)
const
1808 {
return _M_f._M_format(__t, __fc); }
1811 __format::__formatter_chrono<_CharT> _M_f;
1814 template<__format::__
char _CharT>
1815 struct formatter<chrono::year, _CharT>
1817 constexpr typename basic_format_parse_context<_CharT>::iterator
1818 parse(basic_format_parse_context<_CharT>& __pc)
1819 {
return _M_f._M_parse(__pc, __format::_Year); }
1821 template<
typename _Out>
1822 typename basic_format_context<_Out, _CharT>::iterator
1823 format(
const chrono::year& __t,
1824 basic_format_context<_Out, _CharT>& __fc)
const
1825 {
return _M_f._M_format(__t, __fc); }
1828 __format::__formatter_chrono<_CharT> _M_f;
1831 template<__format::__
char _CharT>
1832 struct formatter<chrono::weekday, _CharT>
1834 constexpr typename basic_format_parse_context<_CharT>::iterator
1835 parse(basic_format_parse_context<_CharT>& __pc)
1836 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1838 template<
typename _Out>
1839 typename basic_format_context<_Out, _CharT>::iterator
1840 format(
const chrono::weekday& __t,
1841 basic_format_context<_Out, _CharT>& __fc)
const
1842 {
return _M_f._M_format(__t, __fc); }
1845 __format::__formatter_chrono<_CharT> _M_f;
1848 template<__format::__
char _CharT>
1849 struct formatter<chrono::weekday_indexed, _CharT>
1851 constexpr typename basic_format_parse_context<_CharT>::iterator
1852 parse(basic_format_parse_context<_CharT>& __pc)
1853 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1855 template<
typename _Out>
1856 typename basic_format_context<_Out, _CharT>::iterator
1857 format(
const chrono::weekday_indexed& __t,
1858 basic_format_context<_Out, _CharT>& __fc)
const
1859 {
return _M_f._M_format(__t, __fc); }
1862 __format::__formatter_chrono<_CharT> _M_f;
1865 template<__format::__
char _CharT>
1866 struct formatter<chrono::weekday_last, _CharT>
1868 constexpr typename basic_format_parse_context<_CharT>::iterator
1869 parse(basic_format_parse_context<_CharT>& __pc)
1870 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1872 template<
typename _Out>
1873 typename basic_format_context<_Out, _CharT>::iterator
1874 format(
const chrono::weekday_last& __t,
1875 basic_format_context<_Out, _CharT>& __fc)
const
1876 {
return _M_f._M_format(__t, __fc); }
1879 __format::__formatter_chrono<_CharT> _M_f;
1882 template<__format::__
char _CharT>
1883 struct formatter<chrono::month_day, _CharT>
1885 constexpr typename basic_format_parse_context<_CharT>::iterator
1886 parse(basic_format_parse_context<_CharT>& __pc)
1887 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1889 template<
typename _Out>
1890 typename basic_format_context<_Out, _CharT>::iterator
1891 format(
const chrono::month_day& __t,
1892 basic_format_context<_Out, _CharT>& __fc)
const
1893 {
return _M_f._M_format(__t, __fc); }
1896 __format::__formatter_chrono<_CharT> _M_f;
1899 template<__format::__
char _CharT>
1900 struct formatter<chrono::month_day_last, _CharT>
1902 constexpr typename basic_format_parse_context<_CharT>::iterator
1903 parse(basic_format_parse_context<_CharT>& __pc)
1904 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1906 template<
typename _Out>
1907 typename basic_format_context<_Out, _CharT>::iterator
1908 format(
const chrono::month_day_last& __t,
1909 basic_format_context<_Out, _CharT>& __fc)
const
1910 {
return _M_f._M_format(__t, __fc); }
1913 __format::__formatter_chrono<_CharT> _M_f;
1916 template<__format::__
char _CharT>
1917 struct formatter<chrono::month_weekday, _CharT>
1919 constexpr typename basic_format_parse_context<_CharT>::iterator
1920 parse(basic_format_parse_context<_CharT>& __pc)
1921 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1923 template<
typename _Out>
1924 typename basic_format_context<_Out, _CharT>::iterator
1925 format(
const chrono::month_weekday& __t,
1926 basic_format_context<_Out, _CharT>& __fc)
const
1927 {
return _M_f._M_format(__t, __fc); }
1930 __format::__formatter_chrono<_CharT> _M_f;
1933 template<__format::__
char _CharT>
1934 struct formatter<chrono::month_weekday_last, _CharT>
1936 constexpr typename basic_format_parse_context<_CharT>::iterator
1937 parse(basic_format_parse_context<_CharT>& __pc)
1938 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1940 template<
typename _Out>
1941 typename basic_format_context<_Out, _CharT>::iterator
1942 format(
const chrono::month_weekday_last& __t,
1943 basic_format_context<_Out, _CharT>& __fc)
const
1944 {
return _M_f._M_format(__t, __fc); }
1947 __format::__formatter_chrono<_CharT> _M_f;
1950 template<__format::__
char _CharT>
1951 struct formatter<chrono::year_month, _CharT>
1953 constexpr typename basic_format_parse_context<_CharT>::iterator
1954 parse(basic_format_parse_context<_CharT>& __pc)
1955 {
return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }
1957 template<
typename _Out>
1958 typename basic_format_context<_Out, _CharT>::iterator
1959 format(
const chrono::year_month& __t,
1960 basic_format_context<_Out, _CharT>& __fc)
const
1961 {
return _M_f._M_format(__t, __fc); }
1964 __format::__formatter_chrono<_CharT> _M_f;
1967 template<__format::__
char _CharT>
1968 struct formatter<chrono::year_month_day, _CharT>
1970 constexpr typename basic_format_parse_context<_CharT>::iterator
1971 parse(basic_format_parse_context<_CharT>& __pc)
1972 {
return _M_f._M_parse(__pc, __format::_Date); }
1974 template<
typename _Out>
1975 typename basic_format_context<_Out, _CharT>::iterator
1976 format(
const chrono::year_month_day& __t,
1977 basic_format_context<_Out, _CharT>& __fc)
const
1978 {
return _M_f._M_format(__t, __fc); }
1981 __format::__formatter_chrono<_CharT> _M_f;
1984 template<__format::__
char _CharT>
1985 struct formatter<chrono::year_month_day_last, _CharT>
1987 constexpr typename basic_format_parse_context<_CharT>::iterator
1988 parse(basic_format_parse_context<_CharT>& __pc)
1989 {
return _M_f._M_parse(__pc, __format::_Date); }
1991 template<
typename _Out>
1992 typename basic_format_context<_Out, _CharT>::iterator
1993 format(
const chrono::year_month_day_last& __t,
1994 basic_format_context<_Out, _CharT>& __fc)
const
1995 {
return _M_f._M_format(__t, __fc); }
1998 __format::__formatter_chrono<_CharT> _M_f;
2001 template<__format::__
char _CharT>
2002 struct formatter<chrono::year_month_weekday, _CharT>
2004 constexpr typename basic_format_parse_context<_CharT>::iterator
2005 parse(basic_format_parse_context<_CharT>& __pc)
2006 {
return _M_f._M_parse(__pc, __format::_Date); }
2008 template<
typename _Out>
2009 typename basic_format_context<_Out, _CharT>::iterator
2010 format(
const chrono::year_month_weekday& __t,
2011 basic_format_context<_Out, _CharT>& __fc)
const
2012 {
return _M_f._M_format(__t, __fc); }
2015 __format::__formatter_chrono<_CharT> _M_f;
2018 template<__format::__
char _CharT>
2019 struct formatter<chrono::year_month_weekday_last, _CharT>
2021 constexpr typename basic_format_parse_context<_CharT>::iterator
2022 parse(basic_format_parse_context<_CharT>& __pc)
2023 {
return _M_f._M_parse(__pc, __format::_Date); }
2025 template<
typename _Out>
2026 typename basic_format_context<_Out, _CharT>::iterator
2027 format(
const chrono::year_month_weekday_last& __t,
2028 basic_format_context<_Out, _CharT>& __fc)
const
2029 {
return _M_f._M_format(__t, __fc); }
2032 __format::__formatter_chrono<_CharT> _M_f;
2035 template<
typename _Rep,
typename _Period, __format::__
char _CharT>
2036 struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
2038 constexpr typename basic_format_parse_context<_CharT>::iterator
2039 parse(basic_format_parse_context<_CharT>& __pc)
2040 {
return _M_f._M_parse(__pc, __format::_TimeOfDay); }
2042 template<
typename _Out>
2043 typename basic_format_context<_Out, _CharT>::iterator
2044 format(
const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
2045 basic_format_context<_Out, _CharT>& __fc)
const
2046 {
return _M_f._M_format(__t, __fc); }
2049 __format::__formatter_chrono<_CharT> _M_f;
2052#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2053 template<__format::__
char _CharT>
2054 struct formatter<chrono::sys_info, _CharT>
2056 constexpr typename basic_format_parse_context<_CharT>::iterator
2057 parse(basic_format_parse_context<_CharT>& __pc)
2058 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2060 template<
typename _Out>
2061 typename basic_format_context<_Out, _CharT>::iterator
2062 format(
const chrono::sys_info& __i,
2063 basic_format_context<_Out, _CharT>& __fc)
const
2064 {
return _M_f._M_format(__i, __fc); }
2067 __format::__formatter_chrono<_CharT> _M_f;
2070 template<__format::__
char _CharT>
2071 struct formatter<chrono::local_info, _CharT>
2073 constexpr typename basic_format_parse_context<_CharT>::iterator
2074 parse(basic_format_parse_context<_CharT>& __pc)
2075 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2077 template<
typename _Out>
2078 typename basic_format_context<_Out, _CharT>::iterator
2079 format(
const chrono::local_info& __i,
2080 basic_format_context<_Out, _CharT>& __fc)
const
2081 {
return _M_f._M_format(__i, __fc); }
2084 __format::__formatter_chrono<_CharT> _M_f;
2088 template<
typename _Duration, __format::__
char _CharT>
2089 struct formatter<chrono::sys_time<_Duration>, _CharT>
2091 constexpr typename basic_format_parse_context<_CharT>::iterator
2092 parse(basic_format_parse_context<_CharT>& __pc)
2094 auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
2095 if constexpr (!__stream_insertable)
2096 if (_M_f._M_spec._M_chrono_specs.empty())
2097 __format::__invalid_chrono_spec();
2101 template<
typename _Out>
2102 typename basic_format_context<_Out, _CharT>::iterator
2103 format(
const chrono::sys_time<_Duration>& __t,
2104 basic_format_context<_Out, _CharT>& __fc)
const
2105 {
return _M_f._M_format(__t, __fc); }
2108 static constexpr bool __stream_insertable
2109 =
requires (basic_ostream<_CharT>& __os,
2110 chrono::sys_time<_Duration> __t) { __os << __t; };
2112 __format::__formatter_chrono<_CharT> _M_f;
2115 template<
typename _Duration, __format::__
char _CharT>
2116 struct formatter<chrono::utc_time<_Duration>, _CharT>
2117 : __format::__formatter_chrono<_CharT>
2119 constexpr typename basic_format_parse_context<_CharT>::iterator
2120 parse(basic_format_parse_context<_CharT>& __pc)
2121 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2123 template<
typename _Out>
2124 typename basic_format_context<_Out, _CharT>::iterator
2125 format(
const chrono::utc_time<_Duration>& __t,
2126 basic_format_context<_Out, _CharT>& __fc)
const
2131 using chrono::__detail::__utc_leap_second;
2132 using chrono::seconds;
2133 using chrono::sys_time;
2134 using _CDur = common_type_t<_Duration, seconds>;
2135 const auto __li = chrono::get_leap_second_info(__t);
2136 sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
2137 if (!__li.is_leap_second) [[likely]]
2138 return _M_f._M_format(__s, __fc);
2140 return _M_f._M_format(__utc_leap_second(__s), __fc);
2144 friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;
2146 __format::__formatter_chrono<_CharT> _M_f;
2149 template<
typename _Duration, __format::__
char _CharT>
2150 struct formatter<chrono::tai_time<_Duration>, _CharT>
2151 : __format::__formatter_chrono<_CharT>
2153 constexpr typename basic_format_parse_context<_CharT>::iterator
2154 parse(basic_format_parse_context<_CharT>& __pc)
2155 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2157 template<
typename _Out>
2158 typename basic_format_context<_Out, _CharT>::iterator
2159 format(
const chrono::tai_time<_Duration>& __t,
2160 basic_format_context<_Out, _CharT>& __fc)
const
2167 constexpr chrono::days __tai_offset = chrono::days(4383);
2168 using _CDur = common_type_t<_Duration, chrono::days>;
2169 chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
2170 const string __abbrev(
"TAI", 3);
2171 const chrono::seconds __off = 0s;
2172 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2173 return _M_f._M_format(__lf, __fc);
2177 __format::__formatter_chrono<_CharT> _M_f;
2180 template<
typename _Duration, __format::__
char _CharT>
2181 struct formatter<chrono::gps_time<_Duration>, _CharT>
2182 : __format::__formatter_chrono<_CharT>
2184 constexpr typename basic_format_parse_context<_CharT>::iterator
2185 parse(basic_format_parse_context<_CharT>& __pc)
2186 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2188 template<
typename _Out>
2189 typename basic_format_context<_Out, _CharT>::iterator
2190 format(
const chrono::gps_time<_Duration>& __t,
2191 basic_format_context<_Out, _CharT>& __fc)
const
2198 constexpr chrono::days __gps_offset = chrono::days(3657);
2199 using _CDur = common_type_t<_Duration, chrono::days>;
2200 chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
2201 const string __abbrev(
"GPS", 3);
2202 const chrono::seconds __off = 0s;
2203 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2204 return _M_f._M_format(__lf, __fc);
2208 __format::__formatter_chrono<_CharT> _M_f;
2211 template<
typename _Duration, __format::__
char _CharT>
2212 struct formatter<chrono::file_time<_Duration>, _CharT>
2214 constexpr typename basic_format_parse_context<_CharT>::iterator
2215 parse(basic_format_parse_context<_CharT>& __pc)
2216 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2218 template<
typename _Out>
2219 typename basic_format_context<_Out, _CharT>::iterator
2220 format(
const chrono::file_time<_Duration>& __t,
2221 basic_format_context<_Out, _CharT>& __fc)
const
2223 using namespace chrono;
2224 return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __fc);
2228 __format::__formatter_chrono<_CharT> _M_f;
2231 template<
typename _Duration, __format::__
char _CharT>
2232 struct formatter<chrono::local_time<_Duration>, _CharT>
2234 constexpr typename basic_format_parse_context<_CharT>::iterator
2235 parse(basic_format_parse_context<_CharT>& __pc)
2236 {
return _M_f._M_parse(__pc, __format::_DateTime); }
2238 template<
typename _Out>
2239 typename basic_format_context<_Out, _CharT>::iterator
2240 format(
const chrono::local_time<_Duration>& __t,
2241 basic_format_context<_Out, _CharT>& __fc)
const
2242 {
return _M_f._M_format(__t, __fc); }
2245 __format::__formatter_chrono<_CharT> _M_f;
2248 template<
typename _Duration, __format::__
char _CharT>
2249 struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2251 constexpr typename basic_format_parse_context<_CharT>::iterator
2252 parse(basic_format_parse_context<_CharT>& __pc)
2253 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2255 template<
typename _Out>
2256 typename basic_format_context<_Out, _CharT>::iterator
2257 format(
const chrono::__detail::__local_time_fmt<_Duration>& __t,
2258 basic_format_context<_Out, _CharT>& __fc)
const
2259 {
return _M_f._M_format(__t, __fc,
true); }
2262 __format::__formatter_chrono<_CharT> _M_f;
2265#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2266 template<
typename _Duration,
typename _TimeZonePtr, __format::__
char _CharT>
2267 struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
2268 : formatter<chrono::__detail::__local_time_fmt_for<_Duration>, _CharT>
2270 template<
typename _Out>
2271 typename basic_format_context<_Out, _CharT>::iterator
2272 format(
const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
2273 basic_format_context<_Out, _CharT>& __fc)
const
2275 using _Ltf = chrono::__detail::__local_time_fmt_for<_Duration>;
2276 using _Base = formatter<_Ltf, _CharT>;
2277 const chrono::sys_info __info = __tp.get_info();
2278 const auto __lf = chrono::local_time_format(__tp.get_local_time(),
2281 return _Base::format(__lf, __fc);
2287 template<
typename _Duration, __format::__
char _CharT>
2288 struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
2289 : formatter<chrono::utc_time<_Duration>, _CharT>
2291 template<
typename _Out>
2292 typename basic_format_context<_Out, _CharT>::iterator
2293 format(
const chrono::__detail::__utc_leap_second<_Duration>& __t,
2294 basic_format_context<_Out, _CharT>& __fc)
const
2295 {
return this->_M_f._M_format(__t, __fc); }
2306 template<
typename _Duration = seconds>
2309 static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);
2312 _Parser(__format::_ChronoParts __need) : _M_need(__need) { }
2314 _Parser(_Parser&&) =
delete;
2315 void operator=(_Parser&&) =
delete;
2317 _Duration _M_time{};
2318 sys_days _M_sys_days{};
2319 year_month_day _M_ymd{};
2321 __format::_ChronoParts _M_need;
2322 unsigned _M_is_leap_second : 1 {};
2323 unsigned _M_reserved : 15 {};
2325 template<
typename _CharT,
typename _Traits,
typename _Alloc>
2326 basic_istream<_CharT, _Traits>&
2327 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2328 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2329 minutes* __offset =
nullptr);
2334 template<
typename _CharT,
typename _Traits>
2335 static int_least32_t
2336 _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
2337 ios_base::iostate& __err,
int __n)
2339 int_least32_t __val = _S_try_read_digit(__is, __err);
2340 if (__val == -1) [[unlikely]]
2341 __err |= ios_base::failbit;
2346 for (
int __i = 1; __i < __n1; ++__i)
2347 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2353 while (__n1++ < __n) [[unlikely]]
2354 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2356 if (__builtin_mul_overflow(__val, 10, &__val)
2357 || __builtin_add_overflow(__val, __dig, &__val))
2359 __err |= ios_base::failbit;
2369 template<
typename _CharT,
typename _Traits>
2370 static int_least32_t
2371 _S_read_signed(basic_istream<_CharT, _Traits>& __is,
2372 ios_base::iostate& __err,
int __n)
2374 auto __sign = __is.peek();
2375 if (__sign ==
'-' || __sign ==
'+')
2377 int_least32_t __val = _S_read_unsigned(__is, __err, __n);
2378 if (__err & ios_base::failbit)
2380 if (__sign ==
'-') [[unlikely]]
2388 template<
typename _CharT,
typename _Traits>
2389 static int_least32_t
2390 _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
2391 ios_base::iostate& __err)
2393 int_least32_t __val = -1;
2394 auto __i = __is.peek();
2395 if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
2397 _CharT __c = _Traits::to_char_type(__i);
2398 if (_CharT(
'0') <= __c && __c <= _CharT(
'9')) [[likely]]
2401 __val = __c - _CharT(
'0');
2405 __err |= ios_base::eofbit;
2411 template<
typename _CharT,
typename _Traits>
2413 _S_read_chr(basic_istream<_CharT, _Traits>& __is,
2414 ios_base::iostate& __err, _CharT __c)
2416 auto __i = __is.peek();
2417 if (_Traits::eq_int_type(__i, _Traits::eof()))
2418 __err |= ios_base::eofbit;
2419 else if (_Traits::to_char_type(__i) == __c) [[likely]]
2424 __err |= ios_base::failbit;
2429 template<
typename _Duration>
2430 using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;
2432 template<
typename _Duration>
2436 if constexpr (_Duration::period::den == 1)
2438 switch (_Duration::period::num)
2440 case minutes::period::num:
2441 case hours::period::num:
2442 case days::period::num:
2443 case weeks::period::num:
2444 case years::period::num:
2461 template<
typename _ToDur,
typename _Tp>
2463 __round(
const _Tp& __t)
2465 if constexpr (__is_duration_v<_Tp>)
2467 if constexpr (treat_as_floating_point_v<typename _Tp::rep>)
2468 return chrono::duration_cast<_ToDur>(__t);
2469 else if constexpr (__detail::__use_floor<_ToDur>())
2470 return chrono::floor<_ToDur>(__t);
2472 return chrono::round<_ToDur>(__t);
2476 static_assert(__is_time_point_v<_Tp>);
2477 using _Tpt = time_point<typename _Tp::clock, _ToDur>;
2478 return _Tpt(__detail::__round<_ToDur>(__t.time_since_epoch()));
2485 template<
typename _CharT,
typename _Traits,
typename _Rep,
typename _Period,
2486 typename _Alloc = allocator<_CharT>>
2487 inline basic_istream<_CharT, _Traits>&
2488 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2489 duration<_Rep, _Period>& __d,
2490 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2493 auto __need = __format::_ChronoParts::_TimeOfDay;
2494 __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
2495 if (__p(__is, __fmt, __abbrev, __offset))
2496 __d = __detail::__round<duration<_Rep, _Period>>(__p._M_time);
2500 template<
typename _CharT,
typename _Traits>
2501 inline basic_ostream<_CharT, _Traits>&
2502 operator<<(basic_ostream<_CharT, _Traits>& __os,
const day& __d)
2504 using _Ctx = __format::__format_context<_CharT>;
2505 using _Str = basic_string_view<_CharT>;
2506 _Str __s = _GLIBCXX_WIDEN(
"{:02d} is not a valid day");
2508 __s = __s.substr(0, 6);
2509 auto __u = (unsigned)__d;
2510 __os << std::vformat(__s, make_format_args<_Ctx>(__u));
2514 template<
typename _CharT,
typename _Traits,
2515 typename _Alloc = allocator<_CharT>>
2516 inline basic_istream<_CharT, _Traits>&
2517 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2519 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2522 __detail::_Parser<> __p(__format::_ChronoParts::_Day);
2523 if (__p(__is, __fmt, __abbrev, __offset))
2524 __d = __p._M_ymd.day();
2528 template<
typename _CharT,
typename _Traits>
2529 inline basic_ostream<_CharT, _Traits>&
2530 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month& __m)
2532 using _Ctx = __format::__format_context<_CharT>;
2533 using _Str = basic_string_view<_CharT>;
2534 _Str __s = _GLIBCXX_WIDEN(
"{:L%b}{} is not a valid month");
2537 make_format_args<_Ctx>(__m));
2540 auto __u = (unsigned)__m;
2541 __os <<
std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
2546 template<
typename _CharT,
typename _Traits,
2547 typename _Alloc = allocator<_CharT>>
2548 inline basic_istream<_CharT, _Traits>&
2549 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2551 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2554 __detail::_Parser<> __p(__format::_ChronoParts::_Month);
2555 if (__p(__is, __fmt, __abbrev, __offset))
2556 __m = __p._M_ymd.month();
2560 template<
typename _CharT,
typename _Traits>
2561 inline basic_ostream<_CharT, _Traits>&
2562 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year& __y)
2564 using _Ctx = __format::__format_context<_CharT>;
2565 using _Str = basic_string_view<_CharT>;
2566 _Str __s = _GLIBCXX_WIDEN(
"-{:04d} is not a valid year");
2568 __s = __s.substr(0, 7);
2570 if (__i >= 0) [[likely]]
2571 __s.remove_prefix(1);
2574 __os << std::vformat(__s, make_format_args<_Ctx>(__i));
2578 template<
typename _CharT,
typename _Traits,
2579 typename _Alloc = allocator<_CharT>>
2580 inline basic_istream<_CharT, _Traits>&
2581 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2583 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2586 __detail::_Parser<> __p(__format::_ChronoParts::_Year);
2587 if (__p(__is, __fmt, __abbrev, __offset))
2588 __y = __p._M_ymd.year();
2592 template<
typename _CharT,
typename _Traits>
2593 inline basic_ostream<_CharT, _Traits>&
2594 operator<<(basic_ostream<_CharT, _Traits>& __os,
const weekday& __wd)
2596 using _Ctx = __format::__format_context<_CharT>;
2597 using _Str = basic_string_view<_CharT>;
2598 _Str __s = _GLIBCXX_WIDEN(
"{:L%a}{} is not a valid weekday");
2601 make_format_args<_Ctx>(__wd));
2604 auto __c = __wd.c_encoding();
2605 __os <<
std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
2610 template<
typename _CharT,
typename _Traits,
2611 typename _Alloc = allocator<_CharT>>
2612 inline basic_istream<_CharT, _Traits>&
2613 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2615 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2618 __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
2619 if (__p(__is, __fmt, __abbrev, __offset))
2624 template<
typename _CharT,
typename _Traits>
2625 inline basic_ostream<_CharT, _Traits>&
2626 operator<<(basic_ostream<_CharT, _Traits>& __os,
2627 const weekday_indexed& __wdi)
2632 basic_stringstream<_CharT> __os2;
2633 __os2.imbue(__os.getloc());
2634 __os2 << __wdi.weekday();
2635 const auto __i = __wdi.index();
2636 basic_string_view<_CharT> __s
2637 = _GLIBCXX_WIDEN(
"[ is not a valid index]");
2639 __os2 << std::format(_GLIBCXX_WIDEN(
"{}"), __i);
2640 if (__i >= 1 && __i <= 5)
2641 __os2 << __s.back();
2643 __os2 << __s.substr(1);
2644 __os << __os2.view();
2648 template<
typename _CharT,
typename _Traits>
2649 inline basic_ostream<_CharT, _Traits>&
2650 operator<<(basic_ostream<_CharT, _Traits>& __os,
2651 const weekday_last& __wdl)
2654 basic_stringstream<_CharT> __os2;
2655 __os2.imbue(__os.getloc());
2656 __os2 << __wdl.weekday() << _GLIBCXX_WIDEN(
"[last]");
2657 __os << __os2.view();
2661 template<
typename _CharT,
typename _Traits>
2662 inline basic_ostream<_CharT, _Traits>&
2663 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month_day& __md)
2666 basic_stringstream<_CharT> __os2;
2667 __os2.imbue(__os.getloc());
2668 __os2 << __md.month();
2669 if constexpr (is_same_v<_CharT, char>)
2673 __os2 << __md.day();
2674 __os << __os2.view();
2678 template<
typename _CharT,
typename _Traits,
2679 typename _Alloc = allocator<_CharT>>
2680 inline basic_istream<_CharT, _Traits>&
2681 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2683 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2686 using __format::_ChronoParts;
2687 auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
2688 __detail::_Parser<> __p(__need);
2689 if (__p(__is, __fmt, __abbrev, __offset))
2690 __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
2694 template<
typename _CharT,
typename _Traits>
2695 inline basic_ostream<_CharT, _Traits>&
2696 operator<<(basic_ostream<_CharT, _Traits>& __os,
2697 const month_day_last& __mdl)
2700 basic_stringstream<_CharT> __os2;
2701 __os2.imbue(__os.getloc());
2702 __os2 << __mdl.month() << _GLIBCXX_WIDEN(
"/last");
2703 __os << __os2.view();
2707 template<
typename _CharT,
typename _Traits>
2708 inline basic_ostream<_CharT, _Traits>&
2709 operator<<(basic_ostream<_CharT, _Traits>& __os,
2710 const month_weekday& __mwd)
2713 basic_stringstream<_CharT> __os2;
2714 __os2.imbue(__os.getloc());
2715 __os2 << __mwd.month();
2716 if constexpr (is_same_v<_CharT, char>)
2720 __os2 << __mwd.weekday_indexed();
2721 __os << __os2.view();
2725 template<
typename _CharT,
typename _Traits>
2726 inline basic_ostream<_CharT, _Traits>&
2727 operator<<(basic_ostream<_CharT, _Traits>& __os,
2728 const month_weekday_last& __mwdl)
2731 basic_stringstream<_CharT> __os2;
2732 __os2.imbue(__os.getloc());
2733 __os2 << __mwdl.month();
2734 if constexpr (is_same_v<_CharT, char>)
2738 __os2 << __mwdl.weekday_last();
2739 __os << __os2.view();
2743 template<
typename _CharT,
typename _Traits>
2744 inline basic_ostream<_CharT, _Traits>&
2745 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year_month& __ym)
2748 basic_stringstream<_CharT> __os2;
2749 __os2.imbue(__os.getloc());
2750 __os2 << __ym.year();
2751 if constexpr (is_same_v<_CharT, char>)
2755 __os2 << __ym.month();
2756 __os << __os2.view();
2760 template<
typename _CharT,
typename _Traits,
2761 typename _Alloc = allocator<_CharT>>
2762 inline basic_istream<_CharT, _Traits>&
2763 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2765 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2768 using __format::_ChronoParts;
2769 auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
2770 __detail::_Parser<> __p(__need);
2771 if (__p(__is, __fmt, __abbrev, __offset))
2772 __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
2776 template<
typename _CharT,
typename _Traits>
2777 inline basic_ostream<_CharT, _Traits>&
2778 operator<<(basic_ostream<_CharT, _Traits>& __os,
2779 const year_month_day& __ymd)
2781 using _Ctx = __format::__format_context<_CharT>;
2782 using _Str = basic_string_view<_CharT>;
2783 _Str __s = _GLIBCXX_WIDEN(
"{:%F} is not a valid date");
2784 __os <<
std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
2785 make_format_args<_Ctx>(__ymd));
2789 template<
typename _CharT,
typename _Traits,
2790 typename _Alloc = allocator<_CharT>>
2791 inline basic_istream<_CharT, _Traits>&
2793 year_month_day&
__ymd,
2797 using __format::_ChronoParts;
2798 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2799 | _ChronoParts::_Day;
2800 __detail::_Parser<> __p(
__need);
2806 template<
typename _CharT,
typename _Traits>
2809 const year_month_day_last&
__ymdl)
2824 template<
typename _CharT,
typename _Traits>
2825 inline basic_ostream<_CharT, _Traits>&
2826 operator<<(basic_ostream<_CharT, _Traits>& __os,
2827 const year_month_weekday& __ymwd)
2831 basic_stringstream<_CharT> __os2;
2832 __os2.imbue(__os.getloc());
2834 if constexpr (is_same_v<_CharT, char>)
2838 __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
2839 << __ymwd.weekday_indexed();
2840 __os << __os2.view();
2844 template<
typename _CharT,
typename _Traits>
2845 inline basic_ostream<_CharT, _Traits>&
2846 operator<<(basic_ostream<_CharT, _Traits>& __os,
2847 const year_month_weekday_last& __ymwdl)
2851 basic_stringstream<_CharT> __os2;
2852 __os2.imbue(__os.getloc());
2854 if constexpr (is_same_v<_CharT, char>)
2858 __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
2859 << __ymwdl.weekday_last();
2860 __os << __os2.view();
2864 template<
typename _CharT,
typename _Traits,
typename _Duration>
2865 inline basic_ostream<_CharT, _Traits>&
2866 operator<<(basic_ostream<_CharT, _Traits>& __os,
2867 const hh_mm_ss<_Duration>& __hms)
2869 return __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%T}"), __hms);
2872#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2874 template<
typename _CharT,
typename _Traits>
2875 basic_ostream<_CharT, _Traits>&
2876 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_info& __i)
2878 __os <<
'[' << __i.begin <<
',' << __i.end
2879 <<
',' << hh_mm_ss(__i.offset) <<
',' << __i.save
2880 <<
',' << __i.abbrev <<
']';
2885 template<
typename _CharT,
typename _Traits>
2886 basic_ostream<_CharT, _Traits>&
2887 operator<<(basic_ostream<_CharT, _Traits>& __os,
const local_info& __li)
2890 if (__li.result == local_info::unique)
2894 if (__li.result == local_info::nonexistent)
2895 __os <<
"nonexistent";
2897 __os <<
"ambiguous";
2898 __os <<
" local time between " << __li.first;
2899 __os <<
" and " << __li.second;
2905 template<
typename _CharT,
typename _Traits,
typename _Duration,
2906 typename _TimeZonePtr>
2907 inline basic_ostream<_CharT, _Traits>&
2908 operator<<(basic_ostream<_CharT, _Traits>& __os,
2909 const zoned_time<_Duration, _TimeZonePtr>& __t)
2911 __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T %Z}"), __t);
2916 template<
typename _CharT,
typename _Traits,
typename _Duration>
2917 requires (!treat_as_floating_point_v<typename _Duration::rep>)
2918 && ratio_less_v<typename _Duration::period, days::period>
2919 inline basic_ostream<_CharT, _Traits>&
2920 operator<<(basic_ostream<_CharT, _Traits>& __os,
2921 const sys_time<_Duration>& __tp)
2923 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __tp);
2927 template<
typename _CharT,
typename _Traits>
2928 inline basic_ostream<_CharT, _Traits>&
2929 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_days& __dp)
2931 __os << year_month_day{__dp};
2935 template<
typename _CharT,
typename _Traits,
typename _Duration,
2936 typename _Alloc = allocator<_CharT>>
2937 basic_istream<_CharT, _Traits>&
2938 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2939 sys_time<_Duration>& __tp,
2940 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2946 using __format::_ChronoParts;
2947 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2948 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2949 __detail::_Parser_t<_Duration> __p(__need);
2950 if (__p(__is, __fmt, __abbrev, __offset))
2952 if (__p._M_is_leap_second)
2956 auto __st = __p._M_sys_days + __p._M_time - *__offset;
2957 __tp = __detail::__round<_Duration>(__st);
2963 template<
typename _CharT,
typename _Traits,
typename _Duration>
2964 inline basic_ostream<_CharT, _Traits>&
2965 operator<<(basic_ostream<_CharT, _Traits>& __os,
2966 const utc_time<_Duration>& __t)
2968 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2972 template<
typename _CharT,
typename _Traits,
typename _Duration,
2973 typename _Alloc = allocator<_CharT>>
2974 inline basic_istream<_CharT, _Traits>&
2975 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2976 utc_time<_Duration>& __tp,
2977 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2983 using __format::_ChronoParts;
2984 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2985 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2986 __detail::_Parser_t<_Duration> __p(__need);
2987 if (__p(__is, __fmt, __abbrev, __offset))
2991 auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
2993 __tp = __detail::__round<_Duration>(__ut);
2998 template<
typename _CharT,
typename _Traits,
typename _Duration>
2999 inline basic_ostream<_CharT, _Traits>&
3000 operator<<(basic_ostream<_CharT, _Traits>& __os,
3001 const tai_time<_Duration>& __t)
3003 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3007 template<
typename _CharT,
typename _Traits,
typename _Duration,
3008 typename _Alloc = allocator<_CharT>>
3009 inline basic_istream<_CharT, _Traits>&
3010 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3011 tai_time<_Duration>& __tp,
3012 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3018 using __format::_ChronoParts;
3019 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3020 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3021 __detail::_Parser_t<_Duration> __p(__need);
3022 if (__p(__is, __fmt, __abbrev, __offset))
3024 if (__p._M_is_leap_second)
3028 constexpr sys_days __epoch(-
days(4383));
3029 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3030 tai_time<common_type_t<_Duration, seconds>> __tt(__d);
3031 __tp = __detail::__round<_Duration>(__tt);
3037 template<
typename _CharT,
typename _Traits,
typename _Duration>
3038 inline basic_ostream<_CharT, _Traits>&
3039 operator<<(basic_ostream<_CharT, _Traits>& __os,
3040 const gps_time<_Duration>& __t)
3042 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3046 template<
typename _CharT,
typename _Traits,
typename _Duration,
3047 typename _Alloc = allocator<_CharT>>
3048 inline basic_istream<_CharT, _Traits>&
3049 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3050 gps_time<_Duration>& __tp,
3051 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3057 using __format::_ChronoParts;
3058 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3059 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3060 __detail::_Parser_t<_Duration> __p(__need);
3061 if (__p(__is, __fmt, __abbrev, __offset))
3063 if (__p._M_is_leap_second)
3067 constexpr sys_days __epoch(
days(3657));
3068 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3069 gps_time<common_type_t<_Duration, seconds>> __gt(__d);
3070 __tp = __detail::__round<_Duration>(__gt);
3076 template<
typename _CharT,
typename _Traits,
typename _Duration>
3077 inline basic_ostream<_CharT, _Traits>&
3078 operator<<(basic_ostream<_CharT, _Traits>& __os,
3079 const file_time<_Duration>& __t)
3081 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3085 template<
typename _CharT,
typename _Traits,
typename _Duration,
3086 typename _Alloc = allocator<_CharT>>
3087 inline basic_istream<_CharT, _Traits>&
3088 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3089 file_time<_Duration>& __tp,
3090 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3093 sys_time<_Duration> __st;
3094 if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
3095 __tp = __detail::__round<_Duration>(file_clock::from_sys(__st));
3099 template<
typename _CharT,
typename _Traits,
typename _Duration>
3100 inline basic_ostream<_CharT, _Traits>&
3101 operator<<(basic_ostream<_CharT, _Traits>& __os,
3102 const local_time<_Duration>& __lt)
3104 __os << sys_time<_Duration>{__lt.time_since_epoch()};
3108 template<
typename _CharT,
typename _Traits,
typename _Duration,
3109 typename _Alloc = allocator<_CharT>>
3110 basic_istream<_CharT, _Traits>&
3111 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3112 local_time<_Duration>& __tp,
3113 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3116 using __format::_ChronoParts;
3117 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3118 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3119 __detail::_Parser_t<_Duration> __p(__need);
3120 if (__p(__is, __fmt, __abbrev, __offset))
3122 days __d = __p._M_sys_days.time_since_epoch();
3123 auto __t = local_days(__d) + __p._M_time;
3124 __tp = __detail::__round<_Duration>(__t);
3135 void from_stream() =
delete;
3137 template<
typename _Parsable,
typename _CharT,
3139 typename... _OptArgs>
3140 concept __parsable =
requires (basic_istream<_CharT, _Traits>& __is,
3141 const _CharT* __fmt, _Parsable& __tp,
3142 _OptArgs*... __args)
3143 { from_stream(__is, __fmt, __tp, __args...); };
3145 template<
typename _Parsable,
typename _CharT,
3146 typename _Traits = char_traits<_CharT>,
3147 typename _Alloc = allocator<_CharT>>
3151 using __string_type = basic_string<_CharT, _Traits, _Alloc>;
3154 _Parse(
const _CharT* __fmt, _Parsable& __tp,
3155 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3158 _M_abbrev(__abbrev), _M_offset(__offset)
3161 _Parse(_Parse&&) =
delete;
3162 _Parse& operator=(_Parse&&) =
delete;
3165 using __stream_type = basic_istream<_CharT, _Traits>;
3167 const _CharT*
const _M_fmt;
3168 _Parsable*
const _M_tp;
3169 __string_type*
const _M_abbrev;
3172 friend __stream_type&
3173 operator>>(__stream_type& __is, _Parse&& __p)
3176 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
3178 else if (__p._M_abbrev)
3179 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
3181 from_stream(__is, __p._M_fmt, *__p._M_tp);
3185 friend void operator>>(__stream_type&, _Parse&) =
delete;
3186 friend void operator>>(__stream_type&,
const _Parse&) =
delete;
3190 template<
typename _CharT, __detail::__parsable<_CharT> _Parsable>
3191 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3193 parse(
const _CharT* __fmt, _Parsable& __tp)
3194 {
return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }
3196 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3197 __detail::__parsable<_CharT, _Traits> _Parsable>
3200 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
3202 return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
3205 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3206 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3207 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3208 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3210 parse(
const _CharT* __fmt, _Parsable& __tp,
3211 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3214 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3218 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3219 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3220 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3223 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3224 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3227 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3231 template<
typename _CharT,
typename _Traits =
char_traits<_CharT>,
3232 typename _StrT = basic_
string<_CharT, _Traits>,
3233 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3234 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3236 parse(
const _CharT* __fmt, _Parsable& __tp,
minutes& __offset)
3238 return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp,
nullptr,
3242 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3243 typename _StrT = basic_string<_CharT, _Traits>,
3244 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3247 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3250 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3255 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3256 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3257 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3258 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3260 parse(
const _CharT* __fmt, _Parsable& __tp,
3261 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3264 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3269 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3270 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3271 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3274 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3275 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3278 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3284 template<
typename _Duration>
3285 template<
typename _CharT,
typename _Traits,
typename _Alloc>
3286 basic_istream<_CharT, _Traits>&
3287 __detail::_Parser<_Duration>::
3288 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3289 basic_string<_CharT, _Traits, _Alloc>* __abbrev,
3292 using sentry =
typename basic_istream<_CharT, _Traits>::sentry;
3294 if (sentry __cerb(__is,
true); __cerb)
3296 locale __loc = __is.getloc();
3301 struct _Stream_state
3304 _Stream_state(basic_istream<_CharT, _Traits>& __i)
3306 _M_flags(__i.flags(ios_base::
skipws | ios_base::
dec)),
3312 _M_is.flags(_M_flags);
3316 _Stream_state(_Stream_state&&) =
delete;
3318 basic_istream<_CharT, _Traits>& _M_is;
3319 ios_base::fmtflags _M_flags;
3329 auto __read_unsigned = [&] (
int __n) {
3330 return _S_read_unsigned(__is, __err, __n);
3335 auto __read_signed = [&] (
int __n) {
3336 return _S_read_signed(__is, __err, __n);
3340 auto __read_chr = [&__is, &__err] (_CharT __c) {
3341 return _S_read_chr(__is, __err, __c);
3344 using __format::_ChronoParts;
3345 _ChronoParts __parts{};
3347 const year __bad_y = --year::min();
3348 const month __bad_mon(255);
3349 const day __bad_day(255);
3350 const weekday __bad_wday(255);
3351 const hours __bad_h(-1);
3352 const minutes __bad_min(-9999);
3355 year __y = __bad_y, __yy = __bad_y;
3356 year __iso_y = __bad_y, __iso_yy = __bad_y;
3357 month __m = __bad_mon;
3358 day __d = __bad_day;
3359 weekday __wday = __bad_wday;
3360 hours __h = __bad_h, __h12 = __bad_h;
3362 _Duration __s = __bad_sec;
3364 int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1;
3366 int __dayofyear = -1;
3368 minutes __tz_offset = __bad_min;
3369 basic_string<_CharT, _Traits> __tz_abbr;
3371 if ((_M_need & _ChronoParts::_TimeOfDay)
3372 && (_M_need & _ChronoParts::_Year))
3378 __parts = _ChronoParts::_TimeOfDay;
3385 bool __is_flag =
false;
3387 constexpr bool __is_floating
3388 = treat_as_floating_point_v<typename _Duration::rep>;
3407 _CharT __c = *__fmt++;
3414 else if (!__read_chr(__c)) [[unlikely]]
3425 if (__mod || __num) [[unlikely]]
3430 __tmget.get(__is, {}, __is, __err, &__tm,
3432 if (!__is_failed(__err))
3433 __wday = weekday(__tm.tm_wday);
3435 __parts |= _ChronoParts::_Weekday;
3441 if (__mod || __num) [[unlikely]]
3449 __tmget.get(__is, {}, __is, __err, &__tm,
3451 if (!__is_failed(__err))
3452 __m = month(__tm.tm_mon + 1);
3454 __parts |= _ChronoParts::_Month;
3458 if (__mod ==
'O' || __num) [[unlikely]]
3463 __tmget.get(__is, {}, __is, __err, &__tm,
3464 __fmt - 2 - (__mod ==
'E'), __fmt);
3465 if (!__is_failed(__err))
3467 __y = year(__tm.tm_year + 1900);
3468 __m = month(__tm.tm_mon + 1);
3469 __d = day(__tm.tm_mday);
3470 __h =
hours(__tm.tm_hour);
3475 __parts |= _ChronoParts::_DateTime;
3479 if (!__mod) [[likely]]
3481 auto __v = __read_signed(__num ? __num : 2);
3482 if (!__is_failed(__err))
3484 int __cmin = (int)year::min() / 100;
3485 int __cmax = (int)year::max() / 100;
3486 if (__cmin <= __v && __v <= __cmax)
3487 __century = __v * 100;
3492 else if (__mod ==
'E')
3495 __tmget.get(__is, {}, __is, __err, &__tm,
3497 if (!__is_failed(__err))
3498 __century = __tm.tm_year;
3507 if (!__mod) [[likely]]
3509 auto __v = __read_unsigned(__num ? __num : 2);
3510 if (!__is_failed(__err))
3513 else if (__mod ==
'O')
3516 __tmget.get(__is, {}, __is, __err, &__tm,
3518 if (!__is_failed(__err))
3519 __d = day(__tm.tm_mday);
3523 __parts |= _ChronoParts::_Day;
3527 if (__mod || __num) [[unlikely]]
3531 auto __month = __read_unsigned(2);
3533 auto __day = __read_unsigned(2);
3535 auto __year = __read_unsigned(2);
3536 if (__is_failed(__err))
3538 __y = year(__year + 1900 + 100 *
int(__year < 69));
3539 __m = month(__month);
3541 if (!year_month_day(__y, __m, __d).ok())
3543 __y = __yy = __iso_y = __iso_yy = __bad_y;
3549 __parts |= _ChronoParts::_Date;
3553 if (__mod) [[unlikely]]
3557 auto __year = __read_signed(__num ? __num : 4);
3559 auto __month = __read_unsigned(2);
3561 auto __day = __read_unsigned(2);
3562 if (__is_failed(__err))
3565 __m = month(__month);
3567 if (!year_month_day(__y, __m, __d).ok())
3569 __y = __yy = __iso_y = __iso_yy = __bad_y;
3575 __parts |= _ChronoParts::_Date;
3579 if (__mod) [[unlikely]]
3583 auto __val = __read_unsigned(__num ? __num : 2);
3584 if (__val >= 0 && __val <= 99)
3586 __iso_yy = year(__val);
3587 if (__century == -1)
3591 __iso_yy = __iso_y = __y = __yy = __bad_y;
3593 __parts |= _ChronoParts::_Year;
3597 if (__mod) [[unlikely]]
3600 __iso_y = year(__read_unsigned(__num ? __num : 4));
3601 __parts |= _ChronoParts::_Year;
3606 if (__mod ==
'E') [[unlikely]]
3608 else if (__mod ==
'O')
3613 __tmget.get(__is, {}, __is, __err, &__tm,
3615 if (!__is_failed(__err))
3619 __h12 =
hours(__tm.tm_hour);
3623 __h =
hours(__tm.tm_hour);
3632 auto __val = __read_unsigned(__num ? __num : 2);
3633 if (__c ==
'I' && __val >= 1 && __val <= 12)
3635 __h12 =
hours(__val);
3638 else if (__c ==
'H' && __val >= 0 && __val <= 23)
3645 if (_M_need & _ChronoParts::_TimeOfDay)
3650 __parts |= _ChronoParts::_TimeOfDay;
3654 if (__mod) [[unlikely]]
3656 else if (_M_need == _ChronoParts::_TimeOfDay)
3658 auto __val = __read_signed(__num ? __num : 3);
3659 if (!__is_failed(__err))
3662 __parts |= _ChronoParts::_TimeOfDay;
3667 __dayofyear = __read_unsigned(__num ? __num : 3);
3674 if (__mod ==
'E') [[unlikely]]
3676 else if (__mod ==
'O')
3679 __tmget.get(__is, {}, __is, __err, &__tm,
3681 if (!__is_failed(__err))
3682 __m = month(__tm.tm_mon + 1);
3686 auto __val = __read_unsigned(__num ? __num : 2);
3687 if (__val >= 1 && __val <= 12)
3692 __parts |= _ChronoParts::_Month;
3696 if (__mod ==
'E') [[unlikely]]
3698 else if (__mod ==
'O')
3701 __tmget.get(__is, {}, __is, __err, &__tm,
3703 if (!__is_failed(__err))
3708 auto __val = __read_unsigned(__num ? __num : 2);
3709 if (0 <= __val && __val < 60)
3713 if (_M_need & _ChronoParts::_TimeOfDay)
3718 __parts |= _ChronoParts::_TimeOfDay;
3728 const _CharT* __ampms[2];
3729 __tmpunct._M_am_pm(__ampms);
3730 int __n = 0, __which = 3;
3731 while (__which != 0)
3733 auto __i = __is.peek();
3734 if (_Traits::eq_int_type(__i, _Traits::eof()))
3744 else if (__ampms[0][__n + 1] == _CharT())
3755 else if (__ampms[1][__n + 1] == _CharT())
3766 if (__which == 0 || __which == 3)
3779 __tmget.get(__is, {}, __is, __err, &__tm,
3781 if (!__is_failed(__err))
3783 __h =
hours(__tm.tm_hour);
3788 __parts |= _ChronoParts::_TimeOfDay;
3793 if (__mod || __num) [[unlikely]]
3800 auto __val = __read_unsigned(2);
3801 if (__val == -1 || __val > 23) [[unlikely]]
3803 if (_M_need & _ChronoParts::_TimeOfDay)
3807 if (!__read_chr(
':')) [[unlikely]]
3811 __val = __read_unsigned(2);
3812 if (__val == -1 || __val > 60) [[unlikely]]
3814 if (_M_need & _ChronoParts::_TimeOfDay)
3822 __parts |= _ChronoParts::_TimeOfDay;
3825 else if (!__read_chr(
':')) [[unlikely]]
3831 if (__mod ==
'E') [[unlikely]]
3833 else if (__mod ==
'O')
3836 __tmget.get(__is, {}, __is, __err, &__tm,
3838 if (!__is_failed(__err))
3841 else if constexpr (_Duration::period::den == 1
3844 auto __val = __read_unsigned(__num ? __num : 2);
3845 if (0 <= __val && __val <= 59) [[likely]]
3849 if (_M_need & _ChronoParts::_TimeOfDay)
3856 basic_stringstream<_CharT> __buf;
3857 auto __digit = _S_try_read_digit(__is, __err);
3860 __buf.put(_CharT(
'0') + __digit);
3861 __digit = _S_try_read_digit(__is, __err);
3863 __buf.put(_CharT(
'0') + __digit);
3866 auto __i = __is.peek();
3867 if (_Traits::eq_int_type(__i, _Traits::eof()))
3874 auto& __np = use_facet<numpunct<_CharT>>(__loc);
3875 __dp = __np.decimal_point();
3877 _CharT __c = _Traits::to_char_type(__i);
3883 = hh_mm_ss<_Duration>::fractional_width;
3886 __digit = _S_try_read_digit(__is, __err);
3888 __buf.put(_CharT(
'0') + __digit);
3896 if (!__is_failed(__err)) [[likely]]
3898 long double __val{};
3899#if __cpp_lib_to_chars
3901 auto __first = __str.data();
3902 auto __last = __first + __str.size();
3906 if ((
bool)ec || ptr != __last) [[unlikely]]
3913 duration<long double> __fs(__val);
3914 if constexpr (__is_floating)
3917 __s = chrono::round<_Duration>(__fs);
3921 __parts |= _ChronoParts::_TimeOfDay;
3926 if (__mod ==
'E') [[unlikely]]
3928 else if (__mod ==
'O')
3933 __tmget.get(__is, {}, __is, __err, &__tm,
3935 if (!__is_failed(__err))
3936 __wday = weekday(__tm.tm_wday);
3943 const int __lo = __c ==
'u' ? 1 : 0;
3944 const int __hi = __lo + 6;
3945 auto __val = __read_unsigned(__num ? __num : 1);
3946 if (__lo <= __val && __val <= __hi)
3947 __wday = weekday(__val);
3950 __wday = __bad_wday;
3954 __parts |= _ChronoParts::_Weekday;
3960 if (__mod ==
'E') [[unlikely]]
3962 else if (__mod ==
'O')
3964 if (__c ==
'V') [[unlikely]]
3974 const int __lo = __c ==
'V' ? 1 : 0;
3975 const int __hi = 53;
3976 auto __val = __read_unsigned(__num ? __num : 2);
3977 if (__lo <= __val && __val <= __hi)
3982 __sunday_wk = __val;
3988 __monday_wk = __val;
3993 __iso_wk = __sunday_wk = __monday_wk = -1;
3999 if (__mod ==
'O' || __num) [[unlikely]]
4004 __tmget.get(__is, {}, __is, __err, &__tm,
4005 __fmt - 2 - (__mod ==
'E'), __fmt);
4006 if (!__is_failed(__err))
4008 __y = year(__tm.tm_year + 1900);
4009 __m = month(__tm.tm_mon + 1);
4010 __d = day(__tm.tm_mday);
4013 __parts |= _ChronoParts::_Date;
4017 if (__mod ==
'O' || __num) [[unlikely]]
4022 __tmget.get(__is, {}, __is, __err, &__tm,
4023 __fmt - 2 - (__mod ==
'E'), __fmt);
4024 if (!__is_failed(__err))
4026 __h =
hours(__tm.tm_hour);
4031 __parts |= _ChronoParts::_TimeOfDay;
4035 if (__mod) [[unlikely]]
4038 __tmget.get(__is, {}, __is, __err, &__tm,
4040 if (!__is_failed(__err))
4042 int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
4043 __yy = year(__tm.tm_year - __cent);
4044 if (__century == -1)
4050 auto __val = __read_unsigned(__num ? __num : 2);
4051 if (__val >= 0 && __val <= 99)
4054 if (__century == -1)
4055 __century = __val < 69 ? 2000 : 1900;
4058 __y = __yy = __iso_yy = __iso_y = __bad_y;
4060 __parts |= _ChronoParts::_Year;
4064 if (__mod ==
'O') [[unlikely]]
4066 else if (__mod ==
'E')
4069 __tmget.get(__is, {}, __is, __err, &__tm,
4071 if (!__is_failed(__err))
4072 __y = year(__tm.tm_year);
4076 auto __val = __read_unsigned(__num ? __num : 4);
4077 if (!__is_failed(__err))
4080 __parts |= _ChronoParts::_Year;
4084 if (__num) [[unlikely]]
4091 auto __i = __is.peek();
4092 if (_Traits::eq_int_type(__i, _Traits::eof()))
4097 _CharT __ic = _Traits::to_char_type(__i);
4098 const bool __neg = __ic == _CharT(
'-');
4099 if (__ic == _CharT(
'-') || __ic == _CharT(
'+'))
4106 __hh = __read_unsigned(2);
4111 __hh = 10 * _S_try_read_digit(__is, __err);
4112 __hh += _S_try_read_digit(__is, __err);
4115 if (__is_failed(__err))
4119 if (_Traits::eq_int_type(__i, _Traits::eof()))
4122 __tz_offset =
minutes(__hh * (__neg ? -60 : 60));
4125 __ic = _Traits::to_char_type(__i);
4127 bool __read_mm =
false;
4130 if (__ic == _GLIBCXX_WIDEN(
":")[0])
4137 else if (_CharT(
'0') <= __ic && __ic <= _CharT(
'9'))
4143 int_least32_t __mm = 0;
4146 __mm = 10 * _S_try_read_digit(__is, __err);
4147 __mm += _S_try_read_digit(__is, __err);
4150 if (!__is_failed(__err))
4152 auto __z = __hh * 60 + __mm;
4153 __tz_offset =
minutes(__neg ? -__z : __z);
4159 if (__mod || __num) [[unlikely]]
4163 basic_string_view<_CharT> __x = _GLIBCXX_WIDEN(
"_/-+");
4167 auto __i = __is.peek();
4168 if (!_Traits::eq_int_type(__i, _Traits::eof()))
4170 _CharT __a = _Traits::to_char_type(__i);
4172 || __x.find(__a) != __x.npos)
4174 __tz_abbr.push_back(__a);
4183 if (__tz_abbr.empty())
4189 if (__mod || __num) [[unlikely]]
4193 _CharT __i = __is.peek();
4194 if (_Traits::eq_int_type(__i, _Traits::eof()))
4196 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4204 if (__mod || __num) [[unlikely]]
4208 _CharT __i = __is.peek();
4209 if (_Traits::eq_int_type(__i, _Traits::eof()))
4211 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4217 if (__mod || __num) [[unlikely]]
4225 if (__mod || __num) [[unlikely]]
4234 if (_CharT(
'1') <= __c && __c <= _CharT(
'9'))
4236 if (!__mod) [[likely]]
4239 auto __end = __fmt + _Traits::length(__fmt);
4241 = __format::__parse_integer(__fmt - 1, __end);
4242 if (__ptr) [[likely]]
4253 if (__is_failed(__err)) [[unlikely]]
4263 if (__yy != __bad_y && __y == __bad_y)
4264 __y =
years(__century) + __yy;
4265 if (__iso_yy != __bad_y && __iso_y == __bad_y)
4266 __iso_y =
years(__century) + __iso_yy;
4269 bool __can_use_doy =
false;
4270 bool __can_use_iso_wk =
false;
4271 bool __can_use_sun_wk =
false;
4272 bool __can_use_mon_wk =
false;
4275 if (__y != __bad_y && __dayofyear >= 0)
4277 __can_use_doy =
true;
4278 __parts |= _ChronoParts::_Date;
4280 else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
4282 __can_use_sun_wk =
true;
4283 __parts |= _ChronoParts::_Date;
4285 else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
4287 __can_use_mon_wk =
true;
4288 __parts |= _ChronoParts::_Date;
4290 else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
4293 __can_use_iso_wk =
true;
4294 __parts |= _ChronoParts::_Date;
4297 if (__is_failed(__err)) [[unlikely]]
4299 else if (__is_flag) [[unlikely]]
4301 else if ((_M_need & __parts) == _M_need) [[likely]]
4323 const bool __need_wday = _M_need & _ChronoParts::_Weekday;
4327 const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;
4329 if (__need_wday && __wday != __bad_wday)
4331 else if (_M_need & _ChronoParts::_Date)
4335 const bool __need_ymd = !__need_wday && !__need_time;
4337 if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
4338 || (_M_need & _ChronoParts::_Month && __m == __bad_mon)
4339 || (_M_need & _ChronoParts::_Day && __d == __bad_day))
4346 if ((0 < __dayofyear && __dayofyear <= 365)
4347 || (__dayofyear == 366 && __y.is_leap()))
4350 _M_sys_days = sys_days(__y/January/1)
4351 +
days(__dayofyear - 1);
4353 _M_ymd = year_month_day(_M_sys_days);
4358 else if (__can_use_iso_wk)
4366 const sys_days __jan4(__iso_y/January/4);
4367 weekday __wd1(__jan4 -
days(3));
4368 if (__wd1 != Thursday)
4369 if (__wd1 != Wednesday || !__iso_y.is_leap())
4373 if (!__is_failed(__err)) [[likely]]
4376 sys_days __w(Thursday[1]/January/__iso_y);
4378 __w -= Thursday - Monday;
4380 __w += __wday - Monday;
4384 _M_ymd = year_month_day(_M_sys_days);
4387 else if (__can_use_sun_wk)
4390 sys_days __wk1(__y/January/Sunday[1]);
4391 _M_sys_days = __wk1 +
weeks(__sunday_wk - 1)
4392 +
days(__wday.c_encoding());
4393 _M_ymd = year_month_day(_M_sys_days);
4394 if (_M_ymd.year() != __y) [[unlikely]]
4397 else if (__can_use_mon_wk)
4400 sys_days __wk1(__y/January/Monday[1]);
4401 _M_sys_days = __wk1 +
weeks(__monday_wk - 1)
4402 +
days(__wday.c_encoding() - 1);
4403 _M_ymd = year_month_day(_M_sys_days);
4404 if (_M_ymd.year() != __y) [[unlikely]]
4416 if (_M_need & _ChronoParts::_Year)
4418 if (!__y.ok()) [[unlikely]]
4421 else if (__y == __bad_y)
4424 if (_M_need & _ChronoParts::_Month)
4426 if (!__m.ok()) [[unlikely]]
4429 else if (__m == __bad_mon)
4432 if (_M_need & _ChronoParts::_Day)
4434 if (__d < day(1) || __d > (__y/__m/last).day())
4437 else if (__d == __bad_day)
4440 if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
4443 if (__need_wday || __need_time)
4444 _M_sys_days = sys_days(_M_ymd);
4451 _M_wd = weekday(_M_sys_days);
4457 if (__h == __bad_h && __h12 != __bad_h)
4461 else if (__ampm == 2)
4462 __h = __h12 ==
hours(12) ? __h12 : __h12 +
hours(12);
4467 auto __t = _M_time.zero();
4476 if (__min != __bad_min)
4482 if (__s != __bad_sec)
4486 _M_is_leap_second = __s >=
seconds(60);
4495 if (!__is_failed(__err)) [[likely]]
4497 if (__offset && __tz_offset != __bad_min)
4498 *__offset = __tz_offset;
4499 if (__abbrev && !__tz_abbr.empty())
4507 __is.setstate(__err);
4511#undef _GLIBCXX_WIDEN
4516_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.
_Ios_Iostate iostate
This is a bitmask type.
static const iostate eofbit
Indicates that an input operation reached the end of an input sequence.
static const iostate goodbit
Indicates all is well.
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.