30#ifndef _GLIBCXX_CHRONO_IO_H
31#define _GLIBCXX_CHRONO_IO_H 1
33#pragma GCC system_header
35#if __cplusplus >= 202002L
45_GLIBCXX_BEGIN_NAMESPACE_VERSION
60 template<
typename _CharT>
69#define _GLIBCXX_WIDEN_(C, S) ::std::chrono::__detail::_Widen<C>(S, L##S)
70#define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
74 template<
typename _Period>
81 unsigned __nlen = __tc::__to_chars_len((uintmax_t)_Period::num);
82 __tc::__to_chars_10_impl(__p + 1,
__nlen, (uintmax_t)_Period::num);
84 if constexpr (_Period::den != 1)
87 unsigned __dlen = __tc::__to_chars_len((uintmax_t)_Period::den);
88 __tc::__to_chars_10_impl(__p + 1,
__dlen, (uintmax_t)_Period::den);
97 template<
typename _Period,
typename _CharT>
104#define _GLIBCXX_UNITS_SUFFIX(period, suffix) \
105 if constexpr (is_same_v<_Period, period>) \
106 return _GLIBCXX_WIDEN(suffix); \
114#if _GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX
136#undef _GLIBCXX_UNITS_SUFFIX
137 return __detail::__units_suffix_misc<_Period>(
__buf, __n);
146 template<
typename _CharT,
typename _Traits,
147 typename _Rep,
typename _Period>
152 using period =
typename _Period::type;
157 __s.precision(
__os.precision());
168 template<
typename _Duration>
189 template<
typename _Duration>
190 inline __detail::__local_time_fmt<_Duration>
202 [[noreturn,__gnu__::__always_inline__]]
204 __no_timezone_available()
205 { __throw_format_error(
"format error: no timezone available for %Z or %z"); }
207 [[noreturn,__gnu__::__always_inline__]]
209 __not_valid_for_duration()
210 { __throw_format_error(
"format error: chrono-format-spec not valid for "
211 "chrono::duration"); }
213 [[noreturn,__gnu__::__always_inline__]]
215 __invalid_chrono_spec()
216 { __throw_format_error(
"format error: chrono-format-spec not valid for "
219 template<
typename _CharT>
220 struct _ChronoSpec : _Spec<_CharT>
222 basic_string_view<_CharT> _M_chrono_specs;
229 _Year = 1, _Month = 2, _Day = 4, _Weekday = 8, _TimeOfDay = 16,
231 _Date = _Year | _Month | _Day | _Weekday,
232 _DateTime = _Date | _TimeOfDay,
233 _ZonedDateTime = _DateTime | _TimeZone,
237 constexpr _ChronoParts
238 operator|(_ChronoParts __x, _ChronoParts __y)
239 {
return static_cast<_ChronoParts
>((int)__x | (
int)__y); }
242 template<
typename _CharT>
243 struct __formatter_chrono
245 using __string_view = basic_string_view<_CharT>;
246 using __string = basic_string<_CharT>;
248 template<
typename _ParseContext>
249 constexpr typename _ParseContext::iterator
250 _M_parse(_ParseContext& __pc, _ChronoParts __parts)
252 auto __first = __pc.
begin();
253 auto __last = __pc.end();
255 _ChronoSpec<_CharT> __spec{};
257 auto __finalize = [
this, &__spec] {
261 auto __finished = [&] {
262 if (__first == __last || *__first ==
'}')
273 __first = __spec._M_parse_fill_and_align(__first, __last);
277 __first = __spec._M_parse_width(__first, __last, __pc);
281 if (__parts & _ChronoParts::_Duration)
283 __first = __spec._M_parse_precision(__first, __last, __pc);
288 __first = __spec._M_parse_locale(__first, __last);
295 __string_view __str(__first, __last - __first);
296 auto __end = __str.find(
'}');
297 if (__end != __str.npos)
299 __str.remove_suffix(__str.length() - __end);
300 __last = __first + __end;
302 if (__str.find(
'{') != __str.npos)
303 __throw_format_error(
"chrono format error: '{' in chrono-specs");
310 const auto __chrono_specs = __first++;
311 if (*__chrono_specs !=
'%')
312 __throw_format_error(
"chrono format error: no '%' at start of "
319 while (__first != __last)
321 enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
322 _Mods __allowed_mods = _Mod_none;
324 _CharT __c = *__first++;
337 __needed = _DateTime;
338 __allowed_mods = _Mod_E;
342 __allowed_mods = _Mod_E;
347 __allowed_mods = _Mod_O;
359 __needed = _TimeOfDay;
360 __allowed_mods = _Mod_O;
363 if (!(__parts & _Duration))
368 __allowed_mods = _Mod_O;
371 __needed = _TimeOfDay;
372 __allowed_mods = _Mod_O;
378 __needed = _TimeOfDay;
382 __needed = _Duration;
385 __needed = _TimeOfDay;
386 __allowed_mods = _Mod_O;
391 __allowed_mods = _Mod_O;
397 __allowed_mods = _Mod_O;
401 __allowed_mods = _Mod_E;
404 __needed = _TimeOfDay;
405 __allowed_mods = _Mod_E;
409 __allowed_mods = _Mod_E_O;
413 __allowed_mods = _Mod_E;
416 __needed = _TimeZone;
417 __allowed_mods = _Mod_E_O;
420 __needed = _TimeZone;
428 if (__mod) [[unlikely]]
430 __allowed_mods = _Mod_none;
436 __throw_format_error(
"chrono format error: invalid "
437 " specifier in chrono-specs");
440 if ((__mod ==
'E' && !(__allowed_mods & _Mod_E))
441 || (__mod ==
'O' && !(__allowed_mods & _Mod_O)))
442 __throw_format_error(
"chrono format error: invalid "
443 " modifier in chrono-specs");
446 if ((__parts & __needed) != __needed)
447 __throw_format_error(
"chrono format error: format argument "
448 "does not contain the information "
449 "required by the chrono-specs");
452 size_t __pos = __string_view(__first, __last - __first).find(
'%');
457 if (__pos == __string_view::npos)
463 __first += __pos + 1;
468 if (__conv || __mod != _CharT())
469 __throw_format_error(
"chrono format error: unescaped '%' in "
473 _M_spec._M_chrono_specs
474 = __string_view(__chrono_specs, __first - __chrono_specs);
484 template<
typename _Tp,
typename _FormatContext>
485 typename _FormatContext::iterator
486 _M_format(
const _Tp& __t, _FormatContext& __fc,
487 bool __is_neg =
false)
const
489 auto __first = _M_spec._M_chrono_specs.begin();
490 const auto __last = _M_spec._M_chrono_specs.end();
491 if (__first == __last)
492 return _M_format_to_ostream(__t, __fc, __is_neg);
494 _Sink_iter<_CharT> __out;
495 __format::_Str_sink<_CharT> __sink;
496 bool __write_direct =
false;
497 if constexpr (is_same_v<
typename _FormatContext::iterator,
500 if (_M_spec._M_width_kind == __format::_WP_none)
503 __write_direct =
true;
506 __out = __sink.out();
509 __out = __sink.out();
513 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
514 __is_neg = __t.is_negative();
516 auto __print_sign = [&__is_neg, &__out] {
517 if constexpr (chrono::__is_duration_v<_Tp>
518 || __is_specialization_of<_Tp, chrono::hh_mm_ss>)
521 *__out++ = _S_plus_minus[1];
528 constexpr const _CharT* __literals = _GLIBCXX_WIDEN(
"\n\t%");
535 _CharT __c = *__first++;
540 __out = _M_a_A(__t,
std::move(__out), __fc, __c ==
'A');
545 __out = _M_b_B(__t,
std::move(__out), __fc, __c ==
'B');
548 __out = _M_c(__t,
std::move(__out), __fc, __mod ==
'E');
553 __out = _M_C_y_Y(__t,
std::move(__out), __fc, __c, __mod);
557 __out = _M_d_e(__t,
std::move(__out), __fc, __c, __mod ==
'O');
560 __out = _M_D(__t,
std::move(__out), __fc);
563 __out = _M_F(__t,
std::move(__out), __fc);
567 __out = _M_g_G(__t,
std::move(__out), __fc, __c ==
'G');
571 __out = _M_H_I(__t, __print_sign(), __fc, __c, __mod ==
'O');
574 __out = _M_j(__t, __print_sign(), __fc);
577 __out = _M_m(__t,
std::move(__out), __fc, __mod ==
'O');
580 __out = _M_M(__t, __print_sign(), __fc, __mod ==
'O');
583 __out = _M_p(__t,
std::move(__out), __fc);
586 __out = _M_q(__t,
std::move(__out), __fc);
590 if constexpr (chrono::__is_duration_v<_Tp>)
594 __throw_format_error(
"chrono format error: argument is "
598 __out = _M_r(__t, __print_sign(), __fc);
602 __out = _M_R_T(__t, __print_sign(), __fc, __c ==
'T');
605 __out = _M_S(__t, __print_sign(), __fc, __mod ==
'O');
609 __out = _M_u_w(__t,
std::move(__out), __fc, __c, __mod ==
'O');
614 __out = _M_U_V_W(__t,
std::move(__out), __fc, __c,
618 __out = _M_x(__t,
std::move(__out), __fc, __mod ==
'E');
621 __out = _M_X(__t, __print_sign(), __fc, __mod ==
'E');
624 __out = _M_z(__t,
std::move(__out), __fc, (
bool)__mod);
627 __out = _M_Z(__t,
std::move(__out), __fc);
630 *__out++ = __literals[0];
633 *__out++ = __literals[1];
636 *__out++ = __literals[2];
648 __string_view __str(__first, __last - __first);
649 size_t __pos = __str.find(
'%');
654 if (__pos == __str.npos)
658 __str.remove_suffix(__str.length() - __pos);
659 __first += __pos + 1;
661 __out = __format::__write(
std::move(__out), __str);
664 while (__first != __last);
666 if constexpr (is_same_v<
typename _FormatContext::iterator,
672 return __format::__write_padded_as_spec(__str, __str.size(),
676 _ChronoSpec<_CharT> _M_spec;
680 template<
typename _FormatContext>
682 _M_locale(_FormatContext& __fc)
const
684 if (!_M_spec._M_localized)
687 return __fc.locale();
694 template<
typename _Tp,
typename _FormatContext>
695 typename _FormatContext::iterator
696 _M_format_to_ostream(
const _Tp& __t, _FormatContext& __fc,
699 using ::std::chrono::__detail::__utc_leap_second;
700 using ::std::chrono::__detail::__local_time_fmt;
702 if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
703 return _M_format_to_ostream(__t._M_time, __fc,
false);
706 basic_ostringstream<_CharT> __os;
707 __os.imbue(_M_locale(__fc));
709 if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
710 __os << __t._M_date <<
' ' << __t._M_time;
713 if constexpr (chrono::__is_duration_v<_Tp>)
714 if (__is_neg) [[unlikely]]
715 __os << _S_plus_minus[1];
720 return __format::__write_padded_as_spec(__str, __str.size(),
725 static constexpr const _CharT* _S_chars
726 = _GLIBCXX_WIDEN(
"0123456789+-:/ {}");
727 static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
728 static constexpr _CharT _S_colon = _S_chars[12];
729 static constexpr _CharT _S_slash = _S_chars[13];
730 static constexpr _CharT _S_space = _S_chars[14];
731 static constexpr const _CharT* _S_empty_spec = _S_chars + 15;
733 template<
typename _Tp,
typename _FormatContext>
734 typename _FormatContext::iterator
735 _M_a_A(
const _Tp& __t,
typename _FormatContext::iterator __out,
736 _FormatContext& __ctx,
bool __full)
const
740 chrono::weekday __wd = _S_weekday(__t);
742 __throw_format_error(
"format error: invalid weekday");
744 locale __loc = _M_locale(__ctx);
745 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
746 const _CharT* __days[7];
748 __tp._M_days(__days);
750 __tp._M_days_abbreviated(__days);
751 __string_view __str(__days[__wd.c_encoding()]);
752 return __format::__write(
std::move(__out), __str);
755 template<
typename _Tp,
typename _FormatContext>
756 typename _FormatContext::iterator
757 _M_b_B(
const _Tp& __t,
typename _FormatContext::iterator __out,
758 _FormatContext& __ctx,
bool __full)
const
762 chrono::month __m = _S_month(__t);
764 __throw_format_error(
"format error: invalid month");
765 locale __loc = _M_locale(__ctx);
766 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
767 const _CharT* __months[12];
769 __tp._M_months(__months);
771 __tp._M_months_abbreviated(__months);
772 __string_view __str(__months[(
unsigned)__m - 1]);
773 return __format::__write(
std::move(__out), __str);
776 template<
typename _Tp,
typename _FormatContext>
777 typename _FormatContext::iterator
778 _M_c(
const _Tp& __tt,
typename _FormatContext::iterator __out,
779 _FormatContext& __ctx,
bool __mod =
false)
const
784 auto __t = _S_floor_seconds(__tt);
785 locale __loc = _M_locale(__ctx);
786 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
787 const _CharT* __formats[2];
788 __tp._M_date_time_formats(__formats);
789 const _CharT* __rep = __formats[__mod];
791 __rep = _GLIBCXX_WIDEN(
"%a %b %e %H:%M:%S %Y");
792 basic_string<_CharT> __fmt(_S_empty_spec);
793 __fmt.insert(1u, 1u, _S_colon);
794 __fmt.insert(2u, __rep);
799 template<
typename _Tp,
typename _FormatContext>
800 typename _FormatContext::iterator
801 _M_C_y_Y(
const _Tp& __t,
typename _FormatContext::iterator __out,
802 _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0)
const
812 chrono::year __y = _S_year(__t);
814 if (__mod) [[unlikely]]
817 __tm.tm_year = (int)__y - 1900;
818 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
822 basic_string<_CharT> __s;
824 const bool __is_neg = __yi < 0;
825 __yi = __builtin_abs(__yi);
827 if (__conv ==
'Y' || __conv ==
'C')
829 int __ci = __yi / 100;
830 if (__is_neg) [[unlikely]]
832 __s.assign(1, _S_plus_minus[1]);
834 if (__conv ==
'C' && (__ci * 100) != __yi)
837 if (__ci >= 100) [[unlikely]]
839 __s += std::format(_S_empty_spec, __ci / 100);
842 __s += _S_two_digits(__ci);
845 if (__conv ==
'Y' || __conv ==
'y')
846 __s += _S_two_digits(__yi % 100);
848 return __format::__write(
std::move(__out), __string_view(__s));
851 template<
typename _Tp,
typename _FormatContext>
852 typename _FormatContext::iterator
853 _M_D(
const _Tp& __t,
typename _FormatContext::iterator __out,
854 _FormatContext&)
const
856 auto __ymd = _S_date(__t);
857 basic_string<_CharT> __s;
858#if ! _GLIBCXX_USE_CXX11_ABI
861 __s = _S_two_digits((
unsigned)__ymd.month());
863 __s += _S_two_digits((
unsigned)__ymd.day());
865 __s += _S_two_digits(__builtin_abs((
int)__ymd.year()) % 100);
866 return __format::__write(
std::move(__out), __string_view(__s));
869 template<
typename _Tp,
typename _FormatContext>
870 typename _FormatContext::iterator
871 _M_d_e(
const _Tp& __t,
typename _FormatContext::iterator __out,
872 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
879 chrono::day __d = _S_day(__t);
880 unsigned __i = (unsigned)__d;
882 if (__mod) [[unlikely]]
886 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
890 auto __sv = _S_two_digits(__i);
892 if (__conv == _CharT(
'e') && __i < 10)
898 return __format::__write(
std::move(__out), __sv);
901 template<
typename _Tp,
typename _FormatContext>
902 typename _FormatContext::iterator
903 _M_F(
const _Tp& __t,
typename _FormatContext::iterator __out,
904 _FormatContext&)
const
906 auto __ymd = _S_date(__t);
907 basic_string<_CharT> __s;
908#if ! _GLIBCXX_USE_CXX11_ABI
911 __s += std::format(_GLIBCXX_WIDEN(
"{:04d}- - "), (
int)__ymd.year());
912 auto __sv = _S_two_digits((
unsigned)__ymd.month());
913 __s[__s.size() - 5] = __sv[0];
914 __s[__s.size() - 4] = __sv[1];
915 __sv = _S_two_digits((
unsigned)__ymd.day());
916 __s[__s.size() - 2] = __sv[0];
917 __s[__s.size() - 1] = __sv[1];
919 return __format::__write(
std::move(__out), __sv);
922 template<
typename _Tp,
typename _FormatContext>
923 typename _FormatContext::iterator
924 _M_g_G(
const _Tp& __t,
typename _FormatContext::iterator __out,
925 _FormatContext& __ctx,
bool __full)
const
929 using namespace chrono;
930 auto __d = _S_days(__t);
932 __d -= (weekday(__d) - Monday) -
days(3);
934 year __y = year_month_day(__d).year();
935 return _M_C_y_Y(__y,
std::move(__out), __ctx,
"yY"[__full]);
938 template<
typename _Tp,
typename _FormatContext>
939 typename _FormatContext::iterator
940 _M_H_I(
const _Tp& __t,
typename _FormatContext::iterator __out,
941 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
948 const auto __hms = _S_hms(__t);
949 int __i = __hms.hours().count();
951 if (__mod) [[unlikely]]
955 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
959 if (__conv == _CharT(
'I'))
966 return __format::__write(
std::move(__out), _S_two_digits(__i));
969 template<
typename _Tp,
typename _FormatContext>
970 typename _FormatContext::iterator
971 _M_j(
const _Tp& __t,
typename _FormatContext::iterator __out,
972 _FormatContext&)
const
974 if constexpr (chrono::__is_duration_v<_Tp>)
977 unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
983 using namespace chrono;
984 auto __day = _S_days(__t);
985 auto __ymd = _S_date(__t);
989 if constexpr (is_same_v<
typename decltype(__day)::clock, local_t>)
990 __d = __day - local_days(__ymd.year()/January/0);
992 __d = __day - sys_days(__ymd.year()/January/0);
998 template<
typename _Tp,
typename _FormatContext>
999 typename _FormatContext::iterator
1000 _M_m(
const _Tp& __t,
typename _FormatContext::iterator __out,
1001 _FormatContext& __ctx,
bool __mod)
const
1006 auto __m = _S_month(__t);
1007 auto __i = (unsigned)__m;
1009 if (__mod) [[unlikely]]
1012 __tm.tm_mon = __i - 1;
1013 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
1017 return __format::__write(
std::move(__out), _S_two_digits(__i));
1020 template<
typename _Tp,
typename _FormatContext>
1021 typename _FormatContext::iterator
1022 _M_M(
const _Tp& __t,
typename _FormatContext::iterator __out,
1023 _FormatContext& __ctx,
bool __mod)
const
1028 auto __m = _S_hms(__t).minutes();
1029 auto __i = __m.count();
1031 if (__mod) [[unlikely]]
1035 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
1039 return __format::__write(
std::move(__out), _S_two_digits(__i));
1042 template<
typename _Tp,
typename _FormatContext>
1043 typename _FormatContext::iterator
1044 _M_p(
const _Tp& __t,
typename _FormatContext::iterator __out,
1045 _FormatContext& __ctx)
const
1048 auto __hms = _S_hms(__t);
1049 locale __loc = _M_locale(__ctx);
1050 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1051 const _CharT* __ampm[2];
1052 __tp._M_am_pm(__ampm);
1054 __ampm[__hms.hours().count() >= 12]);
1057 template<
typename _Tp,
typename _FormatContext>
1058 typename _FormatContext::iterator
1059 _M_q(
const _Tp&,
typename _FormatContext::iterator __out,
1060 _FormatContext& __ctx)
const
1063 if constexpr (!chrono::__is_duration_v<_Tp>)
1064 __throw_format_error(
"format error: argument is not a duration");
1067 using period =
typename _Tp::period;
1068 char __buf[
sizeof(
"[/]s") + 2 * numeric_limits<intmax_t>::digits10];
1069 constexpr size_t __n =
sizeof(__buf);
1070 auto __s = chrono::__detail::__units_suffix<period, _CharT>(__buf,
1072 if constexpr (is_same_v<
decltype(__s),
const _CharT*>)
1078 size_t __len = __builtin_strlen(__buf);
1079 locale __loc = _M_locale(__ctx);
1080 auto& __ct = use_facet<ctype<_CharT>>(__loc);
1081 __ct.widen(__buf, __len, __wbuf);
1091 template<
typename _Tp,
typename _FormatContext>
1092 typename _FormatContext::iterator
1093 _M_r(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1094 _FormatContext& __ctx)
const
1097 auto __t = _S_floor_seconds(__tt);
1098 locale __loc = _M_locale(__ctx);
1099 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1100 const _CharT* __ampm_fmt;
1101 __tp._M_am_pm_format(&__ampm_fmt);
1102 basic_string<_CharT> __fmt(_S_empty_spec);
1103 __fmt.insert(1u, 1u, _S_colon);
1104 __fmt.insert(2u, __ampm_fmt);
1109 template<
typename _Tp,
typename _FormatContext>
1110 typename _FormatContext::iterator
1111 _M_R_T(
const _Tp& __t,
typename _FormatContext::iterator __out,
1112 _FormatContext& __ctx,
bool __secs)
const
1116 auto __hms = _S_hms(__t);
1118 basic_string<_CharT> __s;
1119#if ! _GLIBCXX_USE_CXX11_ABI
1122 __s = std::format(_GLIBCXX_WIDEN(
"{:02d}:00"), __hms.hours().count());
1123 auto __sv = _S_two_digits(__hms.minutes().count());
1124 __s[__s.size() - 2] = __sv[0];
1125 __s[__s.size() - 1] = __sv[1];
1127 __out = __format::__write(
std::move(__out), __sv);
1130 *__out++ = _S_colon;
1131 __out = _M_S(__hms,
std::move(__out), __ctx);
1136 template<
typename _Tp,
typename _FormatContext>
1137 typename _FormatContext::iterator
1138 _M_S(
const _Tp& __t,
typename _FormatContext::iterator __out,
1139 _FormatContext& __ctx,
bool __mod =
false)
const
1143 auto __hms = _S_hms(__t);
1145 if (__mod) [[unlikely]]
1148 __tm.tm_sec = (int)__hms.seconds().count();
1149 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
1153 __out = __format::__write(
std::move(__out),
1154 _S_two_digits(__hms.seconds().count()));
1155 if constexpr (__hms.fractional_width != 0)
1157 locale __loc = _M_locale(__ctx);
1158 auto __ss = __hms.subseconds();
1159 using rep =
typename decltype(__ss)::rep;
1160 if constexpr (is_floating_point_v<rep>)
1163 _GLIBCXX_WIDEN(
"{:.{}Lg}"),
1165 __hms.fractional_width);
1167 else if constexpr (is_integral_v<rep>)
1170 = use_facet<numpunct<_CharT>>(__loc);
1172 _GLIBCXX_WIDEN(
"{}{:0{}}"),
1173 __np.decimal_point(),
1175 __hms.fractional_width);
1180 = use_facet<numpunct<_CharT>>(__loc);
1181 *__out++ = __np.decimal_point();
1182 auto __str = std::format(_S_empty_spec, __ss.count());
1185 __hms.fractional_width);
1193 template<
typename _Tp,
typename _FormatContext>
1194 typename _FormatContext::iterator
1195 _M_u_w(
const _Tp& __t,
typename _FormatContext::iterator __out,
1196 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1203 chrono::weekday __wd = _S_weekday(__t);
1205 if (__mod) [[unlikely]]
1208 __tm.tm_wday = __wd.c_encoding();
1209 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
1213 unsigned __wdi = __conv ==
'u' ? __wd.iso_encoding()
1214 : __wd.c_encoding();
1215 const _CharT __d = _S_digit(__wdi);
1216 return __format::__write(
std::move(__out), __string_view(&__d, 1));
1219 template<
typename _Tp,
typename _FormatContext>
1220 typename _FormatContext::iterator
1221 _M_U_V_W(
const _Tp& __t,
typename _FormatContext::iterator __out,
1222 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const
1230 using namespace chrono;
1231 auto __d = _S_days(__t);
1232 using _TDays =
decltype(__d);
1234 if (__mod) [[unlikely]]
1236 const year_month_day __ymd(__d);
1237 const year __y = __ymd.year();
1239 __tm.tm_year = (int)__y - 1900;
1240 __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
1241 __tm.tm_wday = weekday(__d).c_encoding();
1242 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
1250 __d -= (weekday(__d) - Monday) -
days(3);
1253 __first = _TDays(year_month_day(__d).year()/January/1);
1258 if constexpr (
requires { __t.year(); })
1261 __y = year_month_day(__d).year();
1262 const weekday __weekstart = __conv ==
'U' ? Sunday : Monday;
1263 __first = _TDays(__y/January/__weekstart[1]);
1265 auto __weeks = chrono::floor<weeks>(__d - __first);
1266 __string_view __sv = _S_two_digits(__weeks.count() + 1);
1267 return __format::__write(
std::move(__out), __sv);
1270 template<
typename _Tp,
typename _FormatContext>
1271 typename _FormatContext::iterator
1272 _M_x(
const _Tp& __t,
typename _FormatContext::iterator __out,
1273 _FormatContext& __ctx,
bool __mod =
false)
const
1277 locale __loc = _M_locale(__ctx);
1278 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1279 const _CharT* __date_reps[2];
1280 __tp._M_date_formats(__date_reps);
1281 const _CharT* __rep = __date_reps[__mod];
1283 return _M_D(__t,
std::move(__out), __ctx);
1285 basic_string<_CharT> __fmt(_S_empty_spec);
1286 __fmt.insert(1u, 1u, _S_colon);
1287 __fmt.insert(2u, __rep);
1292 template<
typename _Tp,
typename _FormatContext>
1293 typename _FormatContext::iterator
1294 _M_X(
const _Tp& __tt,
typename _FormatContext::iterator __out,
1295 _FormatContext& __ctx,
bool __mod =
false)
const
1299 auto __t = _S_floor_seconds(__tt);
1300 locale __loc = _M_locale(__ctx);
1301 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
1302 const _CharT* __time_reps[2];
1303 __tp._M_time_formats(__time_reps);
1304 const _CharT* __rep = __time_reps[__mod];
1306 return _M_R_T(__t,
std::move(__out), __ctx,
true);
1308 basic_string<_CharT> __fmt(_S_empty_spec);
1309 __fmt.insert(1u, 1u, _S_colon);
1310 __fmt.insert(2u, __rep);
1315 template<
typename _Tp,
typename _FormatContext>
1316 typename _FormatContext::iterator
1317 _M_z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1318 _FormatContext&,
bool __mod =
false)
const
1320 using ::std::chrono::__detail::__utc_leap_second;
1321 using ::std::chrono::__detail::__local_time_fmt;
1323 auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN(
"+00:00"), 6)
1324 : __string_view(_GLIBCXX_WIDEN(
"+0000"), 5);
1326 if constexpr (chrono::__is_time_point_v<_Tp>)
1328 if constexpr (is_same_v<
typename _Tp::clock,
1329 chrono::system_clock>)
1330 return __format::__write(
std::move(__out), __utc);
1332 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1334 if (__t._M_offset_sec)
1337 basic_string<_CharT> __s;
1338 if (*__t._M_offset_sec != 0s)
1340 chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
1341 __s = _S_plus_minus[__hms.is_negative()];
1342 __s += _S_two_digits(__hms.hours().count());
1345 __s += _S_two_digits(__hms.minutes().count());
1348 return __format::__write(
std::move(__out), __sv);
1351 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1352 return __format::__write(
std::move(__out), __utc);
1354 __no_timezone_available();
1357 template<
typename _Tp,
typename _FormatContext>
1358 typename _FormatContext::iterator
1359 _M_Z(
const _Tp& __t,
typename _FormatContext::iterator __out,
1360 _FormatContext& __ctx)
const
1362 using ::std::chrono::__detail::__utc_leap_second;
1363 using ::std::chrono::__detail::__local_time_fmt;
1365 __string_view __utc(_GLIBCXX_WIDEN(
"UTC"), 3);
1366 if constexpr (chrono::__is_time_point_v<_Tp>)
1368 if constexpr (is_same_v<
typename _Tp::clock,
1369 chrono::system_clock>)
1370 return __format::__write(
std::move(__out), __utc);
1372 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1376 __string_view __wsv;
1377 if constexpr (is_same_v<_CharT, char>)
1378 __wsv = *__t._M_abbrev;
1381 string_view __sv = *__t._M_abbrev;
1382 basic_string<_CharT> __ws(__sv.size(), _CharT());
1383 auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
1384 __ct.widen(__sv.begin(), __sv.end(), __ws.data());
1387 return __format::__write(
std::move(__out), __wsv);
1390 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1391 return __format::__write(
std::move(__out), __utc);
1393 __no_timezone_available();
1400 _S_digit(
int __n)
noexcept
1403 return _GLIBCXX_WIDEN(
"0123456789999999")[__n & 0xf];
1407 static basic_string_view<_CharT>
1408 _S_two_digits(
int __n)
noexcept
1411 _GLIBCXX_WIDEN(
"0001020304050607080910111213141516171819"
1412 "2021222324252627282930313233343536373839"
1413 "4041424344454647484950515253545556575859"
1414 "6061626364656667686970717273747576777879"
1415 "8081828384858687888990919293949596979899"
1416 "9999999999999999999999999999999999999999"
1417 "9999999999999999") + 2 * (__n & 0x7f),
1425 template<
typename _Tp>
1426 static decltype(
auto)
1427 _S_hms(
const _Tp& __t)
1429 using ::std::chrono::__detail::__utc_leap_second;
1430 using ::std::chrono::__detail::__local_time_fmt;
1432 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1434 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1436 else if constexpr (chrono::__is_duration_v<_Tp>)
1437 return chrono::hh_mm_ss<_Tp>(__t);
1438 else if constexpr (chrono::__is_time_point_v<_Tp>)
1439 return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
1440 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1441 return _S_hms(__t._M_time);
1444 __invalid_chrono_spec();
1445 return chrono::hh_mm_ss<chrono::seconds>();
1450 template<
typename _Tp>
1452 _S_days(
const _Tp& __t)
1454 using namespace chrono;
1455 using ::std::chrono::__detail::__utc_leap_second;
1456 using ::std::chrono::__detail::__local_time_fmt;
1458 if constexpr (__is_time_point_v<_Tp>)
1459 return chrono::floor<days>(__t);
1460 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
1462 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1463 return chrono::floor<days>(__t._M_time);
1464 else if constexpr (is_same_v<_Tp, year_month_day>
1465 || is_same_v<_Tp, year_month_day_last>
1466 || is_same_v<_Tp, year_month_weekday>
1467 || is_same_v<_Tp, year_month_weekday_last>)
1468 return sys_days(__t);
1471 if constexpr (__is_duration_v<_Tp>)
1472 __not_valid_for_duration();
1474 __invalid_chrono_spec();
1475 return chrono::sys_days();
1480 template<
typename _Tp>
1481 static chrono::year_month_day
1482 _S_date(
const _Tp& __t)
1484 if constexpr (is_same_v<_Tp, chrono::year_month_day>)
1487 return chrono::year_month_day(_S_days(__t));
1490 template<
typename _Tp>
1492 _S_day(
const _Tp& __t)
1494 using namespace chrono;
1496 if constexpr (is_same_v<_Tp, day>)
1498 else if constexpr (
requires { __t.day(); })
1501 return _S_date(__t).day();
1504 template<
typename _Tp>
1505 static chrono::month
1506 _S_month(
const _Tp& __t)
1508 using namespace chrono;
1510 if constexpr (is_same_v<_Tp, month>)
1512 else if constexpr (
requires { __t.month(); })
1515 return _S_date(__t).month();
1518 template<
typename _Tp>
1520 _S_year(
const _Tp& __t)
1522 using namespace chrono;
1524 if constexpr (is_same_v<_Tp, year>)
1526 else if constexpr (
requires { __t.year(); })
1529 return _S_date(__t).year();
1532 template<
typename _Tp>
1533 static chrono::weekday
1534 _S_weekday(
const _Tp& __t)
1537 using ::std::chrono::__detail::__local_time_fmt;
1539 if constexpr (is_same_v<_Tp, weekday>)
1541 else if constexpr (
requires { __t.weekday(); })
1543 else if constexpr (is_same_v<_Tp, month_weekday>)
1544 return __t.weekday_indexed().weekday();
1545 else if constexpr (is_same_v<_Tp, month_weekday_last>)
1546 return __t.weekday_last().weekday();
1548 return weekday(_S_days(__t));
1552 template<
typename _Tp>
1554 _S_floor_seconds(
const _Tp& __t)
1556 using chrono::__detail::__local_time_fmt;
1557 if constexpr (chrono::__is_time_point_v<_Tp>
1558 || chrono::__is_duration_v<_Tp>)
1560 if constexpr (_Tp::period::den != 1)
1561 return chrono::floor<chrono::seconds>(__t);
1565 else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
1567 if constexpr (_Tp::fractional_width != 0)
1568 return chrono::floor<chrono::seconds>(__t.to_duration());
1572 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
1573 return _S_floor_seconds(__t._M_time);
1580 template<
typename _Iter>
1582 _M_locale_fmt(_Iter __out,
const locale& __loc,
const struct tm& __tm,
1583 char __fmt,
char __mod)
const
1585 basic_ostringstream<_CharT> __os;
1586 const auto& __tp = use_facet<time_put<_CharT>>(__loc);
1587 __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
1589 __out = __format::__write(
std::move(__out), __os.view());
1597 template<
typename _Rep,
typename _Period,
typename _CharT>
1598 struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1600 constexpr typename basic_format_parse_context<_CharT>::iterator
1601 parse(basic_format_parse_context<_CharT>& __pc)
1603 using namespace __format;
1604 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1605 if constexpr (!is_floating_point_v<_Rep>)
1606 if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1607 __throw_format_error(
"format error: invalid precision for duration");
1611 template<
typename _Out>
1612 typename basic_format_context<_Out, _CharT>::iterator
1613 format(
const chrono::duration<_Rep, _Period>& __d,
1614 basic_format_context<_Out, _CharT>& __fc)
const
1616 return _M_f._M_format(
chrono::abs(__d), __fc, __d < __d.zero());
1620 __format::__formatter_chrono<_CharT> _M_f;
1623 template<
typename _CharT>
1624 struct formatter<chrono::day, _CharT>
1626 template<
typename _ParseContext>
1627 constexpr typename _ParseContext::iterator
1628 parse(_ParseContext& __pc)
1629 {
return _M_f._M_parse(__pc, __format::_Day); }
1631 template<
typename _FormatContext>
1632 typename _FormatContext::iterator
1633 format(
const chrono::day& __t, _FormatContext& __fc)
const
1634 {
return _M_f._M_format(__t, __fc); }
1637 __format::__formatter_chrono<_CharT> _M_f;
1640 template<
typename _CharT>
1641 struct formatter<chrono::month, _CharT>
1643 template<
typename _ParseContext>
1644 constexpr typename _ParseContext::iterator
1645 parse(_ParseContext& __pc)
1646 {
return _M_f._M_parse(__pc, __format::_Month); }
1648 template<
typename _FormatContext>
1649 typename _FormatContext::iterator
1650 format(
const chrono::month& __t, _FormatContext& __fc)
const
1651 {
return _M_f._M_format(__t, __fc); }
1654 __format::__formatter_chrono<_CharT> _M_f;
1657 template<
typename _CharT>
1658 struct formatter<chrono::year, _CharT>
1660 template<
typename _ParseContext>
1661 constexpr typename _ParseContext::iterator
1662 parse(_ParseContext& __pc)
1663 {
return _M_f._M_parse(__pc, __format::_Year); }
1665 template<
typename _FormatContext>
1666 typename _FormatContext::iterator
1667 format(
const chrono::year& __t, _FormatContext& __fc)
const
1668 {
return _M_f._M_format(__t, __fc); }
1671 __format::__formatter_chrono<_CharT> _M_f;
1674 template<
typename _CharT>
1675 struct formatter<chrono::weekday, _CharT>
1677 template<
typename _ParseContext>
1678 constexpr typename _ParseContext::iterator
1679 parse(_ParseContext& __pc)
1680 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1682 template<
typename _FormatContext>
1683 typename _FormatContext::iterator
1684 format(
const chrono::weekday& __t, _FormatContext& __fc)
const
1685 {
return _M_f._M_format(__t, __fc); }
1688 __format::__formatter_chrono<_CharT> _M_f;
1691 template<
typename _CharT>
1692 struct formatter<chrono::weekday_indexed, _CharT>
1694 template<
typename _ParseContext>
1695 constexpr typename _ParseContext::iterator
1696 parse(_ParseContext& __pc)
1697 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1699 template<
typename _FormatContext>
1700 typename _FormatContext::iterator
1701 format(
const chrono::weekday_indexed& __t, _FormatContext& __fc)
const
1702 {
return _M_f._M_format(__t, __fc); }
1705 __format::__formatter_chrono<_CharT> _M_f;
1708 template<
typename _CharT>
1709 struct formatter<chrono::weekday_last, _CharT>
1711 template<
typename _ParseContext>
1712 constexpr typename _ParseContext::iterator
1713 parse(_ParseContext& __pc)
1714 {
return _M_f._M_parse(__pc, __format::_Weekday); }
1716 template<
typename _FormatContext>
1717 typename _FormatContext::iterator
1718 format(
const chrono::weekday_last& __t, _FormatContext& __fc)
const
1719 {
return _M_f._M_format(__t, __fc); }
1722 __format::__formatter_chrono<_CharT> _M_f;
1725 template<
typename _CharT>
1726 struct formatter<chrono::month_day, _CharT>
1728 template<
typename _ParseContext>
1729 constexpr typename _ParseContext::iterator
1730 parse(_ParseContext& __pc)
1731 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1733 template<
typename _FormatContext>
1734 typename _FormatContext::iterator
1735 format(
const chrono::month_day& __t, _FormatContext& __fc)
const
1736 {
return _M_f._M_format(__t, __fc); }
1739 __format::__formatter_chrono<_CharT> _M_f;
1742 template<
typename _CharT>
1743 struct formatter<chrono::month_day_last, _CharT>
1745 template<
typename _ParseContext>
1746 constexpr typename _ParseContext::iterator
1747 parse(_ParseContext& __pc)
1748 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }
1750 template<
typename _FormatContext>
1751 typename _FormatContext::iterator
1752 format(
const chrono::month_day_last& __t, _FormatContext& __fc)
const
1753 {
return _M_f._M_format(__t, __fc); }
1756 __format::__formatter_chrono<_CharT> _M_f;
1759 template<
typename _CharT>
1760 struct formatter<chrono::month_weekday, _CharT>
1762 template<
typename _ParseContext>
1763 constexpr typename _ParseContext::iterator
1764 parse(_ParseContext& __pc)
1765 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1767 template<
typename _FormatContext>
1768 typename _FormatContext::iterator
1769 format(
const chrono::month_weekday& __t, _FormatContext& __fc)
const
1770 {
return _M_f._M_format(__t, __fc); }
1773 __format::__formatter_chrono<_CharT> _M_f;
1776 template<
typename _CharT>
1777 struct formatter<chrono::month_weekday_last, _CharT>
1779 template<
typename _ParseContext>
1780 constexpr typename _ParseContext::iterator
1781 parse(_ParseContext& __pc)
1782 {
return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }
1784 template<
typename _FormatContext>
1785 typename _FormatContext::iterator
1786 format(
const chrono::month_weekday_last& __t,
1787 _FormatContext& __fc)
const
1788 {
return _M_f._M_format(__t, __fc); }
1791 __format::__formatter_chrono<_CharT> _M_f;
1794 template<
typename _CharT>
1795 struct formatter<chrono::year_month, _CharT>
1797 template<
typename _ParseContext>
1798 constexpr typename _ParseContext::iterator
1799 parse(_ParseContext& __pc)
1800 {
return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }
1802 template<
typename _FormatContext>
1803 typename _FormatContext::iterator
1804 format(
const chrono::year_month& __t, _FormatContext& __fc)
const
1805 {
return _M_f._M_format(__t, __fc); }
1808 __format::__formatter_chrono<_CharT> _M_f;
1811 template<
typename _CharT>
1812 struct formatter<chrono::year_month_day, _CharT>
1814 template<
typename _ParseContext>
1815 constexpr typename _ParseContext::iterator
1816 parse(_ParseContext& __pc)
1817 {
return _M_f._M_parse(__pc, __format::_Date); }
1819 template<
typename _FormatContext>
1820 typename _FormatContext::iterator
1821 format(
const chrono::year_month_day& __t, _FormatContext& __fc)
const
1822 {
return _M_f._M_format(__t, __fc); }
1825 __format::__formatter_chrono<_CharT> _M_f;
1828 template<
typename _CharT>
1829 struct formatter<chrono::year_month_day_last, _CharT>
1831 template<
typename _ParseContext>
1832 constexpr typename _ParseContext::iterator
1833 parse(_ParseContext& __pc)
1834 {
return _M_f._M_parse(__pc, __format::_Date); }
1836 template<
typename _FormatContext>
1837 typename _FormatContext::iterator
1838 format(
const chrono::year_month_day_last& __t,
1839 _FormatContext& __fc)
const
1840 {
return _M_f._M_format(__t, __fc); }
1843 __format::__formatter_chrono<_CharT> _M_f;
1846 template<
typename _CharT>
1847 struct formatter<chrono::year_month_weekday, _CharT>
1849 template<
typename _ParseContext>
1850 constexpr typename _ParseContext::iterator
1851 parse(_ParseContext& __pc)
1852 {
return _M_f._M_parse(__pc, __format::_Date); }
1854 template<
typename _FormatContext>
1855 typename _FormatContext::iterator
1856 format(
const chrono::year_month_weekday& __t,
1857 _FormatContext& __fc)
const
1858 {
return _M_f._M_format(__t, __fc); }
1861 __format::__formatter_chrono<_CharT> _M_f;
1864 template<
typename _CharT>
1865 struct formatter<chrono::year_month_weekday_last, _CharT>
1867 template<
typename _ParseContext>
1868 constexpr typename _ParseContext::iterator
1869 parse(_ParseContext& __pc)
1870 {
return _M_f._M_parse(__pc, __format::_Date); }
1872 template<
typename _FormatContext>
1873 typename _FormatContext::iterator
1874 format(
const chrono::year_month_weekday_last& __t,
1875 _FormatContext& __fc)
const
1876 {
return _M_f._M_format(__t, __fc); }
1879 __format::__formatter_chrono<_CharT> _M_f;
1882 template<
typename _Rep,
typename _Period,
typename _CharT>
1883 struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
1885 template<
typename _ParseContext>
1886 constexpr typename _ParseContext::iterator
1887 parse(_ParseContext& __pc)
1888 {
return _M_f._M_parse(__pc, __format::_TimeOfDay); }
1890 template<
typename _FormatContext>
1891 typename _FormatContext::iterator
1892 format(
const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
1893 _FormatContext& __fc)
const
1894 {
return _M_f._M_format(__t, __fc); }
1897 __format::__formatter_chrono<_CharT> _M_f;
1900#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
1901 template<
typename _CharT>
1902 struct formatter<chrono::sys_info, _CharT>
1904 template<
typename _ParseContext>
1905 constexpr typename _ParseContext::iterator
1906 parse(_ParseContext& __pc)
1907 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
1909 template<
typename _FormatContext>
1910 typename _FormatContext::iterator
1911 format(
const chrono::sys_info& __i, _FormatContext& __fc)
const
1912 {
return _M_f._M_format(__i, __fc); }
1915 __format::__formatter_chrono<_CharT> _M_f;
1918 template<
typename _CharT>
1919 struct formatter<chrono::local_info, _CharT>
1921 template<
typename _ParseContext>
1922 constexpr typename _ParseContext::iterator
1923 parse(_ParseContext& __pc)
1924 {
return _M_f._M_parse(__pc, __format::_ChronoParts{}); }
1926 template<
typename _FormatContext>
1927 typename _FormatContext::iterator
1928 format(
const chrono::local_info& __i, _FormatContext& __fc)
const
1929 {
return _M_f._M_format(__i, __fc); }
1932 __format::__formatter_chrono<_CharT> _M_f;
1936 template<
typename _Duration,
typename _CharT>
1937 struct formatter<chrono::sys_time<_Duration>, _CharT>
1939 template<
typename _ParseContext>
1940 constexpr typename _ParseContext::iterator
1941 parse(_ParseContext& __pc)
1942 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
1944 template<
typename _FormatContext>
1945 typename _FormatContext::iterator
1946 format(
const chrono::sys_time<_Duration>& __t,
1947 _FormatContext& __fc)
const
1948 {
return _M_f._M_format(__t, __fc); }
1951 __format::__formatter_chrono<_CharT> _M_f;
1954 template<
typename _Duration,
typename _CharT>
1955 struct formatter<chrono::utc_time<_Duration>, _CharT>
1956 : __format::__formatter_chrono<_CharT>
1958 template<
typename _ParseContext>
1959 constexpr typename _ParseContext::iterator
1960 parse(_ParseContext& __pc)
1961 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
1963 template<
typename _FormatContext>
1964 typename _FormatContext::iterator
1965 format(
const chrono::utc_time<_Duration>& __t,
1966 _FormatContext& __fc)
const
1971 using chrono::__detail::__utc_leap_second;
1973 using chrono::sys_time;
1974 using _CDur = common_type_t<_Duration, seconds>;
1975 const auto __li = chrono::get_leap_second_info(__t);
1976 sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
1977 if (!__li.is_leap_second) [[likely]]
1978 return _M_f._M_format(__s, __fc);
1980 return _M_f._M_format(__utc_leap_second(__s), __fc);
1984 friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;
1986 __format::__formatter_chrono<_CharT> _M_f;
1989 template<
typename _Duration,
typename _CharT>
1990 struct formatter<chrono::tai_time<_Duration>, _CharT>
1991 : __format::__formatter_chrono<_CharT>
1993 template<
typename _ParseContext>
1994 constexpr typename _ParseContext::iterator
1995 parse(_ParseContext& __pc)
1996 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
1998 template<
typename _FormatContext>
1999 typename _FormatContext::iterator
2000 format(
const chrono::tai_time<_Duration>& __t,
2001 _FormatContext& __fc)
const
2007 using _CDur = common_type_t<_Duration, chrono::days>;
2008 chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
2009 const string __abbrev(
"TAI", 3);
2012 return _M_f._M_format(__lf, __fc);
2016 __format::__formatter_chrono<_CharT> _M_f;
2019 template<
typename _Duration,
typename _CharT>
2020 struct formatter<chrono::gps_time<_Duration>, _CharT>
2021 : __format::__formatter_chrono<_CharT>
2023 template<
typename _ParseContext>
2024 constexpr typename _ParseContext::iterator
2025 parse(_ParseContext& __pc)
2026 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2028 template<
typename _FormatContext>
2029 typename _FormatContext::iterator
2030 format(
const chrono::gps_time<_Duration>& __t,
2031 _FormatContext& __fc)
const
2037 using _CDur = common_type_t<_Duration, chrono::days>;
2038 chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
2039 const string __abbrev(
"GPS", 3);
2042 return _M_f._M_format(__lf, __fc);
2046 __format::__formatter_chrono<_CharT> _M_f;
2049 template<
typename _Duration,
typename _CharT>
2050 struct formatter<chrono::file_time<_Duration>, _CharT>
2052 template<
typename _ParseContext>
2053 constexpr typename _ParseContext::iterator
2054 parse(_ParseContext& __pc)
2055 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2057 template<
typename _FormatContext>
2058 typename _FormatContext::iterator
2059 format(
const chrono::file_time<_Duration>& __t,
2060 _FormatContext& __ctx)
const
2062 using namespace chrono;
2063 return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __ctx);
2067 __format::__formatter_chrono<_CharT> _M_f;
2070 template<
typename _Duration,
typename _CharT>
2071 struct formatter<chrono::local_time<_Duration>, _CharT>
2073 template<
typename _ParseContext>
2074 constexpr typename _ParseContext::iterator
2075 parse(_ParseContext& __pc)
2076 {
return _M_f._M_parse(__pc, __format::_DateTime); }
2078 template<
typename _FormatContext>
2079 typename _FormatContext::iterator
2080 format(
const chrono::local_time<_Duration>& __t,
2081 _FormatContext& __ctx)
const
2082 {
return _M_f._M_format(__t, __ctx); }
2085 __format::__formatter_chrono<_CharT> _M_f;
2088 template<
typename _Duration,
typename _CharT>
2089 struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2091 template<
typename _ParseContext>
2092 constexpr typename _ParseContext::iterator
2093 parse(_ParseContext& __pc)
2094 {
return _M_f._M_parse(__pc, __format::_ZonedDateTime); }
2096 template<
typename _FormatContext>
2097 typename _FormatContext::iterator
2098 format(
const chrono::__detail::__local_time_fmt<_Duration>& __t,
2099 _FormatContext& __ctx)
const
2100 {
return _M_f._M_format(__t, __ctx); }
2103 __format::__formatter_chrono<_CharT> _M_f;
2106#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2107 template<
typename _Duration,
typename _TimeZonePtr,
typename _CharT>
2108 struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
2109 : formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
2111 template<
typename _FormatContext>
2112 typename _FormatContext::iterator
2113 format(
const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
2114 _FormatContext& __ctx)
const
2116 using chrono::__detail::__local_time_fmt;
2117 using _Base = formatter<__local_time_fmt<_Duration>, _CharT>;
2118 const chrono::sys_info __info = __tp.get_info();
2122 return _Base::format(__lf, __ctx);
2128 template<
typename _Duration,
typename _CharT>
2129 struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
2130 : formatter<chrono::utc_time<_Duration>, _CharT>
2132 template<
typename _FormatContext>
2133 typename _FormatContext::iterator
2134 format(
const chrono::__detail::__utc_leap_second<_Duration>& __t,
2136 {
return this->_M_f._M_format(__t,
__fc); }
2146 template<
typename _CharT,
typename _Traits,
typename _Rep,
typename _Period,
2147 typename _Alloc = allocator<_CharT>>
2148 basic_istream<_CharT, _Traits>&
2149 from_stream(basic_istream<_CharT, _Traits>& __is,
const _CharT* __fmt,
2150 duration<_Rep, _Period>& __d,
2151 basic_string<_CharT, _Traits, _Alloc>* __abbrev =
nullptr,
2157 template<
typename _CharT,
typename _Traits>
2158 inline basic_ostream<_CharT, _Traits>&
2159 operator<<(basic_ostream<_CharT, _Traits>& __os,
const day& __d)
2161 using _Ctx = __conditional_t<is_same_v<_CharT, char>,
2162 format_context, wformat_context>;
2163 using _Str = basic_string_view<_CharT>;
2164 _Str __s = _GLIBCXX_WIDEN(
"{:02d} is not a valid day");
2166 __s = __s.substr(0, 6);
2167 __os << std::vformat(__s, make_format_args<_Ctx>((
unsigned)__d));
2173 template<
typename _CharT,
typename _Traits>
2174 inline basic_ostream<_CharT, _Traits>&
2175 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month& __m)
2177 using _Ctx = __conditional_t<is_same_v<_CharT, char>,
2178 format_context, wformat_context>;
2179 using _Str = basic_string_view<_CharT>;
2180 _Str __s = _GLIBCXX_WIDEN(
"{:L%b}{} is not a valid month");
2183 make_format_args<_Ctx>(__m));
2186 make_format_args<_Ctx>((
unsigned)__m));
2192 template<
typename _CharT,
typename _Traits>
2193 inline basic_ostream<_CharT, _Traits>&
2194 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year& __y)
2196 using _Ctx = __conditional_t<is_same_v<_CharT, char>,
2197 format_context, wformat_context>;
2198 using _Str = basic_string_view<_CharT>;
2199 _Str __s = _GLIBCXX_WIDEN(
"-{:04d} is not a valid year");
2201 __s = __s.substr(0, 7);
2203 if (__i >= 0) [[likely]]
2204 __s.remove_prefix(1);
2207 __os << std::vformat(__s, make_format_args<_Ctx>(__i));
2213 template<
typename _CharT,
typename _Traits>
2214 inline basic_ostream<_CharT, _Traits>&
2215 operator<<(basic_ostream<_CharT, _Traits>& __os,
const weekday& __wd)
2217 using _Ctx = __conditional_t<is_same_v<_CharT, char>,
2218 format_context, wformat_context>;
2219 using _Str = basic_string_view<_CharT>;
2220 _Str __s = _GLIBCXX_WIDEN(
"{:L%a}{} is not a valid weekday");
2223 make_format_args<_Ctx>(__wd));
2226 make_format_args<_Ctx>(__wd.c_encoding()));
2232 template<
typename _CharT,
typename _Traits>
2233 inline basic_ostream<_CharT, _Traits>&
2234 operator<<(basic_ostream<_CharT, _Traits>& __os,
2235 const weekday_indexed& __wdi)
2240 basic_stringstream<_CharT> __os2;
2241 __os2.imbue(__os.getloc());
2242 __os2 << __wdi.weekday();
2243 const auto __i = __wdi.index();
2244 if constexpr (is_same_v<_CharT, char>)
2245 __os2 << std::format(
"[{}", __i);
2247 __os2 << std::format(L
"[{}", __i);
2248 basic_string_view<_CharT> __s = _GLIBCXX_WIDEN(
" is not a valid index]");
2249 if (__i >= 1 && __i <= 5)
2250 __os2 << __s.back();
2253 __os << __os2.view();
2257 template<
typename _CharT,
typename _Traits>
2258 inline basic_ostream<_CharT, _Traits>&
2259 operator<<(basic_ostream<_CharT, _Traits>& __os,
2260 const weekday_last& __wdl)
2263 basic_stringstream<_CharT> __os2;
2264 __os2.imbue(__os.getloc());
2265 __os2 << __wdl.weekday() << _GLIBCXX_WIDEN(
"[last]");
2266 __os << __os2.view();
2270 template<
typename _CharT,
typename _Traits>
2271 inline basic_ostream<_CharT, _Traits>&
2272 operator<<(basic_ostream<_CharT, _Traits>& __os,
const month_day& __md)
2275 basic_stringstream<_CharT> __os2;
2276 __os2.imbue(__os.getloc());
2277 __os2 << __md.month();
2278 if constexpr (is_same_v<_CharT, char>)
2282 __os2 << __md.day();
2283 __os << __os2.view();
2289 template<
typename _CharT,
typename _Traits>
2290 inline basic_ostream<_CharT, _Traits>&
2291 operator<<(basic_ostream<_CharT, _Traits>& __os,
2292 const month_day_last& __mdl)
2295 basic_stringstream<_CharT> __os2;
2296 __os2.imbue(__os.getloc());
2297 __os2 << __mdl.month();
2298 if constexpr (is_same_v<_CharT, char>)
2302 __os << __os2.view();
2306 template<
typename _CharT,
typename _Traits>
2307 inline basic_ostream<_CharT, _Traits>&
2308 operator<<(basic_ostream<_CharT, _Traits>& __os,
2309 const month_weekday& __mwd)
2312 basic_stringstream<_CharT> __os2;
2313 __os2.imbue(__os.getloc());
2314 __os2 << __mwd.month();
2315 if constexpr (is_same_v<_CharT, char>)
2319 __os2 << __mwd.weekday_indexed();
2320 __os << __os2.view();
2324 template<
typename _CharT,
typename _Traits>
2325 inline basic_ostream<_CharT, _Traits>&
2326 operator<<(basic_ostream<_CharT, _Traits>& __os,
2327 const month_weekday_last& __mwdl)
2330 basic_stringstream<_CharT> __os2;
2331 __os2.imbue(__os.getloc());
2332 __os2 << __mwdl.month();
2333 if constexpr (is_same_v<_CharT, char>)
2337 __os2 << __mwdl.weekday_last();
2338 __os << __os2.view();
2342 template<
typename _CharT,
typename _Traits>
2343 inline basic_ostream<_CharT, _Traits>&
2344 operator<<(basic_ostream<_CharT, _Traits>& __os,
const year_month& __ym)
2347 basic_stringstream<_CharT> __os2;
2348 __os2.imbue(__os.getloc());
2349 __os2 << __ym.year();
2350 if constexpr (is_same_v<_CharT, char>)
2354 __os2 << __ym.month();
2355 __os << __os2.view();
2361 template<
typename _CharT,
typename _Traits>
2362 inline basic_ostream<_CharT, _Traits>&
2363 operator<<(basic_ostream<_CharT, _Traits>& __os,
2364 const year_month_day& __ymd)
2366 using _Ctx = __conditional_t<is_same_v<_CharT, char>,
2367 format_context, wformat_context>;
2368 using _Str = basic_string_view<_CharT>;
2369 _Str __s = _GLIBCXX_WIDEN(
"{:%F} is not a valid date");
2370 __os <<
std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
2371 make_format_args<_Ctx>(__ymd));
2377 template<
typename _CharT,
typename _Traits>
2378 inline basic_ostream<_CharT, _Traits>&
2379 operator<<(basic_ostream<_CharT, _Traits>& __os,
2380 const year_month_day_last& __ymdl)
2383 basic_stringstream<_CharT> __os2;
2384 __os2.imbue(__os.getloc());
2385 __os2 << __ymdl.year();
2386 if constexpr (is_same_v<_CharT, char>)
2390 __os2 << __ymdl.month_day_last();
2391 __os << __os2.view();
2395 template<
typename _CharT,
typename _Traits>
2396 inline basic_ostream<_CharT, _Traits>&
2397 operator<<(basic_ostream<_CharT, _Traits>& __os,
2398 const year_month_weekday& __ymwd)
2402 basic_stringstream<_CharT> __os2;
2403 __os2.imbue(__os.getloc());
2405 if constexpr (is_same_v<_CharT, char>)
2409 __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
2410 << __ymwd.weekday_indexed();
2411 __os << __os2.view();
2415 template<
typename _CharT,
typename _Traits>
2416 inline basic_ostream<_CharT, _Traits>&
2417 operator<<(basic_ostream<_CharT, _Traits>& __os,
2418 const year_month_weekday_last& __ymwdl)
2422 basic_stringstream<_CharT> __os2;
2423 __os2.imbue(__os.getloc());
2425 if constexpr (is_same_v<_CharT, char>)
2429 __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
2430 << __ymwdl.weekday_last();
2431 __os << __os2.view();
2435 template<
typename _CharT,
typename _Traits,
typename _Duration>
2436 inline basic_ostream<_CharT, _Traits>&
2437 operator<<(basic_ostream<_CharT, _Traits>& __os,
2438 const hh_mm_ss<_Duration>& __hms)
2440 return __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%T}"), __hms);
2443#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
2445 template<
typename _CharT,
typename _Traits>
2446 basic_ostream<_CharT, _Traits>&
2447 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_info& __i)
2449 __os <<
'[' << __i.begin <<
',' << __i.end
2450 <<
',' << hh_mm_ss(__i.offset) <<
',' << __i.save
2451 <<
',' << __i.abbrev <<
']';
2456 template<
typename _CharT,
typename _Traits>
2457 basic_ostream<_CharT, _Traits>&
2458 operator<<(basic_ostream<_CharT, _Traits>& __os,
const local_info& __li)
2461 if (__li.result == local_info::unique)
2465 if (__li.result == local_info::nonexistent)
2466 __os <<
"nonexistent";
2468 __os <<
"ambiguous";
2469 __os <<
" local time between " << __li.first;
2470 __os <<
" and " << __li.second;
2476 template<
typename _CharT,
typename _Traits,
typename _Duration,
2477 typename _TimeZonePtr>
2478 inline basic_ostream<_CharT, _Traits>&
2479 operator<<(basic_ostream<_CharT, _Traits>& __os,
2480 const zoned_time<_Duration, _TimeZonePtr>& __t)
2482 __os << format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T %Z}"), __t);
2487 template<
typename _CharT,
typename _Traits,
typename _Duration>
2488 requires (!treat_as_floating_point_v<typename _Duration::rep>)
2489 && ratio_less_v<typename _Duration::period, days::period>
2490 inline basic_ostream<_CharT, _Traits>&
2491 operator<<(basic_ostream<_CharT, _Traits>& __os,
2492 const sys_time<_Duration>& __tp)
2494 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __tp);
2498 template<
typename _CharT,
typename _Traits>
2499 inline basic_ostream<_CharT, _Traits>&
2500 operator<<(basic_ostream<_CharT, _Traits>& __os,
const sys_days& __dp)
2502 __os << year_month_day{__dp};
2508 template<
typename _CharT,
typename _Traits,
typename _Duration>
2509 inline basic_ostream<_CharT, _Traits>&
2510 operator<<(basic_ostream<_CharT, _Traits>& __os,
2511 const utc_time<_Duration>& __t)
2513 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2519 template<
typename _CharT,
typename _Traits,
typename _Duration>
2520 inline basic_ostream<_CharT, _Traits>&
2521 operator<<(basic_ostream<_CharT, _Traits>& __os,
2522 const tai_time<_Duration>& __t)
2524 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2530 template<
typename _CharT,
typename _Traits,
typename _Duration>
2531 inline basic_ostream<_CharT, _Traits>&
2532 operator<<(basic_ostream<_CharT, _Traits>& __os,
2533 const gps_time<_Duration>& __t)
2535 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2542 template<
typename _CharT,
typename _Traits,
typename _Duration>
2543 inline basic_ostream<_CharT, _Traits>&
2544 operator<<(basic_ostream<_CharT, _Traits>& __os,
2545 const file_time<_Duration>& __t)
2547 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN(
"{:L%F %T}"), __t);
2553 template<
typename _CharT,
typename _Traits,
typename _Duration>
2554 inline basic_ostream<_CharT, _Traits>&
2555 operator<<(basic_ostream<_CharT, _Traits>& __os,
2556 const local_time<_Duration>& __lt)
2558 __os << sys_time<_Duration>{__lt.time_since_epoch()};
2563#undef _GLIBCXX_WIDEN
2568_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< 86400 > > days
days
constexpr enable_if_t< numeric_limits< _Rep >::is_signed, duration< _Rep, _Period > > abs(duration< _Rep, _Period > __d)
basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const duration< _Rep, _Period > &__d)
duration< int64_t, ratio< 60 > > minutes
minutes
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
ISO C++ entities toplevel namespace is std.
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Implementation details not part of the namespace std interface.
ISO C++ 2011 namespace for date and time utilities.
Properties of fundamental types.
Container class for localization functionality.
static const locale & classic()
Return reference to the C locale.