30 #ifndef _GLIBCXX_CHRONO_IO_H 31 #define _GLIBCXX_CHRONO_IO_H 1 33 #pragma GCC system_header 35 #if __cplusplus >= 202002L 43 namespace std _GLIBCXX_VISIBILITY(default)
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
60 template<
typename _CharT>
62 _Widen(
const char* __narrow,
const wchar_t* __wide)
64 if constexpr (is_same_v<_CharT, wchar_t>)
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>
76 __units_suffix_misc(
char* __buf,
size_t ) noexcept
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>
99 __units_suffix(
char* __buf,
size_t __n) noexcept
104 #define _GLIBCXX_UNITS_SUFFIX(period, suffix) \ 105 if constexpr (is_same_v<_Period, period>) \ 106 return _GLIBCXX_WIDEN(suffix); \ 109 _GLIBCXX_UNITS_SUFFIX(atto,
"as")
110 _GLIBCXX_UNITS_SUFFIX(femto, "fs")
111 _GLIBCXX_UNITS_SUFFIX(pico, "ps")
112 _GLIBCXX_UNITS_SUFFIX(nano, "ns")
113 _GLIBCXX_UNITS_SUFFIX(milli, "ms")
114 #if _GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX 117 _GLIBCXX_UNITS_SUFFIX(micro,
"\u00b5s")
119 _GLIBCXX_UNITS_SUFFIX(micro,
"us")
121 _GLIBCXX_UNITS_SUFFIX(centi,
"cs")
122 _GLIBCXX_UNITS_SUFFIX(deci, "ds")
123 _GLIBCXX_UNITS_SUFFIX(ratio<1>, "s")
124 _GLIBCXX_UNITS_SUFFIX(deca, "das")
125 _GLIBCXX_UNITS_SUFFIX(hecto, "hs")
126 _GLIBCXX_UNITS_SUFFIX(kilo, "ks")
127 _GLIBCXX_UNITS_SUFFIX(mega, "Ms")
128 _GLIBCXX_UNITS_SUFFIX(giga, "Gs")
129 _GLIBCXX_UNITS_SUFFIX(tera, "Ts")
130 _GLIBCXX_UNITS_SUFFIX(tera, "Ts")
131 _GLIBCXX_UNITS_SUFFIX(peta, "Ps")
132 _GLIBCXX_UNITS_SUFFIX(exa, "Es")
133 _GLIBCXX_UNITS_SUFFIX(ratio<60>, "
min")
134 _GLIBCXX_UNITS_SUFFIX(ratio<3600>, "h")
135 _GLIBCXX_UNITS_SUFFIX(ratio<86400>, "d")
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>
148 inline basic_ostream<_CharT, _Traits>&
149 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
152 using period =
typename _Period::type;
155 __s.
flags(__os.flags());
156 __s.imbue(__os.getloc());
157 __s.precision(__os.precision());
159 __s << __detail::__units_suffix<period, _CharT>(__buf,
sizeof(__buf));
168 template<
typename _Duration>
169 struct __local_time_fmt
171 local_time<_Duration> _M_time;
172 const string* _M_abbrev;
176 struct __local_fmt_t;
189 template<
typename _Duration>
190 inline __detail::__local_time_fmt<_Duration>
192 const string* __abbrev =
nullptr,
193 const seconds* __offset_sec =
nullptr)
194 {
return {__time, __abbrev, __offset_sec}; }
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>)
591 __out = std::format_to(__print_sign(), _S_empty_spec,
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,
671 auto __str =
std::
move(__sink).get();
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);
795 return std::vformat_to(
std::move(__out), __loc, __fmt,
796 std::make_format_args<_FormatContext>(__t));
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')
830 __s.assign(1, _S_plus_minus[1]);
831 int __ci = __yi / 100;
832 if (__ci >= 100) [[unlikely]]
834 __s += std::format(_S_empty_spec, __ci / 100);
837 __s += _S_two_digits(__ci);
840 if (__conv ==
'Y' || __conv ==
'y')
841 __s += _S_two_digits(__yi % 100);
843 return __format::__write(
std::move(__out), __string_view(__s));
846 template<
typename _Tp,
typename _FormatContext>
847 typename _FormatContext::iterator
848 _M_D(
const _Tp& __t,
typename _FormatContext::iterator __out,
849 _FormatContext&)
const 851 auto __ymd = _S_date(__t);
852 basic_string<_CharT> __s;
853 #if ! _GLIBCXX_USE_CXX11_ABI 856 __s = _S_two_digits((
unsigned)__ymd.month());
858 __s += _S_two_digits((
unsigned)__ymd.day());
860 __s += _S_two_digits(__builtin_abs((
int)__ymd.year()) % 100);
861 return __format::__write(
std::move(__out), __string_view(__s));
864 template<
typename _Tp,
typename _FormatContext>
865 typename _FormatContext::iterator
866 _M_d_e(
const _Tp& __t,
typename _FormatContext::iterator __out,
867 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const 874 chrono::day __d = _S_day(__t);
875 unsigned __i = (unsigned)__d;
877 if (__mod) [[unlikely]]
881 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
885 auto __sv = _S_two_digits(__i);
887 if (__conv == _CharT(
'e') && __i < 10)
893 return __format::__write(
std::move(__out), __sv);
896 template<
typename _Tp,
typename _FormatContext>
897 typename _FormatContext::iterator
898 _M_F(
const _Tp& __t,
typename _FormatContext::iterator __out,
899 _FormatContext&)
const 901 auto __ymd = _S_date(__t);
902 basic_string<_CharT> __s;
903 #if ! _GLIBCXX_USE_CXX11_ABI 906 __s += std::format(_GLIBCXX_WIDEN(
"{:04d}- - "), (
int)__ymd.year());
907 auto __sv = _S_two_digits((
unsigned)__ymd.month());
908 __s[__s.size() - 5] = __sv[0];
909 __s[__s.size() - 4] = __sv[1];
910 __sv = _S_two_digits((
unsigned)__ymd.day());
911 __s[__s.size() - 2] = __sv[0];
912 __s[__s.size() - 1] = __sv[1];
914 return __format::__write(
std::move(__out), __sv);
917 template<
typename _Tp,
typename _FormatContext>
918 typename _FormatContext::iterator
919 _M_g_G(
const _Tp& __t,
typename _FormatContext::iterator __out,
920 _FormatContext& __ctx,
bool __full)
const 924 using namespace chrono;
925 auto __d = _S_days(__t);
927 __d -= (weekday(__d) - Monday) -
days(3);
929 year __y = year_month_day(__d).year();
930 return _M_C_y_Y(__y,
std::move(__out), __ctx,
"yY"[__full]);
933 template<
typename _Tp,
typename _FormatContext>
934 typename _FormatContext::iterator
935 _M_H_I(
const _Tp& __t,
typename _FormatContext::iterator __out,
936 _FormatContext& __ctx, _CharT __conv,
bool __mod =
false)
const 943 const auto __hms = _S_hms(__t);
944 int __i = __hms.hours().count();
946 if (__mod) [[unlikely]]
950 return _M_locale_fmt(
std::move(__out), _M_locale(__ctx), __tm,
954 if (__conv == _CharT(
'I'))
961 return __format::__write(
std::move(__out), _S_two_digits(__i));
964 template<
typename _Tp,
typename _FormatContext>
965 typename _FormatContext::iterator
966 _M_j(
const _Tp& __t,
typename _FormatContext::iterator __out,
967 _FormatContext&)
const 969 if constexpr (chrono::__is_duration_v<_Tp>)
973 return std::format_to(
std::move(__out), _S_empty_spec, __d);
978 using namespace chrono;
979 auto __day = _S_days(__t);
980 auto __ymd = _S_date(__t);
984 if constexpr (is_same_v<
typename decltype(__day)::clock, local_t>)
985 __d = __day - local_days(__ymd.year()/January/0);
987 __d = __day - sys_days(__ymd.year()/January/0);
988 return
std::format_to(
std::
move(__out), _GLIBCXX_WIDEN("{:03d}
"), 993 template<typename _Tp, typename _FormatContext> 994 typename _FormatContext::iterator 995 _M_m(const _Tp& __t, typename _FormatContext::iterator __out, 996 _FormatContext& __ctx, bool __mod) const 998 // %m month as a decimal number. 999 // %Om Locale's alternative representation. 1001 auto __m = _S_month(__t); 1002 auto __i = (unsigned)__m; 1004 if (__mod) [[unlikely]] // %Om 1007 __tm.tm_mon = __i - 1; 1008 return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm, 1012 return __format::__write(std::move(__out), _S_two_digits(__i)); 1015 template<typename _Tp, typename _FormatContext> 1016 typename _FormatContext::iterator 1017 _M_M(const _Tp& __t, typename _FormatContext::iterator __out, 1018 _FormatContext& __ctx, bool __mod) const 1020 // %M The minute as a decimal number. 1021 // %OM Locale's alternative representation. 1023 auto __m = _S_hms(__t).minutes(); 1024 auto __i = __m.count(); 1026 if (__mod) [[unlikely]] // %OM 1030 return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm, 1034 return __format::__write(std::move(__out), _S_two_digits(__i)); 1037 template<typename _Tp, typename _FormatContext> 1038 typename _FormatContext::iterator 1039 _M_p(const _Tp& __t, typename _FormatContext::iterator __out, 1040 _FormatContext& __ctx) const 1042 // %p The locale's equivalent of the AM/PM designations. 1043 auto __hms = _S_hms(__t); 1044 locale __loc = _M_locale(__ctx); 1045 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 1046 const _CharT* __ampm[2]; 1047 __tp._M_am_pm(__ampm); 1048 return std::format_to(std::move(__out), _S_empty_spec, 1049 __ampm[__hms.hours().count() >= 12]); 1052 template<typename _Tp, typename _FormatContext> 1053 typename _FormatContext::iterator 1054 _M_q(const _Tp&, typename _FormatContext::iterator __out, 1055 _FormatContext& __ctx) const 1057 // %q The duration's unit suffix 1058 if constexpr (!chrono::__is_duration_v<_Tp>) 1059 __throw_format_error("format error: argument is not a duration
"); 1062 using period = typename _Tp::period; 1063 char __buf[sizeof("[/]s
") + 2 * numeric_limits<intmax_t>::digits10]; 1064 constexpr size_t __n = sizeof(__buf); 1065 auto __s = chrono::__detail::__units_suffix<period, _CharT>(__buf, 1067 if constexpr (is_same_v<decltype(__s), const _CharT*>) 1068 return std::format_to(std::move(__out), _S_empty_spec, __s); 1071 // Suffix was written to __buf as narrow string. 1073 size_t __len = __builtin_strlen(__buf); 1074 locale __loc = _M_locale(__ctx); 1075 auto& __ct = use_facet<ctype<_CharT>>(__loc); 1076 __ct.widen(__buf, __len, __wbuf); 1078 return std::format_to(std::move(__out), _S_empty_spec, 1084 // %Q handled in _M_format 1086 template<typename _Tp, typename _FormatContext> 1087 typename _FormatContext::iterator 1088 _M_r(const _Tp& __tt, typename _FormatContext::iterator __out, 1089 _FormatContext& __ctx) const 1091 // %r locale's 12-hour clock time. 1092 auto __t = _S_floor_seconds(__tt); 1093 locale __loc = _M_locale(__ctx); 1094 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 1095 const _CharT* __ampm_fmt; 1096 __tp._M_am_pm_format(&__ampm_fmt); 1097 basic_string<_CharT> __fmt(_S_empty_spec); 1098 __fmt.insert(1u, 1u, _S_colon); 1099 __fmt.insert(2u, __ampm_fmt); 1100 return std::vformat_to(std::move(__out), __fmt, 1101 std::make_format_args<_FormatContext>(__t)); 1104 template<typename _Tp, typename _FormatContext> 1105 typename _FormatContext::iterator 1106 _M_R_T(const _Tp& __t, typename _FormatContext::iterator __out, 1107 _FormatContext& __ctx, bool __secs) const 1109 // %R Equivalent to %H:%M 1110 // %T Equivalent to %H:%M:%S 1111 auto __hms = _S_hms(__t); 1113 basic_string<_CharT> __s; 1114 #if ! _GLIBCXX_USE_CXX11_ABI 1117 __s = std::format(_GLIBCXX_WIDEN("{:02d}:00
"), __hms.hours().count()); 1118 auto __sv = _S_two_digits(__hms.minutes().count()); 1119 __s[__s.size() - 2] = __sv[0]; 1120 __s[__s.size() - 1] = __sv[1]; 1122 __out = __format::__write(std::move(__out), __sv); 1125 *__out++ = _S_colon; 1126 __out = _M_S(__hms, std::move(__out), __ctx); 1131 template<typename _Tp, typename _FormatContext> 1132 typename _FormatContext::iterator 1133 _M_S(const _Tp& __t, typename _FormatContext::iterator __out, 1134 _FormatContext& __ctx, bool __mod = false) const 1136 // %S Seconds as a decimal number. 1137 // %OS The locale's alternative representation. 1138 auto __hms = _S_hms(__t); 1140 if (__mod) [[unlikely]] // %OS 1143 __tm.tm_sec = (int)__hms.seconds().count(); 1144 return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm, 1148 __out = __format::__write(std::move(__out), 1149 _S_two_digits(__hms.seconds().count())); 1150 if constexpr (__hms.fractional_width != 0) 1152 locale __loc = _M_locale(__ctx); 1153 auto __ss = __hms.subseconds(); 1154 using rep = typename decltype(__ss)::rep; 1155 if constexpr (is_floating_point_v<rep>) 1157 __out = std::format_to(__loc, std::move(__out), 1158 _GLIBCXX_WIDEN("{:.{}Lg}
"), 1160 __hms.fractional_width); 1162 else if constexpr (is_integral_v<rep>) 1165 = use_facet<numpunct<_CharT>>(__loc); 1166 __out = std::format_to(std::move(__out), 1167 _GLIBCXX_WIDEN("{}{:0{}}
"), 1168 __np.decimal_point(), 1170 __hms.fractional_width); 1175 = use_facet<numpunct<_CharT>>(__loc); 1176 *__out++ = __np.decimal_point(); 1177 auto __str = std::format(_S_empty_spec, __ss.count()); 1178 __out = std::format_to(_GLIBCXX_WIDEN("{:0>{}s}
"), 1180 __hms.fractional_width); 1186 // %t handled in _M_format 1188 template<typename _Tp, typename _FormatContext> 1189 typename _FormatContext::iterator 1190 _M_u_w(const _Tp& __t, typename _FormatContext::iterator __out, 1191 _FormatContext& __ctx, _CharT __conv, bool __mod = false) const 1193 // %u ISO weekday as a decimal number (1-7), where Monday is 1. 1194 // %Ou Locale's alternative numeric rep. 1195 // %w Weekday as a decimal number (0-6), where Sunday is 0. 1196 // %Ow Locale's alternative numeric rep. 1198 chrono::weekday __wd = _S_weekday(__t); 1200 if (__mod) [[unlikely]] 1203 __tm.tm_wday = __wd.c_encoding(); 1204 return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm, 1208 unsigned __wdi = __conv == 'u' ? __wd.iso_encoding() 1209 : __wd.c_encoding(); 1210 const _CharT __d = _S_digit(__wdi); 1211 return __format::__write(std::move(__out), __string_view(&__d, 1)); 1214 template<typename _Tp, typename _FormatContext> 1215 typename _FormatContext::iterator 1216 _M_U_V_W(const _Tp& __t, typename _FormatContext::iterator __out, 1217 _FormatContext& __ctx, _CharT __conv, bool __mod = false) const 1219 // %U Week number of the year as a decimal number, from first Sunday. 1220 // %OU Locale's alternative numeric rep. 1221 // %V ISO week-based week number as a decimal number. 1222 // %OV Locale's alternative numeric rep. 1223 // %W Week number of the year as a decimal number, from first Monday. 1224 // %OW Locale's alternative numeric rep. 1225 using namespace chrono; 1226 auto __d = _S_days(__t); 1227 using _TDays = decltype(__d); // Either sys_days or local_days. 1229 if (__mod) [[unlikely]] 1231 const year_month_day __ymd(__d); 1232 const year __y = __ymd.year(); 1234 __tm.tm_year = (int)__y - 1900; 1235 __tm.tm_yday = (__d - _TDays(__y/January/1)).count(); 1236 __tm.tm_wday = weekday(__d).c_encoding(); 1237 return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm, 1241 _TDays __first; // First day of week 1. 1242 if (__conv == 'V') // W01 begins on Monday before first Thursday. 1244 // Move to nearest Thursday: 1245 __d -= (weekday(__d) - Monday) - days(3); 1246 // ISO week of __t is number of weeks since January 1 of the 1247 // same year as that nearest Thursday. 1248 __first = _TDays(year_month_day(__d).year()/January/1); 1253 if constexpr (requires { __t.year(); }) 1256 __y = year_month_day(__d).year(); 1257 const weekday __weekstart = __conv == 'U' ? Sunday : Monday; 1258 __first = _TDays(__y/January/__weekstart[1]); 1260 auto __weeks = chrono::floor<weeks>(__d - __first); 1261 __string_view __sv = _S_two_digits(__weeks.count() + 1); 1262 return __format::__write(std::move(__out), __sv); 1265 template<typename _Tp, typename _FormatContext> 1266 typename _FormatContext::iterator 1267 _M_x(const _Tp& __t, typename _FormatContext::iterator __out, 1268 _FormatContext& __ctx, bool __mod = false) const 1270 // %x Locale's date rep 1271 // %Ex Locale's alternative date representation. 1272 locale __loc = _M_locale(__ctx); 1273 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 1274 const _CharT* __date_reps[2]; 1275 __tp._M_date_formats(__date_reps); 1276 const _CharT* __rep = __date_reps[__mod]; 1278 return _M_D(__t, std::move(__out), __ctx); 1280 basic_string<_CharT> __fmt(_S_empty_spec); 1281 __fmt.insert(1u, 1u, _S_colon); 1282 __fmt.insert(2u, __rep); 1283 return std::vformat_to(std::move(__out), __fmt, 1284 std::make_format_args<_FormatContext>(__t)); 1287 template<typename _Tp, typename _FormatContext> 1288 typename _FormatContext::iterator 1289 _M_X(const _Tp& __tt, typename _FormatContext::iterator __out, 1290 _FormatContext& __ctx, bool __mod = false) const 1292 // %X Locale's time rep 1293 // %EX Locale's alternative time representation. 1294 auto __t = _S_floor_seconds(__tt); 1295 locale __loc = _M_locale(__ctx); 1296 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 1297 const _CharT* __time_reps[2]; 1298 __tp._M_time_formats(__time_reps); 1299 const _CharT* __rep = __time_reps[__mod]; 1301 return _M_R_T(__t, std::move(__out), __ctx, true); 1303 basic_string<_CharT> __fmt(_S_empty_spec); 1304 __fmt.insert(1u, 1u, _S_colon); 1305 __fmt.insert(2u, __rep); 1306 return std::vformat_to(std::move(__out), __fmt, 1307 std::make_format_args<_FormatContext>(__t)); 1310 template<typename _Tp, typename _FormatContext> 1311 typename _FormatContext::iterator 1312 _M_z(const _Tp& __t, typename _FormatContext::iterator __out, 1313 _FormatContext&, bool __mod = false) const 1315 using ::std::chrono::__detail::__utc_leap_second; 1316 using ::std::chrono::__detail::__local_time_fmt; 1318 auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN("+00:00
"), 6) 1319 : __string_view(_GLIBCXX_WIDEN("+0000
"), 5); 1321 if constexpr (chrono::__is_time_point_v<_Tp>) 1323 if constexpr (is_same_v<typename _Tp::clock, 1324 chrono::system_clock>) 1325 return __format::__write(std::move(__out), __utc); 1327 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1329 if (__t._M_offset_sec) 1332 basic_string<_CharT> __s; 1333 if (*__t._M_offset_sec != 0s) 1335 chrono:: hh_mm_ss __hms(*__t._M_offset_sec); 1336 __s = _S_plus_minus[__hms.is_negative()]; 1337 __s += _S_two_digits(__hms.hours().count()); 1340 __s += _S_two_digits(__hms.minutes().count()); 1343 return __format::__write(std::move(__out), __sv); 1346 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1347 return __format::__write(std::move(__out), __utc); 1349 __no_timezone_available(); 1352 template<typename _Tp, typename _FormatContext> 1353 typename _FormatContext::iterator 1354 _M_Z(const _Tp& __t, typename _FormatContext::iterator __out, 1355 _FormatContext& __ctx) const 1357 using ::std::chrono::__detail::__utc_leap_second; 1358 using ::std::chrono::__detail::__local_time_fmt; 1360 __string_view __utc(_GLIBCXX_WIDEN("UTC
"), 3); 1361 if constexpr (chrono::__is_time_point_v<_Tp>) 1363 if constexpr (is_same_v<typename _Tp::clock, 1364 chrono::system_clock>) 1365 return __format::__write(std::move(__out), __utc); 1367 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1371 __string_view __wsv; 1372 if constexpr (is_same_v<_CharT, char>) 1373 __wsv = *__t._M_abbrev; 1376 string_view __sv = *__t._M_abbrev; 1377 basic_string<_CharT> __ws(__sv.size(), _CharT()); 1378 auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx)); 1379 __ct.widen(__sv.begin(), __sv.end(), __ws.data()); 1382 return __format::__write(std::move(__out), __wsv); 1385 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1386 return __format::__write(std::move(__out), __utc); 1388 __no_timezone_available(); 1391 // %% handled in _M_format 1393 // A single digit character in the range '0'..'9'. 1395 _S_digit(int __n) noexcept 1397 // Extra 9s avoid past-the-end read on bad input. 1398 return _GLIBCXX_WIDEN("0123456789999999
")[__n & 0xf]; 1401 // A string view of two digit characters, "00
".."99
". 1402 static basic_string_view<_CharT> 1403 _S_two_digits(int __n) noexcept 1406 _GLIBCXX_WIDEN("0001020304050607080910111213141516171819
" 1407 "2021222324252627282930313233343536373839
" 1408 "4041424344454647484950515253545556575859
" 1409 "6061626364656667686970717273747576777879
" 1410 "8081828384858687888990919293949596979899
" 1411 "9999999999999999999999999999999999999999
" 1412 "9999999999999999
") + 2 * (__n & 0x7f), 1417 // Accessors for the components of chrono types: 1419 // Returns a hh_mm_ss. 1420 template<typename _Tp> 1421 static decltype(auto) 1422 _S_hms(const _Tp& __t) 1424 using ::std::chrono::__detail::__utc_leap_second; 1425 using ::std::chrono::__detail::__local_time_fmt; 1427 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>) 1429 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1431 else if constexpr (chrono::__is_duration_v<_Tp>) 1432 return chrono::hh_mm_ss<_Tp>(__t); 1433 else if constexpr (chrono::__is_time_point_v<_Tp>) 1434 return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t)); 1435 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1436 return _S_hms(__t._M_time); 1439 __invalid_chrono_spec(); 1440 return chrono::hh_mm_ss<chrono::seconds>(); 1444 // Returns a sys_days or local_days. 1445 template<typename _Tp> 1447 _S_days(const _Tp& __t) 1449 using namespace chrono; 1450 using ::std::chrono::__detail::__utc_leap_second; 1451 using ::std::chrono::__detail::__local_time_fmt; 1453 if constexpr (__is_time_point_v<_Tp>) 1454 return chrono::floor<days>(__t); 1455 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1457 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1458 return chrono::floor<days>(__t._M_time); 1459 else if constexpr (is_same_v<_Tp, year_month_day> 1460 || is_same_v<_Tp, year_month_day_last> 1461 || is_same_v<_Tp, year_month_weekday> 1462 || is_same_v<_Tp, year_month_weekday_last>) 1463 return sys_days(__t); 1466 if constexpr (__is_duration_v<_Tp>) 1467 __not_valid_for_duration(); 1469 __invalid_chrono_spec(); 1470 return chrono::sys_days(); 1474 // Returns a year_month_day. 1475 template<typename _Tp> 1476 static chrono::year_month_day 1477 _S_date(const _Tp& __t) 1479 if constexpr (is_same_v<_Tp, chrono::year_month_day>) 1482 return chrono::year_month_day(_S_days(__t)); 1485 template<typename _Tp> 1487 _S_day(const _Tp& __t) 1489 using namespace chrono; 1491 if constexpr (is_same_v<_Tp, day>) 1493 else if constexpr (requires { __t.day(); }) 1496 return _S_date(__t).day(); 1499 template<typename _Tp> 1500 static chrono::month 1501 _S_month(const _Tp& __t) 1503 using namespace chrono; 1505 if constexpr (is_same_v<_Tp, month>) 1507 else if constexpr (requires { __t.month(); }) 1510 return _S_date(__t).month(); 1513 template<typename _Tp> 1515 _S_year(const _Tp& __t) 1517 using namespace chrono; 1519 if constexpr (is_same_v<_Tp, year>) 1521 else if constexpr (requires { __t.year(); }) 1524 return _S_date(__t).year(); 1527 template<typename _Tp> 1528 static chrono::weekday 1529 _S_weekday(const _Tp& __t) 1531 using namespace ::std::chrono; 1532 using ::std::chrono::__detail::__local_time_fmt; 1534 if constexpr (is_same_v<_Tp, weekday>) 1536 else if constexpr (requires { __t.weekday(); }) 1537 return __t.weekday(); 1538 else if constexpr (is_same_v<_Tp, month_weekday>) 1539 return __t.weekday_indexed().weekday(); 1540 else if constexpr (is_same_v<_Tp, month_weekday_last>) 1541 return __t.weekday_last().weekday(); 1543 return weekday(_S_days(__t)); 1546 // Remove subsecond precision from a time_point. 1547 template<typename _Tp> 1549 _S_floor_seconds(const _Tp& __t) 1551 using chrono::__detail::__local_time_fmt; 1552 if constexpr (chrono::__is_time_point_v<_Tp> 1553 || chrono::__is_duration_v<_Tp>) 1555 if constexpr (_Tp::period::den != 1) 1556 return chrono::floor<chrono::seconds>(__t); 1560 else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>) 1562 if constexpr (_Tp::fractional_width != 0) 1563 return chrono::floor<chrono::seconds>(__t.to_duration()); 1567 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1568 return _S_floor_seconds(__t._M_time); 1573 // Use the formatting locale's std::time_put facet to produce 1574 // a locale-specific representation. 1575 template<typename _Iter> 1577 _M_locale_fmt(_Iter __out, const locale& __loc, const struct tm& __tm, 1578 char __fmt, char __mod) const 1580 basic_ostringstream<_CharT> __os; 1581 const auto& __tp = use_facet<time_put<_CharT>>(__loc); 1582 __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod); 1584 __out = __format::__write(std::move(__out), __os.view()); 1589 } // namespace __format 1592 template<typename _Rep, typename _Period, typename _CharT>
1593 struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1595 constexpr typename basic_format_parse_context<_CharT>::iterator
1596 parse(basic_format_parse_context<_CharT>& __pc)
1598 using namespace __format;
1599 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1600 if constexpr (!is_floating_point_v<_Rep>)
1601 if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1602 __throw_format_error("format error: invalid precision
for duration
"); 1606 template<typename _Out> 1607 typename basic_format_context<_Out, _CharT>::iterator 1608 format(const chrono::duration<_Rep, _Period>& __d, 1609 basic_format_context<_Out, _CharT>& __fc) const 1611 return _M_f._M_format(chrono::abs(__d), __fc, __d < __d.zero()); 1615 __format::__formatter_chrono<_CharT> _M_f; 1618 template<typename _CharT> 1619 struct formatter<chrono::day, _CharT> 1621 template<typename _ParseContext> 1622 constexpr typename _ParseContext::iterator 1623 parse(_ParseContext& __pc) 1624 { return _M_f._M_parse(__pc, __format::_Day); } 1626 template<typename _FormatContext> 1627 typename _FormatContext::iterator 1628 format(const chrono::day& __t, _FormatContext& __fc) const 1629 { return _M_f._M_format(__t, __fc); } 1632 __format::__formatter_chrono<_CharT> _M_f; 1635 template<typename _CharT> 1636 struct formatter<chrono::month, _CharT> 1638 template<typename _ParseContext> 1639 constexpr typename _ParseContext::iterator 1640 parse(_ParseContext& __pc) 1641 { return _M_f._M_parse(__pc, __format::_Month); } 1643 template<typename _FormatContext> 1644 typename _FormatContext::iterator 1645 format(const chrono::month& __t, _FormatContext& __fc) const 1646 { return _M_f._M_format(__t, __fc); } 1649 __format::__formatter_chrono<_CharT> _M_f; 1652 template<typename _CharT> 1653 struct formatter<chrono::year, _CharT> 1655 template<typename _ParseContext> 1656 constexpr typename _ParseContext::iterator 1657 parse(_ParseContext& __pc) 1658 { return _M_f._M_parse(__pc, __format::_Year); } 1660 template<typename _FormatContext> 1661 typename _FormatContext::iterator 1662 format(const chrono::year& __t, _FormatContext& __fc) const 1663 { return _M_f._M_format(__t, __fc); } 1666 __format::__formatter_chrono<_CharT> _M_f; 1669 template<typename _CharT> 1670 struct formatter<chrono::weekday, _CharT> 1672 template<typename _ParseContext> 1673 constexpr typename _ParseContext::iterator 1674 parse(_ParseContext& __pc) 1675 { return _M_f._M_parse(__pc, __format::_Weekday); } 1677 template<typename _FormatContext> 1678 typename _FormatContext::iterator 1679 format(const chrono::weekday& __t, _FormatContext& __fc) const 1680 { return _M_f._M_format(__t, __fc); } 1683 __format::__formatter_chrono<_CharT> _M_f; 1686 template<typename _CharT> 1687 struct formatter<chrono::weekday_indexed, _CharT> 1689 template<typename _ParseContext> 1690 constexpr typename _ParseContext::iterator 1691 parse(_ParseContext& __pc) 1692 { return _M_f._M_parse(__pc, __format::_Weekday); } 1694 template<typename _FormatContext> 1695 typename _FormatContext::iterator 1696 format(const chrono::weekday_indexed& __t, _FormatContext& __fc) const 1697 { return _M_f._M_format(__t, __fc); } 1700 __format::__formatter_chrono<_CharT> _M_f; 1703 template<typename _CharT> 1704 struct formatter<chrono::weekday_last, _CharT> 1706 template<typename _ParseContext> 1707 constexpr typename _ParseContext::iterator 1708 parse(_ParseContext& __pc) 1709 { return _M_f._M_parse(__pc, __format::_Weekday); } 1711 template<typename _FormatContext> 1712 typename _FormatContext::iterator 1713 format(const chrono::weekday_last& __t, _FormatContext& __fc) const 1714 { return _M_f._M_format(__t, __fc); } 1717 __format::__formatter_chrono<_CharT> _M_f; 1720 template<typename _CharT> 1721 struct formatter<chrono::month_day, _CharT> 1723 template<typename _ParseContext> 1724 constexpr typename _ParseContext::iterator 1725 parse(_ParseContext& __pc) 1726 { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); } 1728 template<typename _FormatContext> 1729 typename _FormatContext::iterator 1730 format(const chrono::month_day& __t, _FormatContext& __fc) const 1731 { return _M_f._M_format(__t, __fc); } 1734 __format::__formatter_chrono<_CharT> _M_f; 1737 template<typename _CharT> 1738 struct formatter<chrono::month_day_last, _CharT> 1740 template<typename _ParseContext> 1741 constexpr typename _ParseContext::iterator 1742 parse(_ParseContext& __pc) 1743 { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); } 1745 template<typename _FormatContext> 1746 typename _FormatContext::iterator 1747 format(const chrono::month_day_last& __t, _FormatContext& __fc) const 1748 { return _M_f._M_format(__t, __fc); } 1751 __format::__formatter_chrono<_CharT> _M_f; 1754 template<typename _CharT> 1755 struct formatter<chrono::month_weekday, _CharT> 1757 template<typename _ParseContext> 1758 constexpr typename _ParseContext::iterator 1759 parse(_ParseContext& __pc) 1760 { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); } 1762 template<typename _FormatContext> 1763 typename _FormatContext::iterator 1764 format(const chrono::month_weekday& __t, _FormatContext& __fc) const 1765 { return _M_f._M_format(__t, __fc); } 1768 __format::__formatter_chrono<_CharT> _M_f; 1771 template<typename _CharT> 1772 struct formatter<chrono::month_weekday_last, _CharT> 1774 template<typename _ParseContext> 1775 constexpr typename _ParseContext::iterator 1776 parse(_ParseContext& __pc) 1777 { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); } 1779 template<typename _FormatContext> 1780 typename _FormatContext::iterator 1781 format(const chrono::month_weekday_last& __t, 1782 _FormatContext& __fc) const 1783 { return _M_f._M_format(__t, __fc); } 1786 __format::__formatter_chrono<_CharT> _M_f; 1789 template<typename _CharT> 1790 struct formatter<chrono::year_month, _CharT> 1792 template<typename _ParseContext> 1793 constexpr typename _ParseContext::iterator 1794 parse(_ParseContext& __pc) 1795 { return _M_f._M_parse(__pc, __format::_Year|__format::_Month); } 1797 template<typename _FormatContext> 1798 typename _FormatContext::iterator 1799 format(const chrono::year_month& __t, _FormatContext& __fc) const 1800 { return _M_f._M_format(__t, __fc); } 1803 __format::__formatter_chrono<_CharT> _M_f; 1806 template<typename _CharT> 1807 struct formatter<chrono::year_month_day, _CharT> 1809 template<typename _ParseContext> 1810 constexpr typename _ParseContext::iterator 1811 parse(_ParseContext& __pc) 1812 { return _M_f._M_parse(__pc, __format::_Date); } 1814 template<typename _FormatContext> 1815 typename _FormatContext::iterator 1816 format(const chrono::year_month_day& __t, _FormatContext& __fc) const 1817 { return _M_f._M_format(__t, __fc); } 1820 __format::__formatter_chrono<_CharT> _M_f; 1823 template<typename _CharT> 1824 struct formatter<chrono::year_month_day_last, _CharT> 1826 template<typename _ParseContext> 1827 constexpr typename _ParseContext::iterator 1828 parse(_ParseContext& __pc) 1829 { return _M_f._M_parse(__pc, __format::_Date); } 1831 template<typename _FormatContext> 1832 typename _FormatContext::iterator 1833 format(const chrono::year_month_day_last& __t, 1834 _FormatContext& __fc) const 1835 { return _M_f._M_format(__t, __fc); } 1838 __format::__formatter_chrono<_CharT> _M_f; 1841 template<typename _CharT> 1842 struct formatter<chrono::year_month_weekday, _CharT> 1844 template<typename _ParseContext> 1845 constexpr typename _ParseContext::iterator 1846 parse(_ParseContext& __pc) 1847 { return _M_f._M_parse(__pc, __format::_Date); } 1849 template<typename _FormatContext> 1850 typename _FormatContext::iterator 1851 format(const chrono::year_month_weekday& __t, 1852 _FormatContext& __fc) const 1853 { return _M_f._M_format(__t, __fc); } 1856 __format::__formatter_chrono<_CharT> _M_f; 1859 template<typename _CharT> 1860 struct formatter<chrono::year_month_weekday_last, _CharT> 1862 template<typename _ParseContext> 1863 constexpr typename _ParseContext::iterator 1864 parse(_ParseContext& __pc) 1865 { return _M_f._M_parse(__pc, __format::_Date); } 1867 template<typename _FormatContext> 1868 typename _FormatContext::iterator 1869 format(const chrono::year_month_weekday_last& __t, 1870 _FormatContext& __fc) const 1871 { return _M_f._M_format(__t, __fc); } 1874 __format::__formatter_chrono<_CharT> _M_f; 1877 template<typename _Rep, typename _Period, typename _CharT> 1878 struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT> 1880 template<typename _ParseContext> 1881 constexpr typename _ParseContext::iterator 1882 parse(_ParseContext& __pc) 1883 { return _M_f._M_parse(__pc, __format::_TimeOfDay); } 1885 template<typename _FormatContext> 1886 typename _FormatContext::iterator 1887 format(const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t, 1888 _FormatContext& __fc) const 1889 { return _M_f._M_format(__t, __fc); } 1892 __format::__formatter_chrono<_CharT> _M_f; 1895 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI 1896 template<typename _CharT> 1897 struct formatter<chrono::sys_info, _CharT> 1899 template<typename _ParseContext> 1900 constexpr typename _ParseContext::iterator 1901 parse(_ParseContext& __pc) 1902 { return _M_f._M_parse(__pc, __format::_ChronoParts{}); } 1904 template<typename _FormatContext> 1905 typename _FormatContext::iterator 1906 format(const chrono::sys_info& __i, _FormatContext& __fc) const 1907 { return _M_f._M_format(__i, __fc); } 1910 __format::__formatter_chrono<_CharT> _M_f; 1913 template<typename _CharT> 1914 struct formatter<chrono::local_info, _CharT> 1916 template<typename _ParseContext> 1917 constexpr typename _ParseContext::iterator 1918 parse(_ParseContext& __pc) 1919 { return _M_f._M_parse(__pc, __format::_ChronoParts{}); } 1921 template<typename _FormatContext> 1922 typename _FormatContext::iterator 1923 format(const chrono::local_info& __i, _FormatContext& __fc) const 1924 { return _M_f._M_format(__i, __fc); } 1927 __format::__formatter_chrono<_CharT> _M_f; 1931 template<typename _Duration, typename _CharT> 1932 struct formatter<chrono::sys_time<_Duration>, _CharT> 1934 template<typename _ParseContext> 1935 constexpr typename _ParseContext::iterator 1936 parse(_ParseContext& __pc) 1937 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1939 template<typename _FormatContext> 1940 typename _FormatContext::iterator 1941 format(const chrono::sys_time<_Duration>& __t, 1942 _FormatContext& __fc) const 1943 { return _M_f._M_format(__t, __fc); } 1946 __format::__formatter_chrono<_CharT> _M_f; 1949 template<typename _Duration, typename _CharT> 1950 struct formatter<chrono::utc_time<_Duration>, _CharT> 1951 : __format::__formatter_chrono<_CharT> 1953 template<typename _ParseContext> 1954 constexpr typename _ParseContext::iterator 1955 parse(_ParseContext& __pc) 1956 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1958 template<typename _FormatContext> 1959 typename _FormatContext::iterator 1960 format(const chrono::utc_time<_Duration>& __t, 1961 _FormatContext& __fc) const 1963 // Adjust by removing leap seconds to get equivalent sys_time. 1964 // We can't just use clock_cast because we want to know if the time 1965 // falls within a leap second insertion, and format seconds as "60
". 1966 using chrono::__detail::__utc_leap_second; 1967 using chrono::seconds; 1968 using chrono::sys_time; 1969 using _CDur = common_type_t<_Duration, seconds>; 1970 const auto __li = chrono::get_leap_second_info(__t); 1971 sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed}; 1972 if (!__li.is_leap_second) [[likely]] 1973 return _M_f._M_format(__s, __fc); 1975 return _M_f._M_format(__utc_leap_second(__s), __fc); 1979 friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>; 1981 __format::__formatter_chrono<_CharT> _M_f; 1984 template<typename _Duration, typename _CharT> 1985 struct formatter<chrono::tai_time<_Duration>, _CharT> 1986 : __format::__formatter_chrono<_CharT> 1988 template<typename _ParseContext> 1989 constexpr typename _ParseContext::iterator 1990 parse(_ParseContext& __pc) 1991 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1993 template<typename _FormatContext> 1994 typename _FormatContext::iterator 1995 format(const chrono::tai_time<_Duration>& __t, 1996 _FormatContext& __fc) const 1998 // Convert to __local_time_fmt with abbrev "TAI
" and offset 0s. 2000 // Offset is 1970y/January/1 - 1958y/January/1 2001 constexpr chrono::days __tai_offset = chrono::days(4383); 2002 using _CDur = common_type_t<_Duration, chrono::days>; 2003 chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset); 2004 const string __abbrev("TAI
", 3); 2005 const chrono::seconds __off = 0s; 2006 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off); 2007 return _M_f._M_format(__lf, __fc); 2011 __format::__formatter_chrono<_CharT> _M_f; 2014 template<typename _Duration, typename _CharT> 2015 struct formatter<chrono::gps_time<_Duration>, _CharT> 2016 : __format::__formatter_chrono<_CharT> 2018 template<typename _ParseContext> 2019 constexpr typename _ParseContext::iterator 2020 parse(_ParseContext& __pc) 2021 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 2023 template<typename _FormatContext> 2024 typename _FormatContext::iterator 2025 format(const chrono::gps_time<_Duration>& __t, 2026 _FormatContext& __fc) const 2028 // Convert to __local_time_fmt with abbrev "GPS
" and offset 0s. 2030 // Offset is 1980y/January/Sunday[1] - 1970y/January/1 2031 constexpr chrono::days __gps_offset = chrono::days(3657); 2032 using _CDur = common_type_t<_Duration, chrono::days>; 2033 chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset); 2034 const string __abbrev("GPS
", 3); 2035 const chrono::seconds __off = 0s; 2036 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off); 2037 return _M_f._M_format(__lf, __fc); 2041 __format::__formatter_chrono<_CharT> _M_f; 2044 template<typename _Duration, typename _CharT> 2045 struct formatter<chrono::file_time<_Duration>, _CharT> 2047 template<typename _ParseContext> 2048 constexpr typename _ParseContext::iterator 2049 parse(_ParseContext& __pc) 2050 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 2052 template<typename _FormatContext> 2053 typename _FormatContext::iterator 2054 format(const chrono::file_time<_Duration>& __t, 2055 _FormatContext& __ctx) const 2057 using namespace chrono; 2058 return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __ctx); 2062 __format::__formatter_chrono<_CharT> _M_f; 2065 template<typename _Duration, typename _CharT> 2066 struct formatter<chrono::local_time<_Duration>, _CharT> 2068 template<typename _ParseContext> 2069 constexpr typename _ParseContext::iterator 2070 parse(_ParseContext& __pc) 2071 { return _M_f._M_parse(__pc, __format::_DateTime); } 2073 template<typename _FormatContext> 2074 typename _FormatContext::iterator 2075 format(const chrono::local_time<_Duration>& __t, 2076 _FormatContext& __ctx) const 2077 { return _M_f._M_format(__t, __ctx); } 2080 __format::__formatter_chrono<_CharT> _M_f; 2083 template<typename _Duration, typename _CharT> 2084 struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT> 2086 template<typename _ParseContext> 2087 constexpr typename _ParseContext::iterator 2088 parse(_ParseContext& __pc) 2089 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 2091 template<typename _FormatContext> 2092 typename _FormatContext::iterator 2093 format(const chrono::__detail::__local_time_fmt<_Duration>& __t, 2094 _FormatContext& __ctx) const 2095 { return _M_f._M_format(__t, __ctx); } 2098 __format::__formatter_chrono<_CharT> _M_f; 2101 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI 2102 template<typename _Duration, typename _TimeZonePtr, typename _CharT> 2103 struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT> 2104 : formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT> 2106 template<typename _FormatContext> 2107 typename _FormatContext::iterator 2108 format(const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp, 2109 _FormatContext& __ctx) const 2111 using chrono::__detail::__local_time_fmt; 2112 using _Base = formatter<__local_time_fmt<_Duration>, _CharT>; 2113 const chrono::sys_info __info = __tp.get_info(); 2114 const auto __lf = chrono::local_time_format(__tp.get_local_time(), 2117 return _Base::format(__lf, __ctx); 2122 // Partial specialization needed for %c formatting of __utc_leap_second. 2123 template<typename _Duration, typename _CharT> 2124 struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT> 2125 : formatter<chrono::utc_time<_Duration>, _CharT> 2127 template<typename _FormatContext> 2128 typename _FormatContext::iterator 2129 format(const chrono::__detail::__utc_leap_second<_Duration>& __t, 2130 _FormatContext& __fc) const 2131 { return this->_M_f._M_format(__t, __fc); } 2139 // TODO: from_stream for duration
2141 template<typename _CharT, typename _Traits, typename _Rep, typename _Period,
2142 typename _Alloc = allocator<_CharT>>
2143 basic_istream<_CharT, _Traits>&
2144 from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2145 duration<_Rep, _Period>& __d,
2146 basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2147 minutes* __offset = nullptr)
2152 template<typename _CharT, typename _Traits>
2153 inline basic_ostream<_CharT, _Traits>&
2154 operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d)
2156 using _Ctx = __conditional_t<is_same_v<_CharT, char>,
2157 format_context, wformat_context>;
2158 using _Str = basic_string_view<_CharT>;
2159 _Str __s = _GLIBCXX_WIDEN("{:02d} is not a valid day
"); 2161 __s = __s.substr(0, 6); 2162 __os << std::vformat(__s, make_format_args<_Ctx>((unsigned)__d)); 2166 // TODO from_stream for day 2168 template<typename _CharT, typename _Traits> 2169 inline basic_ostream<_CharT, _Traits>& 2170 operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m) 2172 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2173 format_context, wformat_context>; 2174 using _Str = basic_string_view<_CharT>; 2175 _Str __s = _GLIBCXX_WIDEN("{:L%b}{} is not a valid month
"); 2177 __os << std::vformat(__os.getloc(), __s.substr(0, 6), 2178 make_format_args<_Ctx>(__m)); 2180 __os << std::vformat(__s.substr(6), 2181 make_format_args<_Ctx>((unsigned)__m)); 2185 // TODO from_stream for month 2187 template<typename _CharT, typename _Traits> 2188 inline basic_ostream<_CharT, _Traits>& 2189 operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y) 2191 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2192 format_context, wformat_context>; 2193 using _Str = basic_string_view<_CharT>; 2194 _Str __s = _GLIBCXX_WIDEN("-{:04d} is not a valid year
"); 2196 __s = __s.substr(0, 7); 2198 if (__i >= 0) [[likely]] 2199 __s.remove_prefix(1); 2202 __os << std::vformat(__s, make_format_args<_Ctx>(__i)); 2206 // TODO from_stream for year 2208 template<typename _CharT, typename _Traits> 2209 inline basic_ostream<_CharT, _Traits>& 2210 operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd) 2212 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2213 format_context, wformat_context>; 2214 using _Str = basic_string_view<_CharT>; 2215 _Str __s = _GLIBCXX_WIDEN("{:L%a}{} is not a valid weekday
"); 2217 __os << std::vformat(__os.getloc(), __s.substr(0, 6), 2218 make_format_args<_Ctx>(__wd)); 2220 __os << std::vformat(__s.substr(6), 2221 make_format_args<_Ctx>(__wd.c_encoding())); 2225 // TODO from_stream for weekday 2227 template<typename _CharT, typename _Traits> 2228 inline basic_ostream<_CharT, _Traits>& 2229 operator<<(basic_ostream<_CharT, _Traits>& __os, 2230 const weekday_indexed& __wdi) 2232 // The standard says to format wdi.weekday() and wdi.index() using 2233 // either "{:L}[{}]
" or "{:L}[{} is not a valid index]
". The {:L} spec 2234 // means to format the weekday using ostringstream, so just do that. 2235 basic_stringstream<_CharT> __os2; 2236 __os2.imbue(__os.getloc()); 2237 __os2 << __wdi.weekday(); 2238 const auto __i = __wdi.index(); 2239 if constexpr (is_same_v<_CharT, char>) 2240 __os2 << std::format("[{}
", __i); 2242 __os2 << std::format(L"[{}
", __i); 2243 basic_string_view<_CharT> __s = _GLIBCXX_WIDEN(" is not a valid index]
"); 2244 if (__i >= 1 && __i <= 5) 2245 __os2 << __s.back(); 2248 __os << __os2.view(); 2252 template<typename _CharT, typename _Traits> 2253 inline basic_ostream<_CharT, _Traits>& 2254 operator<<(basic_ostream<_CharT, _Traits>& __os, 2255 const weekday_last& __wdl) 2257 // As above, just write straight to a stringstream, as if by "{:L}[last]
" 2258 basic_stringstream<_CharT> __os2; 2259 __os2.imbue(__os.getloc()); 2260 __os2 << __wdl.weekday() << _GLIBCXX_WIDEN("[last]
"); 2261 __os << __os2.view(); 2265 template<typename _CharT, typename _Traits> 2266 inline basic_ostream<_CharT, _Traits>& 2267 operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md) 2269 // As above, just write straight to a stringstream, as if by "{:L}/{}
" 2270 basic_stringstream<_CharT> __os2; 2271 __os2.imbue(__os.getloc()); 2272 __os2 << __md.month(); 2273 if constexpr (is_same_v<_CharT, char>) 2277 __os2 << __md.day(); 2278 __os << __os2.view(); 2282 // TODO from_stream for month_day 2284 template<typename _CharT, typename _Traits> 2285 inline basic_ostream<_CharT, _Traits>& 2286 operator<<(basic_ostream<_CharT, _Traits>& __os, 2287 const month_day_last& __mdl) 2289 // As above, just write straight to a stringstream, as if by "{:L}/last
" 2290 basic_stringstream<_CharT> __os2; 2291 __os2.imbue(__os.getloc()); 2292 __os2 << __mdl.month(); 2293 if constexpr (is_same_v<_CharT, char>) 2297 __os << __os2.view(); 2301 template<typename _CharT, typename _Traits> 2302 inline basic_ostream<_CharT, _Traits>& 2303 operator<<(basic_ostream<_CharT, _Traits>& __os, 2304 const month_weekday& __mwd) 2306 // As above, just write straight to a stringstream, as if by "{:L}/{:L}
" 2307 basic_stringstream<_CharT> __os2; 2308 __os2.imbue(__os.getloc()); 2309 __os2 << __mwd.month(); 2310 if constexpr (is_same_v<_CharT, char>) 2314 __os2 << __mwd.weekday_indexed(); 2315 __os << __os2.view(); 2319 template<typename _CharT, typename _Traits> 2320 inline basic_ostream<_CharT, _Traits>& 2321 operator<<(basic_ostream<_CharT, _Traits>& __os, 2322 const month_weekday_last& __mwdl) 2324 // As above, just write straight to a stringstream, as if by "{:L}/{:L}
" 2325 basic_stringstream<_CharT> __os2; 2326 __os2.imbue(__os.getloc()); 2327 __os2 << __mwdl.month(); 2328 if constexpr (is_same_v<_CharT, char>) 2332 __os2 << __mwdl.weekday_last(); 2333 __os << __os2.view(); 2337 template<typename _CharT, typename _Traits> 2338 inline basic_ostream<_CharT, _Traits>& 2339 operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym) 2341 // As above, just write straight to a stringstream, as if by "{}/{:L}
" 2342 basic_stringstream<_CharT> __os2; 2343 __os2.imbue(__os.getloc()); 2344 __os2 << __ym.year(); 2345 if constexpr (is_same_v<_CharT, char>) 2349 __os2 << __ym.month(); 2350 __os << __os2.view(); 2354 // TODO from_stream for year_month 2356 template<typename _CharT, typename _Traits> 2357 inline basic_ostream<_CharT, _Traits>& 2358 operator<<(basic_ostream<_CharT, _Traits>& __os, 2359 const year_month_day& __ymd) 2361 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2362 format_context, wformat_context>; 2363 using _Str = basic_string_view<_CharT>; 2364 _Str __s = _GLIBCXX_WIDEN("{:%F} is not a valid date
"); 2365 __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s, 2366 make_format_args<_Ctx>(__ymd)); 2370 // TODO from_stream for year_month_day 2372 template<typename _CharT, typename _Traits> 2373 inline basic_ostream<_CharT, _Traits>& 2374 operator<<(basic_ostream<_CharT, _Traits>& __os, 2375 const year_month_day_last& __ymdl) 2377 // As above, just write straight to a stringstream, as if by "{}/{:L}
" 2378 basic_stringstream<_CharT> __os2; 2379 __os2.imbue(__os.getloc()); 2380 __os2 << __ymdl.year(); 2381 if constexpr (is_same_v<_CharT, char>) 2385 __os2 << __ymdl.month_day_last(); 2386 __os << __os2.view(); 2390 template<typename _CharT, typename _Traits> 2391 inline basic_ostream<_CharT, _Traits>& 2392 operator<<(basic_ostream<_CharT, _Traits>& __os, 2393 const year_month_weekday& __ymwd) 2395 // As above, just write straight to a stringstream, as if by 2397 basic_stringstream<_CharT> __os2; 2398 __os2.imbue(__os.getloc()); 2400 if constexpr (is_same_v<_CharT, char>) 2404 __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash 2405 << __ymwd.weekday_indexed(); 2406 __os << __os2.view(); 2410 template<typename _CharT, typename _Traits> 2411 inline basic_ostream<_CharT, _Traits>& 2412 operator<<(basic_ostream<_CharT, _Traits>& __os, 2413 const year_month_weekday_last& __ymwdl) 2415 // As above, just write straight to a stringstream, as if by 2417 basic_stringstream<_CharT> __os2; 2418 __os2.imbue(__os.getloc()); 2420 if constexpr (is_same_v<_CharT, char>) 2424 __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash 2425 << __ymwdl.weekday_last(); 2426 __os << __os2.view(); 2430 template<typename _CharT, typename _Traits, typename _Duration> 2431 inline basic_ostream<_CharT, _Traits>& 2432 operator<<(basic_ostream<_CharT, _Traits>& __os, 2433 const hh_mm_ss<_Duration>& __hms) 2435 return __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%T}
"), __hms); 2438 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI 2440 template<typename _CharT, typename _Traits>
2441 basic_ostream<_CharT, _Traits>&
2442 operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __i)
2444 __os << '[' << __i.begin << ',' << __i.end
2445 << ',' << hh_mm_ss(__i.offset) << ',' << __i.save
2446 << ',' << __i.abbrev << ']';
2451 template<typename _CharT, typename _Traits>
2452 basic_ostream<_CharT, _Traits>&
2453 operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __li)
2456 if (__li.result == local_info::unique)
2460 if (__li.result == local_info::nonexistent)
2461 __os << "nonexistent
"; 2463 __os << "ambiguous
"; 2464 __os << " local time between
" << __li.first; 2465 __os << " and
" << __li.second; 2471 template<typename _CharT, typename _Traits, typename _Duration, 2472 typename _TimeZonePtr> 2473 inline basic_ostream<_CharT, _Traits>& 2474 operator<<(basic_ostream<_CharT, _Traits>& __os, 2475 const zoned_time<_Duration, _TimeZonePtr>& __t) 2477 __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T %Z}
"), __t); 2482 template<typename _CharT, typename _Traits, typename _Duration> 2483 requires (!treat_as_floating_point_v<typename _Duration::rep>) 2484 && ratio_less_v<typename _Duration::period, days::period> 2485 inline basic_ostream<_CharT, _Traits>& 2486 operator<<(basic_ostream<_CharT, _Traits>& __os, 2487 const sys_time<_Duration>& __tp) 2489 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __tp); 2493 template<typename _CharT, typename _Traits> 2494 inline basic_ostream<_CharT, _Traits>& 2495 operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp) 2497 __os << year_month_day{__dp}; 2501 // TODO: from_stream for sys_time 2503 template<typename _CharT, typename _Traits, typename _Duration> 2504 inline basic_ostream<_CharT, _Traits>& 2505 operator<<(basic_ostream<_CharT, _Traits>& __os, 2506 const utc_time<_Duration>& __t) 2508 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2512 // TODO: from_stream for utc_time 2514 template<typename _CharT, typename _Traits, typename _Duration> 2515 inline basic_ostream<_CharT, _Traits>& 2516 operator<<(basic_ostream<_CharT, _Traits>& __os, 2517 const tai_time<_Duration>& __t) 2519 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2523 // TODO: from_stream for tai_time 2525 template<typename _CharT, typename _Traits, typename _Duration> 2526 inline basic_ostream<_CharT, _Traits>& 2527 operator<<(basic_ostream<_CharT, _Traits>& __os, 2528 const gps_time<_Duration>& __t) 2530 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2534 // TODO: from_stream for gps_time 2537 template<typename _CharT, typename _Traits, typename _Duration> 2538 inline basic_ostream<_CharT, _Traits>& 2539 operator<<(basic_ostream<_CharT, _Traits>& __os, 2540 const file_time<_Duration>& __t) 2542 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2546 // TODO: from_stream for file_time 2548 template<typename _CharT, typename _Traits, typename _Duration> 2549 inline basic_ostream<_CharT, _Traits>& 2550 operator<<(basic_ostream<_CharT, _Traits>& __os, 2551 const local_time<_Duration>& __lt) 2553 __os << sys_time<_Duration>{__lt.time_since_epoch()}; 2557 // TODO: from_stream for local_time 2558 #undef _GLIBCXX_WIDEN 2561 } // namespace chrono
2563 _GLIBCXX_END_NAMESPACE_VERSION
2568 #endif //_GLIBCXX_CHRONO_IO_H
duration< int64_t > seconds
seconds
static const locale & classic()
Return reference to the C locale.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
__detail::__local_time_fmt< _Duration > local_time_format(local_time< _Duration > __time, const string *__abbrev=nullptr, const seconds *__offset_sec=nullptr)
ISO C++ entities toplevel namespace is std.
Properties of fundamental types.
fmtflags flags() const
Access to format flags.
chrono::time_point represents a point in time as measured by a clock
Controlling output for std::string.
duration< int64_t, ratio< 86400 > > days
days
chrono::duration represents a distance between two points in time
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr __enable_if_is_duration< _ToDur > duration_cast(const duration< _Rep, _Period > &__d)
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.