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);
786 else if constexpr (is_convertible_v<_Tp, chrono::local_days>)
787 __os << _S_date(__t);
790 auto __days = chrono::floor<chrono::days>(__t);
791 __os << chrono::year_month_day(__days) <<
' '
792 << chrono::hh_mm_ss(__t - __days);
797 if constexpr (chrono::__is_duration_v<_Tp>)
798 if (__is_neg) [[unlikely]]
799 __os << _S_plus_minus[1];
805 return __format::__write_padded_as_spec(__str, __str.size(),
809 static constexpr const _CharT* _S_chars
810 = _GLIBCXX_WIDEN(
"0123456789+-:/ {}");
811 static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
812 static constexpr _CharT _S_colon = _S_chars[12];
813 static constexpr _CharT _S_slash = _S_chars[13];
814 static constexpr _CharT _S_space = _S_chars[14];
815 static constexpr const _CharT* _S_empty_spec = _S_chars + 15;
817 template<
typename _OutIter>
819 _M_write(_OutIter __out,
const locale& __loc, __string_view __s)
const
821#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
826 if constexpr (is_same_v<_CharT, char>)
827 if constexpr (__unicode::__literal_encoding_is_utf8())
828 if (_M_spec._M_localized && _M_spec._M_locale_specific()
829 && __loc != locale::classic())
832 __locale_encoding_to_utf8(
const locale&, string_view,
void*);
834 __s = __locale_encoding_to_utf8(__loc, __s, &__buf);
837 return __format::__write(
std::move(__out), __s);
840 template<
typename _Tp,
typename _FormatContext>
841 typename _FormatContext::iterator
842 _M_a_A(
const _Tp& __t,
typename _FormatContext::iterator __out,
843 _FormatContext& __ctx,
bool __full)
const
847 chrono::weekday __wd = _S_weekday(__t);
849 __throw_format_error(
"format error: invalid weekday");
851 locale __loc = _M_locale(__ctx);
852 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
853 const _CharT* __days[7];
855 __tp._M_days(__days);
857 __tp._M_days_abbreviated(__days);
858 __string_view __str(__days[__wd.c_encoding()]);
859 return _M_write(
std::move(__out), __loc, __str);
862 template<
typename _Tp,
typename _FormatContext>
863 typename _FormatContext::iterator
864 _M_b_B(
const _Tp& __t,
typename _FormatContext::iterator __out,
865 _FormatContext& __ctx,
bool __full)
const
869 chrono::month __m = _S_month(__t);
871 __throw_format_error(
"format error: invalid month");
872 locale __loc = _M_locale(__ctx);
873 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
874 const _CharT* __months[12];
876 __tp._M_months(__months);
878 __tp._M_months_abbreviated(__months);
879 __string_view __str(__months[(
unsigned)__m - 1]);
880 return _M_write(
std::move(__out), __loc, __str);
883 template<
typename _Tp,
typename _FormatContext>
884 typename _FormatContext::iterator
885 _M_c(
const _Tp& __t,
typename _FormatContext::iterator __out,
886 _FormatContext& __ctx,
bool __mod =
false)
const
891 using namespace chrono;
892 using ::std::chrono::__detail::__utc_leap_second;
893 using ::std::chrono::__detail::__local_time_fmt;
903#ifdef _GLIBCXX_USE_STRUCT_TM_TM_ZONE
906 if constexpr (__is_time_point_v<_Tp>)
909 if constexpr (!is_same_v<typename _Tp::clock, local_t>)
910 __tm.tm_zone =
const_cast<char*
>(
"UTC");
912 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
917 __tm.tm_zone =
const_cast<char*
>(__t._M_abbrev->c_str());
920 __tm.tm_zone =
const_cast<char*
>(
"UTC");
923 auto __d = _S_days(__t);
924 using _TDays =
decltype(__d);
925 const year_month_day __ymd(__d);
926 const auto __y = __ymd.year();
927 const auto __hms = _S_hms(__t);
929 __tm.tm_year = (int)__y - 1900;
930 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
931 __tm.tm_mon = (unsigned)__ymd.month() - 1;
932 __tm.tm_mday = (unsigned)__ymd.day();
933 __tm.tm_wday = weekday(__d).c_encoding();
934 __tm.tm_hour = __hms.hours().count();
935 __tm.tm_min = __hms.minutes().count();
936 __tm.tm_sec = __hms.seconds().count();
938 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
'c',
942 template<
typename _Tp,
typename _FormatContext>
943 typename _FormatContext::iterator
944 _M_C_y_Y(
const _Tp& __t,
typename _FormatContext::iterator __out,
945 _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0)
const
955 chrono::year __y = _S_year(__t);
957 if (__mod && _M_spec._M_localized) [[unlikely]]
958 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
961 __tm.tm_year = (int)__y - 1900;
962 return _M_locale_fmt(
std::move(__out), __loc, __tm,
966 basic_string<_CharT> __s;
968 const bool __is_neg = __yi < 0;
969 __yi = __builtin_abs(__yi);
971 if (__conv ==
'Y' || __conv ==
'C')
973 int __ci = __yi / 100;
974 if (__is_neg) [[unlikely]]
976 __s.assign(1, _S_plus_minus[1]);
978 if (__conv ==
'C' && (__ci * 100) != __yi)
981 if (__ci >= 100) [[unlikely]]
983 __s += std::format(_S_empty_spec, __ci / 100);
986 __s += _S_two_digits(__ci);
989 if (__conv ==
'Y' || __conv ==
'y')
990 __s += _S_two_digits(__yi % 100);
992 return __format::__write(
std::move(__out), __string_view(__s));
995 template<
typename _Tp,
typename _FormatContext>
996 typename _FormatContext::iterator
997 _M_D(
const _Tp& __t,
typename _FormatContext::iterator __out,
998 _FormatContext&)
const
1000 auto __ymd = _S_date(__t);
1001 basic_string<_CharT> __s;
1002#if ! _GLIBCXX_USE_CXX11_ABI
1005 __s = _S_two_digits((
unsigned)__ymd.month());
1007 __s += _S_two_digits((
unsigned)__ymd.day());
1009 __s += _S_two_digits(__builtin_abs((
int)__ymd.year()) % 100);
1010 return __format::__write(
std::move(__out), __string_view(__s));
1013 template<
typename _Tp,
typename _FormatContext>
1014 typename _FormatContext::iterator
1015 _M_d_e(
const _Tp& __t,
typename _FormatContext::iterator __out,
1016 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1023 chrono::day __d = _S_day(__t);
1024 unsigned __i = (unsigned)__d;
1026 if (__mod && _M_spec._M_localized) [[unlikely]]
1027 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1031 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1035 auto __sv = _S_two_digits(__i);
1037 if (__conv == _CharT(
'e') && __i < 10)
1039 __buf[0] = _S_space;
1043 return __format::__write(
std::move(__out), __sv);
1046 template<
typename _Tp,
typename _FormatContext>
1047 typename _FormatContext::iterator
1048 _M_F(
const _Tp& __t,
typename _FormatContext::iterator __out,
1049 _FormatContext&)
const
1051 auto __ymd = _S_date(__t);
1052 auto __s = std::format(_GLIBCXX_WIDEN(
"{:04d}- - "),
1054 auto __sv = _S_two_digits((
unsigned)__ymd.month());
1055 __s[__s.size() - 5] = __sv[0];
1056 __s[__s.size() - 4] = __sv[1];
1057 __sv = _S_two_digits((
unsigned)__ymd.day());
1058 __s[__s.size() - 2] = __sv[0];
1059 __s[__s.size() - 1] = __sv[1];
1061 return __format::__write(
std::move(__out), __sv);
1064 template<
typename _Tp,
typename _FormatContext>
1065 typename _FormatContext::iterator
1066 _M_g_G(
const _Tp& __t,
typename _FormatContext::iterator __out,
1067 _FormatContext& __ctx,
bool __full)
const
1071 using namespace chrono;
1072 auto __d = _S_days(__t);
1074 __d -= (weekday(__d) - Monday) -
days(3);
1076 year __y = year_month_day(__d).year();
1077 return _M_C_y_Y(__y,
std::move(__out), __ctx,
"yY"[__full]);
1080 template<
typename _Tp,
typename _FormatContext>
1081 typename _FormatContext::iterator
1082 _M_H_I(
const _Tp& __t,
typename _FormatContext::iterator __out,
1083 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1090 const auto __hms = _S_hms(__t);
1091 int __i = __hms.hours().count();
1093 if (__mod && _M_spec._M_localized) [[unlikely]]
1094 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1098 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1102 if (__conv == _CharT(
'I'))
1109 return __format::__write(
std::move(__out), _S_two_digits(__i));
1112 template<
typename _Tp,
typename _FormatContext>
1113 typename _FormatContext::iterator
1114 _M_j(
const _Tp& __t,
typename _FormatContext::iterator __out,
1115 _FormatContext&)
const
1117 if constexpr (chrono::__is_duration_v<_Tp>)
1120 unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
1126 using namespace chrono;
1127 auto __day = _S_days(__t);
1128 auto __ymd = _S_date(__t);
1132 if constexpr (is_same_v<
typename decltype(__day)::clock, local_t>)
1133 __d = __day - local_days(__ymd.year()/January/0);
1135 __d = __day - sys_days(__ymd.year()/January/0);
1141 template<
typename _Tp,
typename _FormatContext>
1142 typename _FormatContext::iterator
1143 _M_m(
const _Tp& __t,
typename _FormatContext::iterator __out,
1144 _FormatContext& __ctx,
bool __mod)
const
1149 auto __m = _S_month(__t);
1150 auto __i = (unsigned)__m;
1152 if (__mod && _M_spec._M_localized) [[unlikely]]
1153 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1156 __tm.tm_mon = __i - 1;
1157 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1161 return __format::__write(
std::move(__out), _S_two_digits(__i));
1164 template<
typename _Tp,
typename _FormatContext>
1165 typename _FormatContext::iterator
1166 _M_M(
const _Tp& __t,
typename _FormatContext::iterator __out,
1167 _FormatContext& __ctx,
bool __mod)
const
1172 auto __m = _S_hms(__t).minutes();
1173 auto __i = __m.count();
1175 if (__mod && _M_spec._M_localized) [[unlikely]]
1176 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1180 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1184 return __format::__write(
std::move(__out), _S_two_digits(__i));
1187 template<
typename _Tp,
typename _FormatContext>
1188 typename _FormatContext::iterator
1189 _M_p(
const _Tp& __t,
typename _FormatContext::iterator __out,
1190 _FormatContext& __ctx)
const
1193 auto __hms = _S_hms(__t);
1194 locale __loc = _M_locale(__ctx);
1195 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1196 const _CharT* __ampm[2];
1197 __tp._M_am_pm(__ampm);
1198 return _M_write(
std::move(__out), __loc,
1199 __ampm[__hms.hours().count() >= 12]);
1202 template<
typename _Tp,
typename _FormatContext>
1203 typename _FormatContext::iterator
1204 _M_q(
const _Tp&,
typename _FormatContext::iterator __out,
1205 _FormatContext&)
const
1208 if constexpr (!chrono::__is_duration_v<_Tp>)
1209 __throw_format_error(
"format error: argument is not a duration");
1212 namespace __d = chrono::__detail;
1213 using period =
typename _Tp::period;
1214 return __d::__fmt_units_suffix<period, _CharT>(
std::move(__out));
1220 template<
typename _Tp,
typename _FormatContext>
1221 typename _FormatContext::iterator
1222 _M_r(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1223 _FormatContext& __ctx)
const
1226 auto __t = _S_floor_seconds(__tt);
1227 locale __loc = _M_locale(__ctx);
1228 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1229 const _CharT* __ampm_fmt;
1230 __tp._M_am_pm_format(&__ampm_fmt);
1231 basic_string<_CharT> __fmt(_S_empty_spec);
1232 __fmt.insert(1u, 1u, _S_colon);
1233 __fmt.insert(2u, __ampm_fmt);
1234 using _FmtStr = _Runtime_format_string<_CharT>;
1235 return _M_write(
std::move(__out), __loc,
1236 std::format(__loc, _FmtStr(__fmt), __t));
1239 template<
typename _Tp,
typename _FormatContext>
1240 typename _FormatContext::iterator
1241 _M_R_T(
const _Tp& __t,
typename _FormatContext::iterator __out,
1242 _FormatContext& __ctx,
bool __secs)
const
1246 auto __hms = _S_hms(__t);
1248 auto __s = std::format(_GLIBCXX_WIDEN(
"{:02d}:00"),
1249 __hms.hours().count());
1250 auto __sv = _S_two_digits(__hms.minutes().count());
1251 __s[__s.size() - 2] = __sv[0];
1252 __s[__s.size() - 1] = __sv[1];
1254 __out = __format::__write(
std::move(__out), __sv);
1257 *__out++ = _S_colon;
1258 __out = _M_S(__hms,
std::move(__out), __ctx);
1263 template<
typename _Tp,
typename _FormatContext>
1264 typename _FormatContext::iterator
1265 _M_S(
const _Tp& __t,
typename _FormatContext::iterator __out,
1266 _FormatContext& __ctx,
bool __mod =
false)
const
1270 auto __hms = _S_hms(__t);
1271 auto __s = __hms.seconds();
1273 if (__mod) [[unlikely]]
1275 if (_M_spec._M_localized)
1276 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1279 __tm.tm_sec = (int)__s.count();
1280 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1285 return __format::__write(
std::move(__out),
1286 _S_two_digits(__s.count()));
1289 if constexpr (__hms.fractional_width == 0)
1290 __out = __format::__write(
std::move(__out),
1291 _S_two_digits(__s.count()));
1294 locale __loc = _M_locale(__ctx);
1295 auto __ss = __hms.subseconds();
1296 using rep =
typename decltype(__ss)::rep;
1297 if constexpr (is_floating_point_v<rep>)
1299 chrono::duration<rep> __fs = __s + __ss;
1301 _GLIBCXX_WIDEN(
"{:#0{}.{}Lf}"),
1303 3 + __hms.fractional_width,
1304 __hms.fractional_width);
1309 = use_facet<numpunct<_CharT>>(__loc);
1310 __out = __format::__write(
std::move(__out),
1311 _S_two_digits(__s.count()));
1312 *__out++ = __np.decimal_point();
1313 if constexpr (is_integral_v<rep>)
1315 _GLIBCXX_WIDEN(
"{:0{}}"),
1317 __hms.fractional_width);
1320 auto __str = std::format(_S_empty_spec, __ss.count());
1322 _GLIBCXX_WIDEN(
"{:0>{}s}"),
1324 __hms.fractional_width);
1333 template<
typename _Tp,
typename _FormatContext>
1334 typename _FormatContext::iterator
1335 _M_u_w(
const _Tp& __t,
typename _FormatContext::iterator __out,
1336 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1343 chrono::weekday __wd = _S_weekday(__t);
1345 if (__mod && _M_spec._M_localized) [[unlikely]]
1346 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1349 __tm.tm_wday = __wd.c_encoding();
1350 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1354 unsigned __wdi = __conv ==
'u' ? __wd.iso_encoding()
1355 : __wd.c_encoding();
1356 const _CharT __d = _S_digit(__wdi);
1357 return __format::__write(
std::move(__out), __string_view(&__d, 1));
1360 template<
typename _Tp,
typename _FormatContext>
1361 typename _FormatContext::iterator
1362 _M_U_V_W(
const _Tp& __t,
typename _FormatContext::iterator __out,
1363 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1371 using namespace chrono;
1372 auto __d = _S_days(__t);
1373 using _TDays =
decltype(__d);
1375 if (__mod && _M_spec._M_localized) [[unlikely]]
1376 if (
auto __loc = __ctx.locale(); __loc != locale::classic())
1378 const year_month_day __ymd(__d);
1379 const year __y = __ymd.year();
1381 __tm.tm_year = (int)__y - 1900;
1382 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
1383 __tm.tm_wday = weekday(__d).c_encoding();
1384 return _M_locale_fmt(
std::move(__out), __loc, __tm,
1392 __d -= (weekday(__d) - Monday) -
days(3);
1395 __first = _TDays(year_month_day(__d).year()/January/1);
1400 if constexpr (
requires { __t.year(); })
1403 __y = year_month_day(__d).year();
1404 const weekday __weekstart = __conv ==
'U' ? Sunday : Monday;
1405 __first = _TDays(__y/January/__weekstart[1]);
1407 auto __weeks = chrono::floor<weeks>(__d - __first);
1408 __string_view __sv = _S_two_digits(__weeks.count() + 1);
1409 return __format::__write(
std::move(__out), __sv);
1412 template<
typename _Tp,
typename _FormatContext>
1413 typename _FormatContext::iterator
1414 _M_x(
const _Tp& __t,
typename _FormatContext::iterator __out,
1415 _FormatContext& __ctx,
bool __mod =
false)
const
1419 locale __loc = _M_locale(__ctx);
1420 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1421 const _CharT* __date_reps[2];
1422 __tp._M_date_formats(__date_reps);
1423 const _CharT* __rep = __date_reps[__mod];
1425 return _M_D(__t,
std::move(__out), __ctx);
1427 basic_string<_CharT> __fmt(_S_empty_spec);
1428 __fmt.insert(1u, 1u, _S_colon);
1429 __fmt.insert(2u, __rep);
1430 using _FmtStr = _Runtime_format_string<_CharT>;
1431 return _M_write(
std::move(__out), __loc,
1432 std::format(__loc, _FmtStr(__fmt), __t));
1435 template<
typename _Tp,
typename _FormatContext>
1436 typename _FormatContext::iterator
1437 _M_X(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1438 _FormatContext& __ctx,
bool __mod =
false)
const
1442 auto __t = _S_floor_seconds(__tt);
1443 locale __loc = _M_locale(__ctx);
1444 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1445 const _CharT* __time_reps[2];
1446 __tp._M_time_formats(__time_reps);
1447 const _CharT* __rep = __time_reps[__mod];
1449 return _M_R_T(__t,
std::move(__out), __ctx,
true);
1451 basic_string<_CharT> __fmt(_S_empty_spec);
1452 __fmt.insert(1u, 1u, _S_colon);
1453 __fmt.insert(2u, __rep);
1454 using _FmtStr = _Runtime_format_string<_CharT>;
1455 return _M_write(
std::move(__out), __loc,
1456 std::format(__loc, _FmtStr(__fmt), __t));
1459 template<
typename _Tp,
typename _FormatContext>
1460 typename _FormatContext::iterator
1461 _M_z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1462 _FormatContext&,
bool __mod =
false)
const
1464 using ::std::chrono::__detail::__utc_leap_second;
1465 using ::std::chrono::__detail::__local_time_fmt;
1467 auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN(
"+00:00"), 6)
1468 : __string_view(_GLIBCXX_WIDEN(
"+0000"), 5);
1470 if constexpr (chrono::__is_time_point_v<_Tp>)
1472 if constexpr (is_same_v<
typename _Tp::clock,
1473 chrono::system_clock>)
1474 return __format::__write(
std::move(__out), __utc);
1476 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1478 if (__t._M_offset_sec)
1481 basic_string<_CharT> __s;
1482 if (*__t._M_offset_sec != 0s)
1484 chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
1485 __s = _S_plus_minus[__hms.is_negative()];
1486 __s += _S_two_digits(__hms.hours().count());
1489 __s += _S_two_digits(__hms.minutes().count());
1492 return __format::__write(
std::move(__out), __sv);
1495 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1496 return __format::__write(
std::move(__out), __utc);
1498 __no_timezone_available();
1501 template<
typename _Tp,
typename _FormatContext>
1502 typename _FormatContext::iterator
1503 _M_Z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1504 _FormatContext& __ctx)
const
1506 using ::std::chrono::__detail::__utc_leap_second;
1507 using ::std::chrono::__detail::__local_time_fmt;
1509 __string_view __utc(_GLIBCXX_WIDEN(
"UTC"), 3);
1510 if constexpr (chrono::__is_time_point_v<_Tp>)
1512 if constexpr (is_same_v<
typename _Tp::clock,
1513 chrono::system_clock>)
1514 return __format::__write(
std::move(__out), __utc);
1516 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1520 string_view __sv = *__t._M_abbrev;
1521 if constexpr (is_same_v<_CharT, char>)
1522 return __format::__write(
std::move(__out), __sv);
1526 basic_string<_CharT> __ws(__sv.size(), _CharT());
1527 auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
1528 __ct.widen(__sv.begin(), __sv.end(), __ws.data());
1529 __string_view __wsv = __ws;
1530 return __format::__write(
std::move(__out), __wsv);
1534 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1535 return __format::__write(
std::move(__out), __utc);
1537 __no_timezone_available();
1544 _S_digit(
int __n)
noexcept
1547 return _GLIBCXX_WIDEN(
"0123456789999999")[__n & 0xf];
1551 static basic_string_view<_CharT>
1552 _S_two_digits(
int __n)
noexcept
1555 _GLIBCXX_WIDEN(
"0001020304050607080910111213141516171819"
1556 "2021222324252627282930313233343536373839"
1557 "4041424344454647484950515253545556575859"
1558 "6061626364656667686970717273747576777879"
1559 "8081828384858687888990919293949596979899"
1560 "9999999999999999999999999999999999999999"
1561 "9999999999999999") + 2 * (__n & 0x7f),
1569 template<
typename _Tp>
1570 static decltype(
auto)
1571 _S_hms(
const _Tp& __t)
1573 using ::std::chrono::__detail::__utc_leap_second;
1574 using ::std::chrono::__detail::__local_time_fmt;
1576 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1578 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1580 else if constexpr (chrono::__is_duration_v<_Tp>)
1581 return chrono::hh_mm_ss<_Tp>(__t);
1582 else if constexpr (chrono::__is_time_point_v<_Tp>)
1583 return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
1584 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1585 return _S_hms(__t._M_time);
1588 __invalid_chrono_spec();
1589 return chrono::hh_mm_ss<chrono::seconds>();
1594 template<
typename _Tp>
1596 _S_days(
const _Tp& __t)
1598 using namespace chrono;
1599 using ::std::chrono::__detail::__utc_leap_second;
1600 using ::std::chrono::__detail::__local_time_fmt;
1602 if constexpr (__is_time_point_v<_Tp>)
1603 return chrono::floor<days>(__t);
1604 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1606 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1607 return chrono::floor<days>(__t._M_time);
1608 else if constexpr (is_same_v<_Tp, year_month_day>
1609 || is_same_v<_Tp, year_month_day_last>
1610 || is_same_v<_Tp, year_month_weekday>
1611 || is_same_v<_Tp, year_month_weekday_last>)
1612 return sys_days(__t);
1615 if constexpr (__is_duration_v<_Tp>)
1616 __not_valid_for_duration();
1618 __invalid_chrono_spec();
1619 return chrono::sys_days();
1624 template<
typename _Tp>
1625 static chrono::year_month_day
1626 _S_date(
const _Tp& __t)
1628 if constexpr (is_same_v<_Tp, chrono::year_month_day>)
1631 return chrono::year_month_day(_S_days(__t));
1634 template<
typename _Tp>
1636 _S_day(
const _Tp& __t)
1638 using namespace chrono;
1640 if constexpr (is_same_v<_Tp, day>)
1642 else if constexpr (
requires { __t.day(); })
1645 return _S_date(__t).day();
1648 template<
typename _Tp>
1649 static chrono::month
1650 _S_month(
const _Tp& __t)
1652 using namespace chrono;
1654 if constexpr (is_same_v<_Tp, month>)
1656 else if constexpr (
requires { __t.month(); })
1659 return _S_date(__t).month();
1662 template<
typename _Tp>
1664 _S_year(
const _Tp& __t)
1666 using namespace chrono;
1668 if constexpr (is_same_v<_Tp, year>)
1670 else if constexpr (
requires { __t.year(); })
1673 return _S_date(__t).year();
1676 template<
typename _Tp>
1677 static chrono::weekday
1678 _S_weekday(
const _Tp& __t)
1681 using ::std::chrono::__detail::__local_time_fmt;
1683 if constexpr (is_same_v<_Tp, weekday>)
1685 else if constexpr (
requires { __t.weekday(); })
1687 else if constexpr (is_same_v<_Tp, month_weekday>)
1688 return __t.weekday_indexed().weekday();
1689 else if constexpr (is_same_v<_Tp, month_weekday_last>)
1690 return __t.weekday_last().weekday();
1692 return weekday(_S_days(__t));
1696 template<
typename _Tp>
1698 _S_floor_seconds(
const _Tp& __t)
1700 using chrono::__detail::__local_time_fmt;
1701 if constexpr (chrono::__is_time_point_v<_Tp>
1702 || chrono::__is_duration_v<_Tp>)
1704 if constexpr (_Tp::period::den != 1)
1705 return chrono::floor<chrono::seconds>(__t);
1709 else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1711 if constexpr (_Tp::fractional_width != 0)
1712 return chrono::floor<chrono::seconds>(__t.to_duration());
1716 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1717 return _S_floor_seconds(__t._M_time);
1724 template<
typename _Iter>
1726 _M_locale_fmt(_Iter __out,
const locale& __loc,
const struct tm& __tm,
1727 char __fmt,
char __mod)
const
1729 basic_ostringstream<_CharT> __os;
1731 const auto& __tp = use_facet<time_put<_CharT>>(__loc);
1732 __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
1734 __out = _M_write(
std::move(__out), __loc, __os.view());
1742 template<
typename _Rep,
typename _Period,
typename _CharT>
1743 requires __format::__formattable_impl<_Rep, _CharT>
1744 struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1746 constexpr typename basic_format_parse_context<_CharT>::iterator
1747 parse(basic_format_parse_context<_CharT>& __pc)
1749 using namespace __format;
1750 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1751 if constexpr (!is_floating_point_v<_Rep>)
1752 if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1753 __throw_format_error(
"format error: invalid precision for duration");
1757 template<
typename _Out>
1758 typename basic_format_context<_Out, _CharT>::iterator
1759 format(
const chrono::duration<_Rep, _Period>& __d,
1760 basic_format_context<_Out, _CharT>& __fc)
const
1762 if constexpr (numeric_limits<_Rep>::is_signed)
1763 if (__d < __d.zero()) [[unlikely]]
1765 if constexpr (is_integral_v<_Rep>)
1769 using _URep = make_unsigned_t<_Rep>;
1770 auto __ucnt = -
static_cast<_URep
>(__d.count());
1771 auto __ud = chrono::duration<_URep, _Period>(__ucnt);
1772 return _M_f._M_format(__ud, __fc,
true);
1775 return _M_f._M_format(-__d, __fc,
true);
1777 return _M_f._M_format(__d, __fc,
false);
1781 __format::__formatter_chrono<_CharT> _M_f;
1784 template<__format::__
char _CharT>
1785 struct formatter<chrono::day, _CharT>
1787 constexpr typename basic_format_parse_context<_CharT>::iterator
1788 parse(basic_format_parse_context<_CharT>& __pc)
1789 {
return _M_f._M_parse(__pc, __format::_Day); }
1791 template<
typename _Out>
1792 typename basic_format_context<_Out, _CharT>::iterator
1793 format(
const chrono::day& __t,
1794 basic_format_context<_Out, _CharT>& __fc)
const
1795 {
return _M_f._M_format(__t, __fc); }
1798 __format::__formatter_chrono<_CharT> _M_f;
1801 template<__format::__
char _CharT>
1802 struct formatter<chrono::month, _CharT>
1804 constexpr typename basic_format_parse_context<_CharT>::iterator
1805 parse(basic_format_parse_context<_CharT>& __pc)
1806 {
return _M_f._M_parse(__pc, __format::_Month); }
1808 template<
typename _Out>
1809 typename basic_format_context<_Out, _CharT>::iterator
1810 format(
const chrono::month& __t,
1811 basic_format_context<_Out, _CharT>& __fc)
const
1812 {
return _M_f._M_format(__t, __fc); }
1815 __format::__formatter_chrono<_CharT> _M_f;
1818 template<__format::__
char _CharT>
1819 struct formatter<chrono::year, _CharT>
1821 constexpr typename basic_format_parse_context<_CharT>::iterator
1822 parse(basic_format_parse_context<_CharT>& __pc)
1823 {
return _M_f._M_parse(__pc, __format::_Year); }
1825 template<
typename _Out>
1826 typename basic_format_context<_Out, _CharT>::iterator
1827 format(
const chrono::year& __t,
1828 basic_format_context<_Out, _CharT>& __fc)
const
1829 {
return _M_f._M_format(__t, __fc); }
1832 __format::__formatter_chrono<_CharT> _M_f;
1835 template<__format::__
char _CharT>
1836 struct formatter<chrono::weekday, _CharT>
1838 constexpr typename basic_format_parse_context<_CharT>::iterator
1839 parse(basic_format_parse_context<_CharT>& __pc)
1840 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1842 template<
typename _Out>
1843 typename basic_format_context<_Out, _CharT>::iterator
1844 format(
const chrono::weekday& __t,
1845 basic_format_context<_Out, _CharT>& __fc)
const
1846 {
return _M_f._M_format(__t, __fc); }
1849 __format::__formatter_chrono<_CharT> _M_f;
1852 template<__format::__
char _CharT>
1853 struct formatter<chrono::weekday_indexed, _CharT>
1855 constexpr typename basic_format_parse_context<_CharT>::iterator
1856 parse(basic_format_parse_context<_CharT>& __pc)
1857 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1859 template<
typename _Out>
1860 typename basic_format_context<_Out, _CharT>::iterator
1861 format(
const chrono::weekday_indexed& __t,
1862 basic_format_context<_Out, _CharT>& __fc)
const
1863 {
return _M_f._M_format(__t, __fc); }
1866 __format::__formatter_chrono<_CharT> _M_f;
1869 template<__format::__
char _CharT>
1870 struct formatter<chrono::weekday_last, _CharT>
1872 constexpr typename basic_format_parse_context<_CharT>::iterator
1873 parse(basic_format_parse_context<_CharT>& __pc)
1874 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1876 template<
typename _Out>
1877 typename basic_format_context<_Out, _CharT>::iterator
1878 format(
const chrono::weekday_last& __t,
1879 basic_format_context<_Out, _CharT>& __fc)
const
1880 {
return _M_f._M_format(__t, __fc); }
1883 __format::__formatter_chrono<_CharT> _M_f;
1886 template<__format::__
char _CharT>
1887 struct formatter<chrono::month_day, _CharT>
1889 constexpr typename basic_format_parse_context<_CharT>::iterator
1890 parse(basic_format_parse_context<_CharT>& __pc)
1891 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1893 template<
typename _Out>
1894 typename basic_format_context<_Out, _CharT>::iterator
1895 format(
const chrono::month_day& __t,
1896 basic_format_context<_Out, _CharT>& __fc)
const
1897 {
return _M_f._M_format(__t, __fc); }
1900 __format::__formatter_chrono<_CharT> _M_f;
1903 template<__format::__
char _CharT>
1904 struct formatter<chrono::month_day_last, _CharT>
1906 constexpr typename basic_format_parse_context<_CharT>::iterator
1907 parse(basic_format_parse_context<_CharT>& __pc)
1908 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1910 template<
typename _Out>
1911 typename basic_format_context<_Out, _CharT>::iterator
1912 format(
const chrono::month_day_last& __t,
1913 basic_format_context<_Out, _CharT>& __fc)
const
1914 {
return _M_f._M_format(__t, __fc); }
1917 __format::__formatter_chrono<_CharT> _M_f;
1920 template<__format::__
char _CharT>
1921 struct formatter<chrono::month_weekday, _CharT>
1923 constexpr typename basic_format_parse_context<_CharT>::iterator
1924 parse(basic_format_parse_context<_CharT>& __pc)
1925 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1927 template<
typename _Out>
1928 typename basic_format_context<_Out, _CharT>::iterator
1929 format(
const chrono::month_weekday& __t,
1930 basic_format_context<_Out, _CharT>& __fc)
const
1931 {
return _M_f._M_format(__t, __fc); }
1934 __format::__formatter_chrono<_CharT> _M_f;
1937 template<__format::__
char _CharT>
1938 struct formatter<chrono::month_weekday_last, _CharT>
1940 constexpr typename basic_format_parse_context<_CharT>::iterator
1941 parse(basic_format_parse_context<_CharT>& __pc)
1942 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1944 template<
typename _Out>
1945 typename basic_format_context<_Out, _CharT>::iterator
1946 format(
const chrono::month_weekday_last& __t,
1947 basic_format_context<_Out, _CharT>& __fc)
const
1948 {
return _M_f._M_format(__t, __fc); }
1951 __format::__formatter_chrono<_CharT> _M_f;
1954 template<__format::__
char _CharT>
1955 struct formatter<chrono::year_month, _CharT>
1957 constexpr typename basic_format_parse_context<_CharT>::iterator
1958 parse(basic_format_parse_context<_CharT>& __pc)
1959 {
return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }
1961 template<
typename _Out>
1962 typename basic_format_context<_Out, _CharT>::iterator
1963 format(
const chrono::year_month& __t,
1964 basic_format_context<_Out, _CharT>& __fc)
const
1965 {
return _M_f._M_format(__t, __fc); }
1968 __format::__formatter_chrono<_CharT> _M_f;
1971 template<__format::__
char _CharT>
1972 struct formatter<chrono::year_month_day, _CharT>
1974 constexpr typename basic_format_parse_context<_CharT>::iterator
1975 parse(basic_format_parse_context<_CharT>& __pc)
1976 {
return _M_f._M_parse(__pc, __format::_Date); }
1978 template<
typename _Out>
1979 typename basic_format_context<_Out, _CharT>::iterator
1980 format(
const chrono::year_month_day& __t,
1981 basic_format_context<_Out, _CharT>& __fc)
const
1982 {
return _M_f._M_format(__t, __fc); }
1985 __format::__formatter_chrono<_CharT> _M_f;
1988 template<__format::__
char _CharT>
1989 struct formatter<chrono::year_month_day_last, _CharT>
1991 constexpr typename basic_format_parse_context<_CharT>::iterator
1992 parse(basic_format_parse_context<_CharT>& __pc)
1993 {
return _M_f._M_parse(__pc, __format::_Date); }
1995 template<
typename _Out>
1996 typename basic_format_context<_Out, _CharT>::iterator
1997 format(
const chrono::year_month_day_last& __t,
1998 basic_format_context<_Out, _CharT>& __fc)
const
1999 {
return _M_f._M_format(__t, __fc); }
2002 __format::__formatter_chrono<_CharT> _M_f;
2005 template<__format::__
char _CharT>
2006 struct formatter<chrono::year_month_weekday, _CharT>
2008 constexpr typename basic_format_parse_context<_CharT>::iterator
2009 parse(basic_format_parse_context<_CharT>& __pc)
2010 {
return _M_f._M_parse(__pc, __format::_Date); }
2012 template<
typename _Out>
2013 typename basic_format_context<_Out, _CharT>::iterator
2014 format(
const chrono::year_month_weekday& __t,
2015 basic_format_context<_Out, _CharT>& __fc)
const
2016 {
return _M_f._M_format(__t, __fc); }
2019 __format::__formatter_chrono<_CharT> _M_f;
2022 template<__format::__
char _CharT>
2023 struct formatter<chrono::year_month_weekday_last, _CharT>
2025 constexpr typename basic_format_parse_context<_CharT>::iterator
2026 parse(basic_format_parse_context<_CharT>& __pc)
2027 {
return _M_f._M_parse(__pc, __format::_Date); }
2029 template<
typename _Out>
2030 typename basic_format_context<_Out, _CharT>::iterator
2031 format(
const chrono::year_month_weekday_last& __t,
2032 basic_format_context<_Out, _CharT>& __fc)
const
2033 {
return _M_f._M_format(__t, __fc); }
2036 __format::__formatter_chrono<_CharT> _M_f;
2039 template<
typename _Rep,
typename _Period, __format::__
char _CharT>
2040 struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
2042 constexpr typename basic_format_parse_context<_CharT>::iterator
2043 parse(basic_format_parse_context<_CharT>& __pc)
2044 {
return _M_f._M_parse(__pc, __format::_TimeOfDay); }
2046 template<
typename _Out>
2047 typename basic_format_context<_Out, _CharT>::iterator
2048 format(
const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
2049 basic_format_context<_Out, _CharT>& __fc)
const
2050 {
return _M_f._M_format(__t, __fc); }
2053 __format::__formatter_chrono<_CharT> _M_f;
2056#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2057 template<__format::__
char _CharT>
2058 struct formatter<chrono::sys_info, _CharT>
2060 constexpr typename basic_format_parse_context<_CharT>::iterator
2061 parse(basic_format_parse_context<_CharT>& __pc)
2062 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2064 template<
typename _Out>
2065 typename basic_format_context<_Out, _CharT>::iterator
2066 format(
const chrono::sys_info& __i,
2067 basic_format_context<_Out, _CharT>& __fc)
const
2068 {
return _M_f._M_format(__i, __fc); }
2071 __format::__formatter_chrono<_CharT> _M_f;
2074 template<__format::__
char _CharT>
2075 struct formatter<chrono::local_info, _CharT>
2077 constexpr typename basic_format_parse_context<_CharT>::iterator
2078 parse(basic_format_parse_context<_CharT>& __pc)
2079 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
2081 template<
typename _Out>
2082 typename basic_format_context<_Out, _CharT>::iterator
2083 format(
const chrono::local_info& __i,
2084 basic_format_context<_Out, _CharT>& __fc)
const
2085 {
return _M_f._M_format(__i, __fc); }
2088 __format::__formatter_chrono<_CharT> _M_f;
2092 template<
typename _Duration, __format::__
char _CharT>
2093 struct formatter<chrono::sys_time<_Duration>, _CharT>
2095 constexpr typename basic_format_parse_context<_CharT>::iterator
2096 parse(basic_format_parse_context<_CharT>& __pc)
2098 auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
2099 if constexpr (!__stream_insertable)
2100 if (_M_f._M_spec._M_chrono_specs.empty())
2101 __format::__invalid_chrono_spec();
2105 template<
typename _Out>
2106 typename basic_format_context<_Out, _CharT>::iterator
2107 format(
const chrono::sys_time<_Duration>& __t,
2108 basic_format_context<_Out, _CharT>& __fc)
const
2109 {
return _M_f._M_format(__t, __fc); }
2112 static constexpr bool __stream_insertable
2113 =
requires (basic_ostream<_CharT>& __os,
2114 chrono::sys_time<_Duration> __t) { __os << __t; };
2116 __format::__formatter_chrono<_CharT> _M_f;
2119 template<
typename _Duration, __format::__
char _CharT>
2120 struct formatter<chrono::utc_time<_Duration>, _CharT>
2121 : __format::__formatter_chrono<_CharT>
2123 constexpr typename basic_format_parse_context<_CharT>::iterator
2124 parse(basic_format_parse_context<_CharT>& __pc)
2125 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2127 template<
typename _Out>
2128 typename basic_format_context<_Out, _CharT>::iterator
2129 format(
const chrono::utc_time<_Duration>& __t,
2130 basic_format_context<_Out, _CharT>& __fc)
const
2135 using chrono::__detail::__utc_leap_second;
2136 using chrono::seconds;
2137 using chrono::sys_time;
2138 using _CDur = common_type_t<_Duration, seconds>;
2139 const auto __li = chrono::get_leap_second_info(__t);
2140 sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
2141 if (!__li.is_leap_second) [[likely]]
2142 return _M_f._M_format(__s, __fc);
2144 return _M_f._M_format(__utc_leap_second(__s), __fc);
2148 friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;
2150 __format::__formatter_chrono<_CharT> _M_f;
2153 template<
typename _Duration, __format::__
char _CharT>
2154 struct formatter<chrono::tai_time<_Duration>, _CharT>
2155 : __format::__formatter_chrono<_CharT>
2157 constexpr typename basic_format_parse_context<_CharT>::iterator
2158 parse(basic_format_parse_context<_CharT>& __pc)
2159 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2161 template<
typename _Out>
2162 typename basic_format_context<_Out, _CharT>::iterator
2163 format(
const chrono::tai_time<_Duration>& __t,
2164 basic_format_context<_Out, _CharT>& __fc)
const
2171 constexpr chrono::days __tai_offset = chrono::days(4383);
2172 using _CDur = common_type_t<_Duration, chrono::days>;
2173 chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
2174 const string __abbrev(
"TAI", 3);
2175 const chrono::seconds __off = 0s;
2176 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2177 return _M_f._M_format(__lf, __fc);
2181 __format::__formatter_chrono<_CharT> _M_f;
2184 template<
typename _Duration, __format::__
char _CharT>
2185 struct formatter<chrono::gps_time<_Duration>, _CharT>
2186 : __format::__formatter_chrono<_CharT>
2188 constexpr typename basic_format_parse_context<_CharT>::iterator
2189 parse(basic_format_parse_context<_CharT>& __pc)
2190 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2192 template<
typename _Out>
2193 typename basic_format_context<_Out, _CharT>::iterator
2194 format(
const chrono::gps_time<_Duration>& __t,
2195 basic_format_context<_Out, _CharT>& __fc)
const
2202 constexpr chrono::days __gps_offset = chrono::days(3657);
2203 using _CDur = common_type_t<_Duration, chrono::days>;
2204 chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
2205 const string __abbrev(
"GPS", 3);
2206 const chrono::seconds __off = 0s;
2207 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
2208 return _M_f._M_format(__lf, __fc);
2212 __format::__formatter_chrono<_CharT> _M_f;
2215 template<
typename _Duration, __format::__
char _CharT>
2216 struct formatter<chrono::file_time<_Duration>, _CharT>
2218 constexpr typename basic_format_parse_context<_CharT>::iterator
2219 parse(basic_format_parse_context<_CharT>& __pc)
2220 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2222 template<
typename _Out>
2223 typename basic_format_context<_Out, _CharT>::iterator
2224 format(
const chrono::file_time<_Duration>& __t,
2225 basic_format_context<_Out, _CharT>& __fc)
const
2227 using namespace chrono;
2228 return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __fc);
2232 __format::__formatter_chrono<_CharT> _M_f;
2235 template<
typename _Duration, __format::__
char _CharT>
2236 struct formatter<chrono::local_time<_Duration>, _CharT>
2238 constexpr typename basic_format_parse_context<_CharT>::iterator
2239 parse(basic_format_parse_context<_CharT>& __pc)
2240 {
return _M_f._M_parse(__pc, __format::_DateTime); }
2242 template<
typename _Out>
2243 typename basic_format_context<_Out, _CharT>::iterator
2244 format(
const chrono::local_time<_Duration>& __t,
2245 basic_format_context<_Out, _CharT>& __fc)
const
2246 {
return _M_f._M_format(__t, __fc); }
2249 __format::__formatter_chrono<_CharT> _M_f;
2252 template<
typename _Duration, __format::__
char _CharT>
2253 struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2255 constexpr typename basic_format_parse_context<_CharT>::iterator
2256 parse(basic_format_parse_context<_CharT>& __pc)
2257 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2259 template<
typename _Out>
2260 typename basic_format_context<_Out, _CharT>::iterator
2261 format(
const chrono::__detail::__local_time_fmt<_Duration>& __t,
2262 basic_format_context<_Out, _CharT>& __fc)
const
2263 {
return _M_f._M_format(__t, __fc,
true); }
2266 __format::__formatter_chrono<_CharT> _M_f;
2269#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2270 template<
typename _Duration,
typename _TimeZonePtr, __format::__
char _CharT>
2271 struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
2272 : formatter<chrono::__detail::__local_time_fmt_for<_Duration>, _CharT>
2274 template<
typename _Out>
2275 typename basic_format_context<_Out, _CharT>::iterator
2276 format(
const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
2277 basic_format_context<_Out, _CharT>& __fc)
const
2279 using _Ltf = chrono::__detail::__local_time_fmt_for<_Duration>;
2280 using _Base = formatter<_Ltf, _CharT>;
2281 const chrono::sys_info __info = __tp.get_info();
2282 const auto __lf = chrono::local_time_format(__tp.get_local_time(),
2285 return _Base::format(__lf, __fc);
2291 template<
typename _Duration, __format::__
char _CharT>
2292 struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
2293 : formatter<chrono::utc_time<_Duration>, _CharT>
2295 template<
typename _Out>
2296 typename basic_format_context<_Out, _CharT>::iterator
2297 format(
const chrono::__detail::__utc_leap_second<_Duration>& __t,
2298 basic_format_context<_Out, _CharT>& __fc)
const
2299 {
return this->_M_f._M_format(__t, __fc); }
2310 template<
typename _Duration = seconds>
2313 static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);
2316 _Parser(__format::_ChronoParts __need) : _M_need(__need) { }
2318 _Parser(_Parser&&) =
delete;
2319 void operator=(_Parser&&) =
delete;
2321 _Duration _M_time{};
2322 sys_days _M_sys_days{};
2323 year_month_day _M_ymd{};
2325 __format::_ChronoParts _M_need;
2326 unsigned _M_is_leap_second : 1 {};
2327 unsigned _M_reserved : 15 {};
2329 template<
typename _CharT,
typename _Traits,
typename _Alloc>
2330 basic_istream<_CharT, _Traits>&
2331 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2332 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2333 minutes* __offset =
nullptr);
2338 template<
typename _CharT,
typename _Traits>
2339 static int_least32_t
2340 _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
2341 ios_base::iostate& __err,
int __n)
2343 int_least32_t __val = _S_try_read_digit(__is, __err);
2344 if (__val == -1) [[unlikely]]
2345 __err |= ios_base::failbit;
2350 for (
int __i = 1; __i < __n1; ++__i)
2351 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2357 while (__n1++ < __n) [[unlikely]]
2358 if (
auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
2360 if (__builtin_mul_overflow(__val, 10, &__val)
2361 || __builtin_add_overflow(__val, __dig, &__val))
2363 __err |= ios_base::failbit;
2373 template<
typename _CharT,
typename _Traits>
2374 static int_least32_t
2375 _S_read_signed(basic_istream<_CharT, _Traits>& __is,
2376 ios_base::iostate& __err,
int __n)
2378 auto __sign = __is.peek();
2379 if (__sign ==
'-' || __sign ==
'+')
2381 int_least32_t __val = _S_read_unsigned(__is, __err, __n);
2382 if (__err & ios_base::failbit)
2384 if (__sign ==
'-') [[unlikely]]
2392 template<
typename _CharT,
typename _Traits>
2393 static int_least32_t
2394 _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
2395 ios_base::iostate& __err)
2397 int_least32_t __val = -1;
2398 auto __i = __is.peek();
2399 if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
2401 _CharT __c = _Traits::to_char_type(__i);
2402 if (_CharT(
'0') <= __c && __c <= _CharT(
'9')) [[likely]]
2405 __val = __c - _CharT(
'0');
2409 __err |= ios_base::eofbit;
2415 template<
typename _CharT,
typename _Traits>
2417 _S_read_chr(basic_istream<_CharT, _Traits>& __is,
2418 ios_base::iostate& __err, _CharT __c)
2420 auto __i = __is.peek();
2421 if (_Traits::eq_int_type(__i, _Traits::eof()))
2422 __err |= ios_base::eofbit;
2423 else if (_Traits::to_char_type(__i) == __c) [[likely]]
2428 __err |= ios_base::failbit;
2433 template<
typename _Duration>
2434 using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;
2436 template<
typename _Duration>
2440 if constexpr (_Duration::period::den == 1)
2442 switch (_Duration::period::num)
2444 case minutes::period::num:
2445 case hours::period::num:
2446 case days::period::num:
2447 case weeks::period::num:
2448 case years::period::num:
2465 template<
typename _ToDur,
typename _Tp>
2467 __round(
const _Tp& __t)
2469 if constexpr (__is_duration_v<_Tp>)
2471 if constexpr (treat_as_floating_point_v<typename _Tp::rep>)
2472 return chrono::duration_cast<_ToDur>(__t);
2473 else if constexpr (__detail::__use_floor<_ToDur>())
2474 return chrono::floor<_ToDur>(__t);
2476 return chrono::round<_ToDur>(__t);
2480 static_assert(__is_time_point_v<_Tp>);
2481 using _Tpt = time_point<typename _Tp::clock, _ToDur>;
2482 return _Tpt(__detail::__round<_ToDur>(__t.time_since_epoch()));
2489 template<
typename _CharT,
typename _Traits,
typename _Rep,
typename _Period,
2490 typename _Alloc = allocator<_CharT>>
2491 inline basic_istream<_CharT, _Traits>&
2492 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2493 duration<_Rep, _Period>& __d,
2494 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2497 auto __need = __format::_ChronoParts::_TimeOfDay;
2498 __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
2499 if (__p(__is, __fmt, __abbrev, __offset))
2500 __d = __detail::__round<duration<_Rep, _Period>>(__p._M_time);
2504 template<
typename _CharT,
typename _Traits>
2505 inline basic_ostream<_CharT, _Traits>&
2506 operator<<(basic_ostream<_CharT, _Traits>& __os,
const day& __d)
2508 using _Ctx = __format::__format_context<_CharT>;
2509 using _Str = basic_string_view<_CharT>;
2510 _Str __s = _GLIBCXX_WIDEN(
"{:02d} is not a valid day");
2512 __s = __s.substr(0, 6);
2513 auto __u = (unsigned)__d;
2514 __os << std::vformat(__s, make_format_args<_Ctx>(__u));
2518 template<
typename _CharT,
typename _Traits,
2519 typename _Alloc = allocator<_CharT>>
2520 inline basic_istream<_CharT, _Traits>&
2521 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2523 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2526 __detail::_Parser<> __p(__format::_ChronoParts::_Day);
2527 if (__p(__is, __fmt, __abbrev, __offset))
2528 __d = __p._M_ymd.day();
2532 template<
typename _CharT,
typename _Traits>
2533 inline basic_ostream<_CharT, _Traits>&
2534 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month& __m)
2536 using _Ctx = __format::__format_context<_CharT>;
2537 using _Str = basic_string_view<_CharT>;
2538 _Str __s = _GLIBCXX_WIDEN(
"{:L%b}{} is not a valid month");
2541 make_format_args<_Ctx>(__m));
2544 auto __u = (unsigned)__m;
2545 __os <<
std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
2550 template<
typename _CharT,
typename _Traits,
2551 typename _Alloc = allocator<_CharT>>
2552 inline basic_istream<_CharT, _Traits>&
2553 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2555 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2558 __detail::_Parser<> __p(__format::_ChronoParts::_Month);
2559 if (__p(__is, __fmt, __abbrev, __offset))
2560 __m = __p._M_ymd.month();
2564 template<
typename _CharT,
typename _Traits>
2565 inline basic_ostream<_CharT, _Traits>&
2566 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year& __y)
2568 using _Ctx = __format::__format_context<_CharT>;
2569 using _Str = basic_string_view<_CharT>;
2570 _Str __s = _GLIBCXX_WIDEN(
"-{:04d} is not a valid year");
2572 __s = __s.substr(0, 7);
2574 if (__i >= 0) [[likely]]
2575 __s.remove_prefix(1);
2578 __os << std::vformat(__s, make_format_args<_Ctx>(__i));
2582 template<
typename _CharT,
typename _Traits,
2583 typename _Alloc = allocator<_CharT>>
2584 inline basic_istream<_CharT, _Traits>&
2585 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2587 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2590 __detail::_Parser<> __p(__format::_ChronoParts::_Year);
2591 if (__p(__is, __fmt, __abbrev, __offset))
2592 __y = __p._M_ymd.year();
2596 template<
typename _CharT,
typename _Traits>
2597 inline basic_ostream<_CharT, _Traits>&
2598 operator<<(basic_ostream<_CharT, _Traits>& __os,
const weekday& __wd)
2600 using _Ctx = __format::__format_context<_CharT>;
2601 using _Str = basic_string_view<_CharT>;
2602 _Str __s = _GLIBCXX_WIDEN(
"{:L%a}{} is not a valid weekday");
2605 make_format_args<_Ctx>(__wd));
2608 auto __c = __wd.c_encoding();
2609 __os <<
std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
2614 template<
typename _CharT,
typename _Traits,
2615 typename _Alloc = allocator<_CharT>>
2616 inline basic_istream<_CharT, _Traits>&
2617 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2619 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2622 __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
2623 if (__p(__is, __fmt, __abbrev, __offset))
2628 template<
typename _CharT,
typename _Traits>
2629 inline basic_ostream<_CharT, _Traits>&
2630 operator<<(basic_ostream<_CharT, _Traits>& __os,
2631 const weekday_indexed& __wdi)
2636 basic_stringstream<_CharT> __os2;
2637 __os2.imbue(__os.getloc());
2638 __os2 << __wdi.weekday();
2639 const auto __i = __wdi.index();
2640 basic_string_view<_CharT> __s
2641 = _GLIBCXX_WIDEN(
"[ is not a valid index]");
2643 __os2 << std::format(_GLIBCXX_WIDEN(
"{}"), __i);
2644 if (__i >= 1 && __i <= 5)
2645 __os2 << __s.back();
2647 __os2 << __s.substr(1);
2648 __os << __os2.view();
2652 template<
typename _CharT,
typename _Traits>
2653 inline basic_ostream<_CharT, _Traits>&
2654 operator<<(basic_ostream<_CharT, _Traits>& __os,
2655 const weekday_last& __wdl)
2658 basic_stringstream<_CharT> __os2;
2659 __os2.imbue(__os.getloc());
2660 __os2 << __wdl.weekday() << _GLIBCXX_WIDEN(
"[last]");
2661 __os << __os2.view();
2665 template<
typename _CharT,
typename _Traits>
2666 inline basic_ostream<_CharT, _Traits>&
2667 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month_day& __md)
2670 basic_stringstream<_CharT> __os2;
2671 __os2.imbue(__os.getloc());
2672 __os2 << __md.month();
2673 if constexpr (is_same_v<_CharT, char>)
2677 __os2 << __md.day();
2678 __os << __os2.view();
2682 template<
typename _CharT,
typename _Traits,
2683 typename _Alloc = allocator<_CharT>>
2684 inline basic_istream<_CharT, _Traits>&
2685 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2687 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2690 using __format::_ChronoParts;
2691 auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
2692 __detail::_Parser<> __p(__need);
2693 if (__p(__is, __fmt, __abbrev, __offset))
2694 __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
2698 template<
typename _CharT,
typename _Traits>
2699 inline basic_ostream<_CharT, _Traits>&
2700 operator<<(basic_ostream<_CharT, _Traits>& __os,
2701 const month_day_last& __mdl)
2704 basic_stringstream<_CharT> __os2;
2705 __os2.imbue(__os.getloc());
2706 __os2 << __mdl.month() << _GLIBCXX_WIDEN(
"/last");
2707 __os << __os2.view();
2711 template<
typename _CharT,
typename _Traits>
2712 inline basic_ostream<_CharT, _Traits>&
2713 operator<<(basic_ostream<_CharT, _Traits>& __os,
2714 const month_weekday& __mwd)
2717 basic_stringstream<_CharT> __os2;
2718 __os2.imbue(__os.getloc());
2719 __os2 << __mwd.month();
2720 if constexpr (is_same_v<_CharT, char>)
2724 __os2 << __mwd.weekday_indexed();
2725 __os << __os2.view();
2729 template<
typename _CharT,
typename _Traits>
2730 inline basic_ostream<_CharT, _Traits>&
2731 operator<<(basic_ostream<_CharT, _Traits>& __os,
2732 const month_weekday_last& __mwdl)
2735 basic_stringstream<_CharT> __os2;
2736 __os2.imbue(__os.getloc());
2737 __os2 << __mwdl.month();
2738 if constexpr (is_same_v<_CharT, char>)
2742 __os2 << __mwdl.weekday_last();
2743 __os << __os2.view();
2747 template<
typename _CharT,
typename _Traits>
2748 inline basic_ostream<_CharT, _Traits>&
2749 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year_month& __ym)
2752 basic_stringstream<_CharT> __os2;
2753 __os2.imbue(__os.getloc());
2754 __os2 << __ym.year();
2755 if constexpr (is_same_v<_CharT, char>)
2759 __os2 << __ym.month();
2760 __os << __os2.view();
2764 template<
typename _CharT,
typename _Traits,
2765 typename _Alloc = allocator<_CharT>>
2766 inline basic_istream<_CharT, _Traits>&
2767 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2769 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2772 using __format::_ChronoParts;
2773 auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
2774 __detail::_Parser<> __p(__need);
2775 if (__p(__is, __fmt, __abbrev, __offset))
2776 __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
2780 template<
typename _CharT,
typename _Traits>
2781 inline basic_ostream<_CharT, _Traits>&
2782 operator<<(basic_ostream<_CharT, _Traits>& __os,
2783 const year_month_day& __ymd)
2785 using _Ctx = __format::__format_context<_CharT>;
2786 using _Str = basic_string_view<_CharT>;
2787 _Str __s = _GLIBCXX_WIDEN(
"{:%F} is not a valid date");
2788 __os <<
std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
2789 make_format_args<_Ctx>(__ymd));
2793 template<
typename _CharT,
typename _Traits,
2794 typename _Alloc = allocator<_CharT>>
2795 inline basic_istream<_CharT, _Traits>&
2797 year_month_day&
__ymd,
2801 using __format::_ChronoParts;
2802 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2803 | _ChronoParts::_Day;
2804 __detail::_Parser<> __p(
__need);
2810 template<
typename _CharT,
typename _Traits>
2813 const year_month_day_last&
__ymdl)
2828 template<
typename _CharT,
typename _Traits>
2829 inline basic_ostream<_CharT, _Traits>&
2830 operator<<(basic_ostream<_CharT, _Traits>& __os,
2831 const year_month_weekday& __ymwd)
2835 basic_stringstream<_CharT> __os2;
2836 __os2.imbue(__os.getloc());
2838 if constexpr (is_same_v<_CharT, char>)
2842 __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
2843 << __ymwd.weekday_indexed();
2844 __os << __os2.view();
2848 template<
typename _CharT,
typename _Traits>
2849 inline basic_ostream<_CharT, _Traits>&
2850 operator<<(basic_ostream<_CharT, _Traits>& __os,
2851 const year_month_weekday_last& __ymwdl)
2855 basic_stringstream<_CharT> __os2;
2856 __os2.imbue(__os.getloc());
2858 if constexpr (is_same_v<_CharT, char>)
2862 __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
2863 << __ymwdl.weekday_last();
2864 __os << __os2.view();
2868 template<
typename _CharT,
typename _Traits,
typename _Duration>
2869 inline basic_ostream<_CharT, _Traits>&
2870 operator<<(basic_ostream<_CharT, _Traits>& __os,
2871 const hh_mm_ss<_Duration>& __hms)
2873 return __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%T}"), __hms);
2876#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2878 template<
typename _CharT,
typename _Traits>
2879 basic_ostream<_CharT, _Traits>&
2880 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_info& __i)
2882 __os <<
'[' << __i.begin <<
',' << __i.end
2883 <<
',' << hh_mm_ss(__i.offset) <<
',' << __i.save
2884 <<
',' << __i.abbrev <<
']';
2889 template<
typename _CharT,
typename _Traits>
2890 basic_ostream<_CharT, _Traits>&
2891 operator<<(basic_ostream<_CharT, _Traits>& __os,
const local_info& __li)
2894 if (__li.result == local_info::unique)
2898 if (__li.result == local_info::nonexistent)
2899 __os <<
"nonexistent";
2901 __os <<
"ambiguous";
2902 __os <<
" local time between " << __li.first;
2903 __os <<
" and " << __li.second;
2909 template<
typename _CharT,
typename _Traits,
typename _Duration,
2910 typename _TimeZonePtr>
2911 inline basic_ostream<_CharT, _Traits>&
2912 operator<<(basic_ostream<_CharT, _Traits>& __os,
2913 const zoned_time<_Duration, _TimeZonePtr>& __t)
2915 __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T %Z}"), __t);
2920 template<
typename _CharT,
typename _Traits,
typename _Duration>
2921 requires (!treat_as_floating_point_v<typename _Duration::rep>)
2922 && ratio_less_v<typename _Duration::period, days::period>
2923 inline basic_ostream<_CharT, _Traits>&
2924 operator<<(basic_ostream<_CharT, _Traits>& __os,
2925 const sys_time<_Duration>& __tp)
2927 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __tp);
2931 template<
typename _CharT,
typename _Traits>
2932 inline basic_ostream<_CharT, _Traits>&
2933 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_days& __dp)
2935 __os << year_month_day{__dp};
2939 template<
typename _CharT,
typename _Traits,
typename _Duration,
2940 typename _Alloc = allocator<_CharT>>
2941 basic_istream<_CharT, _Traits>&
2942 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2943 sys_time<_Duration>& __tp,
2944 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2950 using __format::_ChronoParts;
2951 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2952 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2953 __detail::_Parser_t<_Duration> __p(__need);
2954 if (__p(__is, __fmt, __abbrev, __offset))
2956 if (__p._M_is_leap_second)
2960 auto __st = __p._M_sys_days + __p._M_time - *__offset;
2961 __tp = __detail::__round<_Duration>(__st);
2967 template<
typename _CharT,
typename _Traits,
typename _Duration>
2968 inline basic_ostream<_CharT, _Traits>&
2969 operator<<(basic_ostream<_CharT, _Traits>& __os,
2970 const utc_time<_Duration>& __t)
2972 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2976 template<
typename _CharT,
typename _Traits,
typename _Duration,
2977 typename _Alloc = allocator<_CharT>>
2978 inline basic_istream<_CharT, _Traits>&
2979 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2980 utc_time<_Duration>& __tp,
2981 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2987 using __format::_ChronoParts;
2988 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
2989 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
2990 __detail::_Parser_t<_Duration> __p(__need);
2991 if (__p(__is, __fmt, __abbrev, __offset))
2995 auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
2997 __tp = __detail::__round<_Duration>(__ut);
3002 template<
typename _CharT,
typename _Traits,
typename _Duration>
3003 inline basic_ostream<_CharT, _Traits>&
3004 operator<<(basic_ostream<_CharT, _Traits>& __os,
3005 const tai_time<_Duration>& __t)
3007 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3011 template<
typename _CharT,
typename _Traits,
typename _Duration,
3012 typename _Alloc = allocator<_CharT>>
3013 inline basic_istream<_CharT, _Traits>&
3014 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3015 tai_time<_Duration>& __tp,
3016 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3022 using __format::_ChronoParts;
3023 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3024 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3025 __detail::_Parser_t<_Duration> __p(__need);
3026 if (__p(__is, __fmt, __abbrev, __offset))
3028 if (__p._M_is_leap_second)
3032 constexpr sys_days __epoch(-
days(4383));
3033 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3034 tai_time<common_type_t<_Duration, seconds>> __tt(__d);
3035 __tp = __detail::__round<_Duration>(__tt);
3041 template<
typename _CharT,
typename _Traits,
typename _Duration>
3042 inline basic_ostream<_CharT, _Traits>&
3043 operator<<(basic_ostream<_CharT, _Traits>& __os,
3044 const gps_time<_Duration>& __t)
3046 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3050 template<
typename _CharT,
typename _Traits,
typename _Duration,
3051 typename _Alloc = allocator<_CharT>>
3052 inline basic_istream<_CharT, _Traits>&
3053 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3054 gps_time<_Duration>& __tp,
3055 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3061 using __format::_ChronoParts;
3062 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3063 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3064 __detail::_Parser_t<_Duration> __p(__need);
3065 if (__p(__is, __fmt, __abbrev, __offset))
3067 if (__p._M_is_leap_second)
3071 constexpr sys_days __epoch(
days(3657));
3072 auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
3073 gps_time<common_type_t<_Duration, seconds>> __gt(__d);
3074 __tp = __detail::__round<_Duration>(__gt);
3080 template<
typename _CharT,
typename _Traits,
typename _Duration>
3081 inline basic_ostream<_CharT, _Traits>&
3082 operator<<(basic_ostream<_CharT, _Traits>& __os,
3083 const file_time<_Duration>& __t)
3085 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
3089 template<
typename _CharT,
typename _Traits,
typename _Duration,
3090 typename _Alloc = allocator<_CharT>>
3091 inline basic_istream<_CharT, _Traits>&
3092 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3093 file_time<_Duration>& __tp,
3094 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3097 sys_time<_Duration> __st;
3098 if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
3099 __tp = __detail::__round<_Duration>(file_clock::from_sys(__st));
3103 template<
typename _CharT,
typename _Traits,
typename _Duration>
3104 inline basic_ostream<_CharT, _Traits>&
3105 operator<<(basic_ostream<_CharT, _Traits>& __os,
3106 const local_time<_Duration>& __lt)
3108 __os << sys_time<_Duration>{__lt.time_since_epoch()};
3112 template<
typename _CharT,
typename _Traits,
typename _Duration,
3113 typename _Alloc = allocator<_CharT>>
3114 basic_istream<_CharT, _Traits>&
3115 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3116 local_time<_Duration>& __tp,
3117 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3120 using __format::_ChronoParts;
3121 auto __need = _ChronoParts::_Year | _ChronoParts::_Month
3122 | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
3123 __detail::_Parser_t<_Duration> __p(__need);
3124 if (__p(__is, __fmt, __abbrev, __offset))
3126 days __d = __p._M_sys_days.time_since_epoch();
3127 auto __t = local_days(__d) + __p._M_time;
3128 __tp = __detail::__round<_Duration>(__t);
3139 void from_stream() =
delete;
3141 template<
typename _Parsable,
typename _CharT,
3143 typename... _OptArgs>
3144 concept __parsable =
requires (basic_istream<_CharT, _Traits>& __is,
3145 const _CharT* __fmt, _Parsable& __tp,
3146 _OptArgs*... __args)
3147 { from_stream(__is, __fmt, __tp, __args...); };
3149 template<
typename _Parsable,
typename _CharT,
3150 typename _Traits = char_traits<_CharT>,
3151 typename _Alloc = allocator<_CharT>>
3155 using __string_type = basic_string<_CharT, _Traits, _Alloc>;
3158 _Parse(
const _CharT* __fmt, _Parsable& __tp,
3159 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
3162 _M_abbrev(__abbrev), _M_offset(__offset)
3165 _Parse(_Parse&&) =
delete;
3166 _Parse& operator=(_Parse&&) =
delete;
3169 using __stream_type = basic_istream<_CharT, _Traits>;
3171 const _CharT*
const _M_fmt;
3172 _Parsable*
const _M_tp;
3173 __string_type*
const _M_abbrev;
3176 friend __stream_type&
3177 operator>>(__stream_type& __is, _Parse&& __p)
3180 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
3182 else if (__p._M_abbrev)
3183 from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
3185 from_stream(__is, __p._M_fmt, *__p._M_tp);
3189 friend void operator>>(__stream_type&, _Parse&) =
delete;
3190 friend void operator>>(__stream_type&,
const _Parse&) =
delete;
3194 template<
typename _CharT, __detail::__parsable<_CharT> _Parsable>
3195 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3197 parse(
const _CharT* __fmt, _Parsable& __tp)
3198 {
return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }
3200 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3201 __detail::__parsable<_CharT, _Traits> _Parsable>
3204 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
3206 return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
3209 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3210 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3211 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3212 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3214 parse(
const _CharT* __fmt, _Parsable& __tp,
3215 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3218 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3222 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3223 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3224 __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
3227 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3228 basic_string<_CharT, _Traits, _Alloc>& __abbrev)
3231 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3235 template<
typename _CharT,
typename _Traits =
char_traits<_CharT>,
3236 typename _StrT = basic_
string<_CharT, _Traits>,
3237 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3238 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3240 parse(
const _CharT* __fmt, _Parsable& __tp,
minutes& __offset)
3242 return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp,
nullptr,
3246 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3247 typename _StrT = basic_string<_CharT, _Traits>,
3248 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3251 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3254 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3259 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3260 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3261 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3262 [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
3264 parse(
const _CharT* __fmt, _Parsable& __tp,
3265 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3268 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
3273 template<
typename _CharT,
typename _Traits,
typename _Alloc,
3274 typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
3275 __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
3278 parse(
const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
3279 basic_string<_CharT, _Traits, _Alloc>& __abbrev,
minutes& __offset)
3282 return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
3288 template<
typename _Duration>
3289 template<
typename _CharT,
typename _Traits,
typename _Alloc>
3290 basic_istream<_CharT, _Traits>&
3291 __detail::_Parser<_Duration>::
3292 operator()(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
3293 basic_string<_CharT, _Traits, _Alloc>* __abbrev,
3296 using sentry =
typename basic_istream<_CharT, _Traits>::sentry;
3298 if (sentry __cerb(__is,
true); __cerb)
3300 locale __loc = __is.getloc();
3305 struct _Stream_state
3308 _Stream_state(basic_istream<_CharT, _Traits>& __i)
3310 _M_flags(__i.flags(ios_base::
skipws | ios_base::
dec)),
3316 _M_is.flags(_M_flags);
3320 _Stream_state(_Stream_state&&) =
delete;
3322 basic_istream<_CharT, _Traits>& _M_is;
3323 ios_base::fmtflags _M_flags;
3333 auto __read_unsigned = [&] (
int __n) {
3334 return _S_read_unsigned(__is, __err, __n);
3339 auto __read_signed = [&] (
int __n) {
3340 return _S_read_signed(__is, __err, __n);
3344 auto __read_chr = [&__is, &__err] (_CharT __c) {
3345 return _S_read_chr(__is, __err, __c);
3348 using __format::_ChronoParts;
3349 _ChronoParts __parts{};
3351 const year __bad_y = --year::min();
3352 const month __bad_mon(255);
3353 const day __bad_day(255);
3354 const weekday __bad_wday(255);
3355 const hours __bad_h(-1);
3356 const minutes __bad_min(-9999);
3359 year __y = __bad_y, __yy = __bad_y;
3360 year __iso_y = __bad_y, __iso_yy = __bad_y;
3361 month __m = __bad_mon;
3362 day __d = __bad_day;
3363 weekday __wday = __bad_wday;
3364 hours __h = __bad_h, __h12 = __bad_h;
3366 _Duration __s = __bad_sec;
3368 int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1;
3370 int __dayofyear = -1;
3372 minutes __tz_offset = __bad_min;
3373 basic_string<_CharT, _Traits> __tz_abbr;
3375 if ((_M_need & _ChronoParts::_TimeOfDay)
3376 && (_M_need & _ChronoParts::_Year))
3382 __parts = _ChronoParts::_TimeOfDay;
3389 bool __is_flag =
false;
3391 constexpr bool __is_floating
3392 = treat_as_floating_point_v<typename _Duration::rep>;
3411 _CharT __c = *__fmt++;
3418 else if (!__read_chr(__c)) [[unlikely]]
3429 if (__mod || __num) [[unlikely]]
3434 __tmget.get(__is, {}, __is, __err, &__tm,
3436 if (!__is_failed(__err))
3437 __wday = weekday(__tm.tm_wday);
3439 __parts |= _ChronoParts::_Weekday;
3445 if (__mod || __num) [[unlikely]]
3453 __tmget.get(__is, {}, __is, __err, &__tm,
3455 if (!__is_failed(__err))
3456 __m = month(__tm.tm_mon + 1);
3458 __parts |= _ChronoParts::_Month;
3462 if (__mod ==
'O' || __num) [[unlikely]]
3467 __tmget.get(__is, {}, __is, __err, &__tm,
3468 __fmt - 2 - (__mod ==
'E'), __fmt);
3469 if (!__is_failed(__err))
3471 __y = year(__tm.tm_year + 1900);
3472 __m = month(__tm.tm_mon + 1);
3473 __d = day(__tm.tm_mday);
3474 __h =
hours(__tm.tm_hour);
3479 __parts |= _ChronoParts::_DateTime;
3483 if (!__mod) [[likely]]
3485 auto __v = __read_signed(__num ? __num : 2);
3486 if (!__is_failed(__err))
3488 int __cmin = (int)year::min() / 100;
3489 int __cmax = (int)year::max() / 100;
3490 if (__cmin <= __v && __v <= __cmax)
3491 __century = __v * 100;
3496 else if (__mod ==
'E')
3499 __tmget.get(__is, {}, __is, __err, &__tm,
3501 if (!__is_failed(__err))
3502 __century = __tm.tm_year;
3511 if (!__mod) [[likely]]
3513 auto __v = __read_unsigned(__num ? __num : 2);
3514 if (!__is_failed(__err))
3517 else if (__mod ==
'O')
3520 __tmget.get(__is, {}, __is, __err, &__tm,
3522 if (!__is_failed(__err))
3523 __d = day(__tm.tm_mday);
3527 __parts |= _ChronoParts::_Day;
3531 if (__mod || __num) [[unlikely]]
3535 auto __month = __read_unsigned(2);
3537 auto __day = __read_unsigned(2);
3539 auto __year = __read_unsigned(2);
3540 if (__is_failed(__err))
3542 __y = year(__year + 1900 + 100 *
int(__year < 69));
3543 __m = month(__month);
3545 if (!year_month_day(__y, __m, __d).ok())
3547 __y = __yy = __iso_y = __iso_yy = __bad_y;
3553 __parts |= _ChronoParts::_Date;
3557 if (__mod) [[unlikely]]
3561 auto __year = __read_signed(__num ? __num : 4);
3563 auto __month = __read_unsigned(2);
3565 auto __day = __read_unsigned(2);
3566 if (__is_failed(__err))
3569 __m = month(__month);
3571 if (!year_month_day(__y, __m, __d).ok())
3573 __y = __yy = __iso_y = __iso_yy = __bad_y;
3579 __parts |= _ChronoParts::_Date;
3583 if (__mod) [[unlikely]]
3587 auto __val = __read_unsigned(__num ? __num : 2);
3588 if (__val >= 0 && __val <= 99)
3590 __iso_yy = year(__val);
3591 if (__century == -1)
3595 __iso_yy = __iso_y = __y = __yy = __bad_y;
3597 __parts |= _ChronoParts::_Year;
3601 if (__mod) [[unlikely]]
3604 __iso_y = year(__read_unsigned(__num ? __num : 4));
3605 __parts |= _ChronoParts::_Year;
3610 if (__mod ==
'E') [[unlikely]]
3612 else if (__mod ==
'O')
3617 __tmget.get(__is, {}, __is, __err, &__tm,
3619 if (!__is_failed(__err))
3623 __h12 =
hours(__tm.tm_hour);
3627 __h =
hours(__tm.tm_hour);
3636 auto __val = __read_unsigned(__num ? __num : 2);
3637 if (__c ==
'I' && __val >= 1 && __val <= 12)
3639 __h12 =
hours(__val);
3642 else if (__c ==
'H' && __val >= 0 && __val <= 23)
3649 if (_M_need & _ChronoParts::_TimeOfDay)
3654 __parts |= _ChronoParts::_TimeOfDay;
3658 if (__mod) [[unlikely]]
3660 else if (_M_need == _ChronoParts::_TimeOfDay)
3662 auto __val = __read_signed(__num ? __num : 3);
3663 if (!__is_failed(__err))
3666 __parts |= _ChronoParts::_TimeOfDay;
3671 __dayofyear = __read_unsigned(__num ? __num : 3);
3678 if (__mod ==
'E') [[unlikely]]
3680 else if (__mod ==
'O')
3683 __tmget.get(__is, {}, __is, __err, &__tm,
3685 if (!__is_failed(__err))
3686 __m = month(__tm.tm_mon + 1);
3690 auto __val = __read_unsigned(__num ? __num : 2);
3691 if (__val >= 1 && __val <= 12)
3696 __parts |= _ChronoParts::_Month;
3700 if (__mod ==
'E') [[unlikely]]
3702 else if (__mod ==
'O')
3705 __tmget.get(__is, {}, __is, __err, &__tm,
3707 if (!__is_failed(__err))
3712 auto __val = __read_unsigned(__num ? __num : 2);
3713 if (0 <= __val && __val < 60)
3717 if (_M_need & _ChronoParts::_TimeOfDay)
3722 __parts |= _ChronoParts::_TimeOfDay;
3732 const _CharT* __ampms[2];
3733 __tmpunct._M_am_pm(__ampms);
3734 int __n = 0, __which = 3;
3735 while (__which != 0)
3737 auto __i = __is.peek();
3738 if (_Traits::eq_int_type(__i, _Traits::eof()))
3748 else if (__ampms[0][__n + 1] == _CharT())
3759 else if (__ampms[1][__n + 1] == _CharT())
3770 if (__which == 0 || __which == 3)
3783 __tmget.get(__is, {}, __is, __err, &__tm,
3785 if (!__is_failed(__err))
3787 __h =
hours(__tm.tm_hour);
3792 __parts |= _ChronoParts::_TimeOfDay;
3797 if (__mod || __num) [[unlikely]]
3804 auto __val = __read_unsigned(2);
3805 if (__val == -1 || __val > 23) [[unlikely]]
3807 if (_M_need & _ChronoParts::_TimeOfDay)
3811 if (!__read_chr(
':')) [[unlikely]]
3815 __val = __read_unsigned(2);
3816 if (__val == -1 || __val > 60) [[unlikely]]
3818 if (_M_need & _ChronoParts::_TimeOfDay)
3826 __parts |= _ChronoParts::_TimeOfDay;
3829 else if (!__read_chr(
':')) [[unlikely]]
3835 if (__mod ==
'E') [[unlikely]]
3837 else if (__mod ==
'O')
3840 __tmget.get(__is, {}, __is, __err, &__tm,
3842 if (!__is_failed(__err))
3845 else if constexpr (_Duration::period::den == 1
3848 auto __val = __read_unsigned(__num ? __num : 2);
3849 if (0 <= __val && __val <= 59) [[likely]]
3853 if (_M_need & _ChronoParts::_TimeOfDay)
3860 basic_stringstream<_CharT> __buf;
3861 auto __digit = _S_try_read_digit(__is, __err);
3864 __buf.put(_CharT(
'0') + __digit);
3865 __digit = _S_try_read_digit(__is, __err);
3867 __buf.put(_CharT(
'0') + __digit);
3870 auto __i = __is.peek();
3871 if (_Traits::eq_int_type(__i, _Traits::eof()))
3878 auto& __np = use_facet<numpunct<_CharT>>(__loc);
3879 __dp = __np.decimal_point();
3881 _CharT __c = _Traits::to_char_type(__i);
3887 = hh_mm_ss<_Duration>::fractional_width;
3890 __digit = _S_try_read_digit(__is, __err);
3892 __buf.put(_CharT(
'0') + __digit);
3900 if (!__is_failed(__err)) [[likely]]
3902 long double __val{};
3903#if __cpp_lib_to_chars
3905 auto __first = __str.data();
3906 auto __last = __first + __str.size();
3910 if ((
bool)ec || ptr != __last) [[unlikely]]
3917 duration<long double> __fs(__val);
3918 if constexpr (__is_floating)
3921 __s = chrono::round<_Duration>(__fs);
3925 __parts |= _ChronoParts::_TimeOfDay;
3930 if (__mod ==
'E') [[unlikely]]
3932 else if (__mod ==
'O')
3937 __tmget.get(__is, {}, __is, __err, &__tm,
3939 if (!__is_failed(__err))
3940 __wday = weekday(__tm.tm_wday);
3947 const int __lo = __c ==
'u' ? 1 : 0;
3948 const int __hi = __lo + 6;
3949 auto __val = __read_unsigned(__num ? __num : 1);
3950 if (__lo <= __val && __val <= __hi)
3951 __wday = weekday(__val);
3954 __wday = __bad_wday;
3958 __parts |= _ChronoParts::_Weekday;
3964 if (__mod ==
'E') [[unlikely]]
3966 else if (__mod ==
'O')
3968 if (__c ==
'V') [[unlikely]]
3978 const int __lo = __c ==
'V' ? 1 : 0;
3979 const int __hi = 53;
3980 auto __val = __read_unsigned(__num ? __num : 2);
3981 if (__lo <= __val && __val <= __hi)
3986 __sunday_wk = __val;
3992 __monday_wk = __val;
3997 __iso_wk = __sunday_wk = __monday_wk = -1;
4003 if (__mod ==
'O' || __num) [[unlikely]]
4008 __tmget.get(__is, {}, __is, __err, &__tm,
4009 __fmt - 2 - (__mod ==
'E'), __fmt);
4010 if (!__is_failed(__err))
4012 __y = year(__tm.tm_year + 1900);
4013 __m = month(__tm.tm_mon + 1);
4014 __d = day(__tm.tm_mday);
4017 __parts |= _ChronoParts::_Date;
4021 if (__mod ==
'O' || __num) [[unlikely]]
4026 __tmget.get(__is, {}, __is, __err, &__tm,
4027 __fmt - 2 - (__mod ==
'E'), __fmt);
4028 if (!__is_failed(__err))
4030 __h =
hours(__tm.tm_hour);
4035 __parts |= _ChronoParts::_TimeOfDay;
4039 if (__mod) [[unlikely]]
4042 __tmget.get(__is, {}, __is, __err, &__tm,
4044 if (!__is_failed(__err))
4046 int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
4047 __yy = year(__tm.tm_year - __cent);
4048 if (__century == -1)
4054 auto __val = __read_unsigned(__num ? __num : 2);
4055 if (__val >= 0 && __val <= 99)
4058 if (__century == -1)
4059 __century = __val < 69 ? 2000 : 1900;
4062 __y = __yy = __iso_yy = __iso_y = __bad_y;
4064 __parts |= _ChronoParts::_Year;
4068 if (__mod ==
'O') [[unlikely]]
4070 else if (__mod ==
'E')
4073 __tmget.get(__is, {}, __is, __err, &__tm,
4075 if (!__is_failed(__err))
4076 __y = year(__tm.tm_year);
4080 auto __val = __read_unsigned(__num ? __num : 4);
4081 if (!__is_failed(__err))
4084 __parts |= _ChronoParts::_Year;
4088 if (__num) [[unlikely]]
4095 auto __i = __is.peek();
4096 if (_Traits::eq_int_type(__i, _Traits::eof()))
4101 _CharT __ic = _Traits::to_char_type(__i);
4102 const bool __neg = __ic == _CharT(
'-');
4103 if (__ic == _CharT(
'-') || __ic == _CharT(
'+'))
4110 __hh = __read_unsigned(2);
4115 __hh = 10 * _S_try_read_digit(__is, __err);
4116 __hh += _S_try_read_digit(__is, __err);
4119 if (__is_failed(__err))
4123 if (_Traits::eq_int_type(__i, _Traits::eof()))
4126 __tz_offset =
minutes(__hh * (__neg ? -60 : 60));
4129 __ic = _Traits::to_char_type(__i);
4131 bool __read_mm =
false;
4134 if (__ic == _GLIBCXX_WIDEN(
":")[0])
4141 else if (_CharT(
'0') <= __ic && __ic <= _CharT(
'9'))
4147 int_least32_t __mm = 0;
4150 __mm = 10 * _S_try_read_digit(__is, __err);
4151 __mm += _S_try_read_digit(__is, __err);
4154 if (!__is_failed(__err))
4156 auto __z = __hh * 60 + __mm;
4157 __tz_offset =
minutes(__neg ? -__z : __z);
4163 if (__mod || __num) [[unlikely]]
4167 basic_string_view<_CharT> __x = _GLIBCXX_WIDEN(
"_/-+");
4171 auto __i = __is.peek();
4172 if (!_Traits::eq_int_type(__i, _Traits::eof()))
4174 _CharT __a = _Traits::to_char_type(__i);
4176 || __x.find(__a) != __x.npos)
4178 __tz_abbr.push_back(__a);
4187 if (__tz_abbr.empty())
4193 if (__mod || __num) [[unlikely]]
4197 _CharT __i = __is.peek();
4198 if (_Traits::eq_int_type(__i, _Traits::eof()))
4200 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4208 if (__mod || __num) [[unlikely]]
4212 _CharT __i = __is.peek();
4213 if (_Traits::eq_int_type(__i, _Traits::eof()))
4215 else if (
std::isspace(_Traits::to_char_type(__i), __loc))
4221 if (__mod || __num) [[unlikely]]
4229 if (__mod || __num) [[unlikely]]
4238 if (_CharT(
'1') <= __c && __c <= _CharT(
'9'))
4240 if (!__mod) [[likely]]
4243 auto __end = __fmt + _Traits::length(__fmt);
4245 = __format::__parse_integer(__fmt - 1, __end);
4246 if (__ptr) [[likely]]
4257 if (__is_failed(__err)) [[unlikely]]
4267 if (__yy != __bad_y && __y == __bad_y)
4268 __y =
years(__century) + __yy;
4269 if (__iso_yy != __bad_y && __iso_y == __bad_y)
4270 __iso_y =
years(__century) + __iso_yy;
4273 bool __can_use_doy =
false;
4274 bool __can_use_iso_wk =
false;
4275 bool __can_use_sun_wk =
false;
4276 bool __can_use_mon_wk =
false;
4279 if (__y != __bad_y && __dayofyear >= 0)
4281 __can_use_doy =
true;
4282 __parts |= _ChronoParts::_Date;
4284 else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
4286 __can_use_sun_wk =
true;
4287 __parts |= _ChronoParts::_Date;
4289 else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
4291 __can_use_mon_wk =
true;
4292 __parts |= _ChronoParts::_Date;
4294 else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
4297 __can_use_iso_wk =
true;
4298 __parts |= _ChronoParts::_Date;
4301 if (__is_failed(__err)) [[unlikely]]
4303 else if (__is_flag) [[unlikely]]
4305 else if ((_M_need & __parts) == _M_need) [[likely]]
4327 const bool __need_wday = _M_need & _ChronoParts::_Weekday;
4331 const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;
4333 if (__need_wday && __wday != __bad_wday)
4335 else if (_M_need & _ChronoParts::_Date)
4339 const bool __need_ymd = !__need_wday && !__need_time;
4341 if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
4342 || (_M_need & _ChronoParts::_Month && __m == __bad_mon)
4343 || (_M_need & _ChronoParts::_Day && __d == __bad_day))
4350 if ((0 < __dayofyear && __dayofyear <= 365)
4351 || (__dayofyear == 366 && __y.is_leap()))
4354 _M_sys_days = sys_days(__y/January/1)
4355 +
days(__dayofyear - 1);
4357 _M_ymd = year_month_day(_M_sys_days);
4362 else if (__can_use_iso_wk)
4370 const sys_days __jan4(__iso_y/January/4);
4371 weekday __wd1(__jan4 -
days(3));
4372 if (__wd1 != Thursday)
4373 if (__wd1 != Wednesday || !__iso_y.is_leap())
4377 if (!__is_failed(__err)) [[likely]]
4380 sys_days __w(Thursday[1]/January/__iso_y);
4382 __w -= Thursday - Monday;
4384 __w += __wday - Monday;
4388 _M_ymd = year_month_day(_M_sys_days);
4391 else if (__can_use_sun_wk)
4394 sys_days __wk1(__y/January/Sunday[1]);
4395 _M_sys_days = __wk1 +
weeks(__sunday_wk - 1)
4396 +
days(__wday.c_encoding());
4397 _M_ymd = year_month_day(_M_sys_days);
4398 if (_M_ymd.year() != __y) [[unlikely]]
4401 else if (__can_use_mon_wk)
4404 sys_days __wk1(__y/January/Monday[1]);
4405 _M_sys_days = __wk1 +
weeks(__monday_wk - 1)
4406 +
days(__wday.c_encoding() - 1);
4407 _M_ymd = year_month_day(_M_sys_days);
4408 if (_M_ymd.year() != __y) [[unlikely]]
4420 if (_M_need & _ChronoParts::_Year)
4422 if (!__y.ok()) [[unlikely]]
4425 else if (__y == __bad_y)
4428 if (_M_need & _ChronoParts::_Month)
4430 if (!__m.ok()) [[unlikely]]
4433 else if (__m == __bad_mon)
4436 if (_M_need & _ChronoParts::_Day)
4438 if (__d < day(1) || __d > (__y/__m/last).day())
4441 else if (__d == __bad_day)
4444 if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
4447 if (__need_wday || __need_time)
4448 _M_sys_days = sys_days(_M_ymd);
4455 _M_wd = weekday(_M_sys_days);
4461 if (__h == __bad_h && __h12 != __bad_h)
4465 else if (__ampm == 2)
4466 __h = __h12 ==
hours(12) ? __h12 : __h12 +
hours(12);
4471 auto __t = _M_time.zero();
4480 if (__min != __bad_min)
4486 if (__s != __bad_sec)
4490 _M_is_leap_second = __s >=
seconds(60);
4499 if (!__is_failed(__err)) [[likely]]
4501 if (__offset && __tz_offset != __bad_min)
4502 *__offset = __tz_offset;
4503 if (__abbrev && !__tz_abbr.empty())
4511 __is.setstate(__err);
4515#undef _GLIBCXX_WIDEN
4520_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.