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;
420 __needed = _TimeZone;
421 __allowed_mods = _Mod_E_O;
432 __throw_format_error(
"chrono format error: invalid " 433 " specifier in chrono-specs");
436 if ((__mod ==
'E' && !(__allowed_mods & _Mod_E))
437 || __mod ==
'O' && !(__allowed_mods & _Mod_O))
438 __throw_format_error(
"chrono format error: invalid " 439 " modifier in chrono-specs");
442 if ((__parts & __needed) != __needed)
443 __throw_format_error(
"chrono format error: format argument " 444 "does not contain the information " 445 "required by the chrono-specs");
448 size_t __pos = __string_view(__first, __last - __first).find(
'%');
453 if (__pos == __string_view::npos)
459 __first += __pos + 1;
464 if (__conv || __mod != _CharT())
465 __throw_format_error(
"chrono format error: unescaped '%' in " 469 _M_spec._M_chrono_specs = {__chrono_specs, __first - __chrono_specs};
479 template<
typename _Tp,
typename _FormatContext>
480 typename _FormatContext::iterator
481 _M_format(
const _Tp& __t, _FormatContext& __fc,
482 bool __is_neg =
false)
const 484 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
485 __is_neg = __t.is_negative();
486 else if constexpr (!chrono::__is_duration_v<_Tp>)
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();
511 auto __print_sign = [&__is_neg, &__out] {
514 *__out++ = _S_plus_minus[1];
521 constexpr
const _CharT* __literals = _GLIBCXX_WIDEN(
"\n\t%");
528 _CharT __c = *__first++;
533 __out = _M_a_A(__t,
std::move(__out), __fc, __c ==
'A');
538 __out = _M_b_B(__t,
std::move(__out), __fc, __c ==
'B');
541 __out = _M_c(__t,
std::move(__out), __fc, __mod ==
'E');
546 __out = _M_C_y_Y(__t,
std::move(__out), __fc, __c, __mod);
551 __out = _S_dd_zero_fill((
unsigned)_S_day(__t),
556 __out = _M_D(__t,
std::move(__out), __fc);
559 __out = _M_e(__t,
std::move(__out), __fc, __mod ==
'O');
562 __out = _M_F(__t,
std::move(__out), __fc);
566 __out = _M_g_G(__t,
std::move(__out), __fc, __c ==
'G');
571 __out = _S_dd_zero_fill(_S_hms(__t).
hours().count(),
572 __print_sign(), __fc, __mod ==
'O');
575 __out = _M_I(__t, __print_sign(), __fc, __mod ==
'O');
578 __out = _M_j(__t, __print_sign(), __fc);
583 __out = _S_dd_zero_fill((
unsigned)_S_month(__t),
590 __out = _S_dd_zero_fill(_S_hms(__t).
minutes().count(),
591 __print_sign(), __fc, __mod ==
'O');
594 __out = _M_p(__t,
std::move(__out), __fc);
597 __out = _M_q(__t,
std::move(__out), __fc);
601 if constexpr (chrono::__is_duration_v<_Tp>)
602 __out = std::format_to(__print_sign(), _S_empty_spec,
605 __throw_format_error(
"chrono format error: argument is " 609 __out = _M_r(__t, __print_sign(), __fc);
613 __out = _M_R_T(__t, __print_sign(), __fc, __c ==
'T');
616 __out = _M_S(__t, __print_sign(), __fc, __mod ==
'O');
620 __out = _M_u_w(__t,
std::move(__out), __fc, __c, __mod ==
'O');
625 __out = _M_U_V_W(__t,
std::move(__out), __fc, __c,
629 __out = _M_x(__t,
std::move(__out), __fc, __mod ==
'E');
632 __out = _M_X(__t, __print_sign(), __fc, __mod ==
'E');
635 __out = _M_z(__t,
std::move(__out), __fc, (
bool)__mod);
638 __out = _M_Z(__t,
std::move(__out), __fc);
641 *__out++ = __literals[0];
644 *__out++ = __literals[1];
647 *__out++ = __literals[2];
659 __string_view __str(__first, __last - __first);
660 size_t __pos = __str.find(
'%');
665 if (__pos == __str.npos)
669 __str.remove_suffix(__str.length() - __pos);
670 __first += __pos + 1;
672 __out = __format::__write(
std::move(__out), __str);
675 while (__first != __last);
677 if constexpr (is_same_v<
typename _FormatContext::iterator,
682 auto __str =
std::
move(__sink).get();
683 return __format::__write_padded_as_spec(__str, __str.
size(),
687 _ChronoSpec<_CharT> _M_spec;
691 template<typename _FormatContext>
693 _M_locale(_FormatContext& __fc)
const 695 if (!_M_spec._M_localized)
698 return __fc.locale();
705 template<
typename _Tp,
typename _FormatContext>
706 typename _FormatContext::iterator
707 _M_format_to_ostream(
const _Tp& __t, _FormatContext& __fc,
710 using ::std::chrono::__detail::__utc_leap_second;
711 using ::std::chrono::__detail::__local_time_fmt;
713 if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
714 return _M_format_to_ostream(__t._M_time, __fc,
false);
717 basic_ostringstream<_CharT> __os;
718 __os.imbue(_M_locale(__fc));
720 if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
721 __os << __t._M_date <<
' ' << __t._M_time;
724 if (__is_neg) [[unlikely]]
725 __os << _S_plus_minus[1];
730 return __format::__write_padded_as_spec(__str, __str.size(),
735 static constexpr
const _CharT* _S_chars
736 = _GLIBCXX_WIDEN(
"0123456789+-:/ {}");
737 static constexpr
const _CharT* _S_plus_minus = _S_chars + 10;
738 static constexpr _CharT _S_colon = _S_chars[12];
739 static constexpr _CharT _S_slash = _S_chars[13];
740 static constexpr _CharT _S_space = _S_chars[14];
741 static constexpr
const _CharT* _S_empty_spec = _S_chars + 15;
743 template<
typename _Tp,
typename _FormatContext>
744 typename _FormatContext::iterator
745 _M_a_A(
const _Tp& __t,
typename _FormatContext::iterator __out,
746 _FormatContext& __ctx,
bool __full)
const 750 chrono::weekday __wd = _S_weekday(__t);
752 __throw_format_error(
"format error: invalid weekday");
754 locale __loc = _M_locale(__ctx);
755 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
756 const _CharT* __days[7];
758 __tp._M_days(__days);
760 __tp._M_days_abbreviated(__days);
761 __string_view __str(__days[__wd.c_encoding()]);
762 return __format::__write(
std::move(__out), __str);
765 template<
typename _Tp,
typename _FormatContext>
766 typename _FormatContext::iterator
767 _M_b_B(
const _Tp& __t,
typename _FormatContext::iterator __out,
768 _FormatContext& __ctx,
bool __full)
const 772 chrono::month __m = _S_month(__t);
774 __throw_format_error(
"format error: invalid month");
775 locale __loc = _M_locale(__ctx);
776 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
777 const _CharT* __months[12];
779 __tp._M_months(__months);
781 __tp._M_months_abbreviated(__months);
782 __string_view __str(__months[(
unsigned)__m - 1]);
783 return __format::__write(
std::move(__out), __str);
786 template<
typename _Tp,
typename _FormatContext>
787 typename _FormatContext::iterator
788 _M_c(
const _Tp& __t,
typename _FormatContext::iterator __out,
789 _FormatContext& __ctx,
bool __mod =
false)
const 794 locale __loc = _M_locale(__ctx);
795 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
796 const _CharT* __formats[2];
797 __tp._M_date_time_formats(__formats);
798 const _CharT* __rep = __formats[__mod];
800 __rep = _GLIBCXX_WIDEN(
"%a %b %e %H:%M:%S %Y");
801 basic_string<_CharT> __fmt(_S_empty_spec);
802 __fmt.insert(1u, 1u, _S_colon);
803 __fmt.insert(2u, __rep);
804 return std::vformat_to(
std::move(__out), __loc, __fmt,
805 std::make_format_args<_FormatContext>(__t));
808 template<
typename _Tp,
typename _FormatContext>
809 typename _FormatContext::iterator
810 _M_C_y_Y(
const _Tp& __t,
typename _FormatContext::iterator __out,
811 _FormatContext& __ctx,
char __conv,
char __mod = 0)
const 821 chrono::year __y = _S_year(__t);
829 basic_string<_CharT> __s;
831 const bool __is_neg = __yi < 0;
832 __yi = __builtin_abs(__yi);
834 if (__conv ==
'Y' || __conv ==
'C')
837 __s.assign(1, _S_plus_minus[1]);
838 int __ci = __yi / 100;
839 if (__ci >= 100) [[unlikely]]
841 __s += std::format(_S_empty_spec, __ci / 100);
844 __s += _S_two_digits(__ci);
847 if (__conv ==
'Y' || __conv ==
'y')
848 __s += _S_two_digits(__yi % 100);
851 _S_altnum(_M_locale(__ctx), __s, __is_neg);
853 return __format::__write(
std::move(__out), __string_view(__s));
856 template<
typename _Tp,
typename _FormatContext>
857 typename _FormatContext::iterator
858 _M_D(
const _Tp& __t,
typename _FormatContext::iterator __out,
859 _FormatContext&)
const 861 auto __ymd = _S_date(__t);
862 basic_string<_CharT> __s;
863 #if ! _GLIBCXX_USE_CXX11_ABI 866 __s = _S_two_digits((
unsigned)__ymd.month());
868 __s += _S_two_digits((
unsigned)__ymd.day());
870 __s += _S_two_digits(__builtin_abs((
int)__ymd.year()) % 100);
871 return __format::__write(
std::move(__out), __string_view(__s));
874 template<
typename _Tp,
typename _FormatContext>
875 typename _FormatContext::iterator
876 _M_e(
const _Tp& __t,
typename _FormatContext::iterator __out,
877 _FormatContext& __ctx,
bool __mod =
false)
const 881 chrono::day __d = _S_day(__t);
882 unsigned __i = (unsigned)__d;
883 auto __sv = _S_two_digits(__i);
884 basic_string<_CharT> __s;
886 __sv = _S_altnum(_M_locale(__ctx), __s.assign(__sv));
888 __sv = __s = {_S_space, __sv[1]};
889 return __format::__write(
std::move(__out), __sv);
892 template<
typename _Tp,
typename _FormatContext>
893 typename _FormatContext::iterator
894 _M_F(
const _Tp& __t,
typename _FormatContext::iterator __out,
895 _FormatContext&)
const 897 auto __ymd = _S_date(__t);
898 basic_string<_CharT> __s;
899 #if ! _GLIBCXX_USE_CXX11_ABI 902 __s += std::format(_GLIBCXX_WIDEN(
"{:04d}- - "), (
int)__ymd.year());
903 auto __sv = _S_two_digits((
unsigned)__ymd.month());
904 __s[__s.size() - 5] = __sv[0];
905 __s[__s.size() - 4] = __sv[1];
906 __sv = _S_two_digits((
unsigned)__ymd.day());
907 __s[__s.size() - 2] = __sv[0];
908 __s[__s.size() - 1] = __sv[1];
910 return __format::__write(
std::move(__out), __sv);
913 template<
typename _Tp,
typename _FormatContext>
914 typename _FormatContext::iterator
915 _M_g_G(
const _Tp& __t,
typename _FormatContext::iterator __out,
916 _FormatContext& __ctx,
bool __full)
const 920 using namespace chrono;
921 auto __d = _S_days(__t);
923 __d -= (weekday(__d) - Monday) -
days(3);
925 year __y = year_month_day(__d).year();
926 return _M_C_y_Y(__y,
std::move(__out), __ctx,
"yY"[__full]);
929 template<
typename _Tp,
typename _FormatContext>
930 typename _FormatContext::iterator
931 _M_I(
const _Tp& __t,
typename _FormatContext::iterator __out,
932 _FormatContext& __ctx,
bool __mod =
false)
const 934 auto __hms = _S_hms(__t);
935 int __i = __hms.hours().count();
940 auto __sv = _S_two_digits(__i);
941 basic_string<_CharT> __s;
943 __sv = _S_altnum(_M_locale(__ctx), __s.assign(__sv));
944 return __format::__write(
std::move(__out), __sv);
947 template<
typename _Tp,
typename _FormatContext>
948 typename _FormatContext::iterator
949 _M_j(
const _Tp& __t,
typename _FormatContext::iterator __out,
950 _FormatContext& __ctx)
const 952 if constexpr (chrono::__is_duration_v<_Tp>)
956 return std::format_to(
std::move(__out), _S_empty_spec, __d);
961 using namespace chrono;
962 auto __day = _S_days(__t);
963 auto __ymd = _S_date(__t);
967 if constexpr (is_same_v<
typename decltype(__day)::clock, local_t>)
968 __d = __day - local_days(__ymd.year()/January/0);
970 __d = __day - sys_days(__ymd.year()/January/0);
971 return
std::format_to(
std::
move(__out), _GLIBCXX_WIDEN("{:03d}
"), 976 template<typename _Tp, typename _FormatContext> 977 typename _FormatContext::iterator 978 _M_p(const _Tp& __t, typename _FormatContext::iterator __out, 979 _FormatContext& __ctx) const 981 // %p The locale's equivalent of the AM/PM designations. 982 auto __hms = _S_hms(__t); 983 locale __loc = _M_locale(__ctx); 984 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 985 const _CharT* __ampm[2]; 986 __tp._M_am_pm(__ampm); 987 return std::format_to(std::move(__out), _S_empty_spec, 988 __ampm[__hms.hours().count() >= 12]); 991 template<typename _Tp, typename _FormatContext> 992 typename _FormatContext::iterator 993 _M_q(const _Tp& __t, typename _FormatContext::iterator __out, 994 _FormatContext& __ctx) const 996 // %q The duration's unit suffix 997 if constexpr (!chrono::__is_duration_v<_Tp>) 998 __throw_format_error("format error: argument is not a duration
"); 1001 using period = typename _Tp::period; 1002 char __buf[sizeof("[/]s
") + 2 * numeric_limits<intmax_t>::digits10]; 1003 constexpr size_t __n = sizeof(__buf); 1004 auto __s = chrono::__detail::__units_suffix<period, _CharT>(__buf, 1006 if constexpr (is_same_v<decltype(__s), const _CharT*>) 1007 return std::format_to(std::move(__out), _S_empty_spec, __s); 1010 // Suffix was written to __buf as narrow string. 1012 size_t __len = __builtin_strlen(__buf); 1013 locale __loc = _M_locale(__ctx); 1014 auto& __ct = use_facet<ctype<_CharT>>(__loc); 1015 __ct.widen(__buf, __len, __wbuf); 1017 return std::format_to(std::move(__out), _S_empty_spec, 1023 template<typename _Tp, typename _FormatContext> 1024 typename _FormatContext::iterator 1025 _M_r(const _Tp& __t, typename _FormatContext::iterator __out, 1026 _FormatContext& __ctx) const 1028 // %r locale's 12-hour clock time. 1029 locale __loc = _M_locale(__ctx); 1030 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 1031 const _CharT* __ampm_fmt; 1032 __tp._M_am_pm_format(&__ampm_fmt); 1033 basic_string<_CharT> __fmt(_S_empty_spec); 1034 __fmt.insert(1u, 1u, _S_colon); 1035 __fmt.insert(2u, __ampm_fmt); 1036 return std::vformat_to(std::move(__out), __fmt, 1037 std::make_format_args<_FormatContext>(__t)); 1040 template<typename _Tp, typename _FormatContext> 1041 typename _FormatContext::iterator 1042 _M_R_T(const _Tp& __t, typename _FormatContext::iterator __out, 1043 _FormatContext& __ctx, bool __secs) const 1045 // %R Equivalent to %H:%M 1046 // %T Equivalent to %H:%M:%S 1047 auto __hms = _S_hms(__t); 1049 basic_string<_CharT> __s; 1050 #if ! _GLIBCXX_USE_CXX11_ABI 1053 __s = std::format(_GLIBCXX_WIDEN("{:02d}:00
"), __hms.hours().count()); 1054 auto __sv = _S_two_digits(__hms.minutes().count()); 1055 __s[__s.size() - 2] = __sv[0]; 1056 __s[__s.size() - 1] = __sv[1]; 1058 __out = __format::__write(std::move(__out), __sv); 1061 *__out++ = _S_colon; 1062 __out = _M_S(__hms, std::move(__out), __ctx); 1067 template<typename _Tp, typename _FormatContext> 1068 typename _FormatContext::iterator 1069 _M_S(const _Tp& __t, typename _FormatContext::iterator __out, 1070 _FormatContext& __ctx, bool __mod = false) const 1072 // %S Seconds as a decimal number. 1073 // %OS (TODO) The locale's alternative representation. 1074 auto __hms = _S_hms(__t); 1075 __out = _S_dd_zero_fill(__hms.seconds().count(), 1076 std::move(__out), __ctx, __mod); 1077 using rep = typename decltype(__hms)::precision::rep; 1078 if constexpr (__hms.fractional_width != 0) 1080 locale __loc = _M_locale(__ctx); 1081 auto __ss = __hms.subseconds(); 1082 if constexpr (is_floating_point_v<rep>) 1084 __out = std::format_to(__loc, std::move(__out), 1085 _GLIBCXX_WIDEN("{:.{}Lg}
"), 1087 __hms.fractional_width); 1089 else if constexpr (is_integral_v<rep>) 1092 = use_facet<numpunct<_CharT>>(__loc); 1093 __out = std::format_to(std::move(__out), 1094 _GLIBCXX_WIDEN("{}{:0{}}
"), 1095 __np.decimal_point(), 1097 __hms.fractional_width); 1102 = use_facet<numpunct<_CharT>>(__loc); 1103 *__out++ = __np.decimal_point(); 1104 auto __str = std::format(_S_empty_spec, __ss.count()); 1105 __out = std::format_to(_GLIBCXX_WIDEN("{:0>{}s}
"), 1107 __hms.fractional_width); 1113 // %t handled in _M_format 1115 template<typename _Tp, typename _FormatContext> 1116 typename _FormatContext::iterator 1117 _M_u_w(const _Tp& __t, typename _FormatContext::iterator __out, 1118 _FormatContext& __ctx, _CharT __conv, bool __mod = false) const 1120 // %u ISO weekday as a decimal number (1-7), where Monday is 1. 1121 // %Ou Locale's alternative numeric rep. 1122 // %w Weekday as a decimal number (0-6), where Sunday is 0. 1123 // %Ow Locale's alternative numeric rep. 1124 chrono::weekday __wd = _S_weekday(__t); 1125 unsigned __wdi = __conv == 'u' ? __wd.iso_encoding() 1126 : __wd.c_encoding(); 1127 basic_string<_CharT> __s(1, _S_digit(__wdi)); 1129 _S_altnum(_M_locale(__ctx), __s); 1130 return __format::__write(std::move(__out), __string_view(__s)); 1134 template<typename _Tp, typename _FormatContext> 1135 typename _FormatContext::iterator 1136 _M_U_V_W(const _Tp& __t, typename _FormatContext::iterator __out, 1137 _FormatContext& __ctx, _CharT __conv, bool __mod = false) const 1139 // %U Week number of the year as a decimal number, from first Sunday. 1140 // %OU Locale's alternative numeric rep. 1141 // %V ISO week-based week number as a decimal number. 1142 // %OV Locale's alternative numeric rep. 1143 // %W Week number of the year as a decimal number, from first Monday. 1144 // %OW Locale's alternative numeric rep. 1145 using namespace chrono; 1146 auto __d = _S_days(__t); 1147 using _TDays = decltype(__d); // Either sys_days or local_days. 1149 _TDays __first; // First day of week 1. 1150 if (__conv == 'V') // W01 begins on Monday before first Thursday. 1152 // Move to nearest Thursday: 1153 __d -= (weekday(__d) - Monday) - days(3); 1154 // ISO week of __t is number of weeks since January 1 of the 1155 // same year as that nearest Thursday. 1156 __first = _TDays(year_month_day(__d).year()/January/1); 1161 if constexpr (requires { __t.year(); }) 1164 __y = year_month_day(__d).year(); 1165 const weekday __weekstart = __conv == 'U' ? Sunday : Monday; 1166 __first = _TDays(__y/January/__weekstart[1]); 1168 auto __weeks = chrono::floor<weeks>(__d - __first); 1169 __string_view __sv = _S_two_digits(__weeks.count() + 1); 1170 basic_string<_CharT> __s; 1172 __sv = _S_altnum(_M_locale(__ctx), __s.assign(__sv)); 1173 return __format::__write(std::move(__out), __sv); 1176 template<typename _Tp, typename _FormatContext> 1177 typename _FormatContext::iterator 1178 _M_x(const _Tp& __t, typename _FormatContext::iterator __out, 1179 _FormatContext& __ctx, bool __mod = false) const 1181 // %x Locale's date rep 1182 // %Ex Locale's alternative date representation. 1183 locale __loc = _M_locale(__ctx); 1184 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 1185 const _CharT* __date_reps[2]; 1186 __tp._M_date_formats(__date_reps); 1187 const _CharT* __rep = __date_reps[__mod]; 1189 return _M_D(__t, std::move(__out), __ctx); 1191 basic_string<_CharT> __fmt(_S_empty_spec); 1192 __fmt.insert(1u, 1u, _S_colon); 1193 __fmt.insert(2u, __rep); 1194 return std::vformat_to(std::move(__out), __fmt, 1195 std::make_format_args<_FormatContext>(__t)); 1198 template<typename _Tp, typename _FormatContext> 1199 typename _FormatContext::iterator 1200 _M_X(const _Tp& __t, typename _FormatContext::iterator __out, 1201 _FormatContext& __ctx, bool __mod = false) const 1203 // %X Locale's time rep 1204 // %EX Locale's alternative time representation. 1205 locale __loc = _M_locale(__ctx); 1206 const auto& __tp = use_facet<__timepunct<_CharT>>(__loc); 1207 const _CharT* __time_reps[2]; 1208 __tp._M_time_formats(__time_reps); 1209 const _CharT* __rep = __time_reps[__mod]; 1211 return _M_R_T(__t, std::move(__out), __ctx, true); 1213 basic_string<_CharT> __fmt(_S_empty_spec); 1214 __fmt.insert(1u, 1u, _S_colon); 1215 __fmt.insert(2u, __rep); 1216 return std::vformat_to(std::move(__out), __fmt, 1217 std::make_format_args<_FormatContext>(__t)); 1220 template<typename _Tp, typename _FormatContext> 1221 typename _FormatContext::iterator 1222 _M_z(const _Tp& __t, typename _FormatContext::iterator __out, 1223 _FormatContext& __ctx, bool __mod = false) const 1225 using ::std::chrono::__detail::__utc_leap_second; 1226 using ::std::chrono::__detail::__local_time_fmt; 1228 auto __utc = __mod ? __string_view(_GLIBCXX_WIDEN("+00:00
"), 6) 1229 : __string_view(_GLIBCXX_WIDEN("+0000
"), 5); 1231 if constexpr (chrono::__is_time_point_v<_Tp>) 1233 if constexpr (is_same_v<typename _Tp::clock, 1234 chrono::system_clock>) 1235 return __format::__write(std::move(__out), __utc); 1237 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1239 if (__t._M_offset_sec) 1242 basic_string<_CharT> __s; 1243 if (*__t._M_offset_sec != 0s) 1245 chrono:: hh_mm_ss __hms(*__t._M_offset_sec); 1246 __s = _S_plus_minus[__hms.is_negative()]; 1247 __s += _S_two_digits(__hms.hours().count()); 1250 __s += _S_two_digits(__hms.minutes().count()); 1253 return __format::__write(std::move(__out), __sv); 1256 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1257 return __format::__write(std::move(__out), __utc); 1259 __no_timezone_available(); 1262 template<typename _Tp, typename _FormatContext> 1263 typename _FormatContext::iterator 1264 _M_Z(const _Tp& __t, typename _FormatContext::iterator __out, 1265 _FormatContext& __ctx) const 1267 using ::std::chrono::__detail::__utc_leap_second; 1268 using ::std::chrono::__detail::__local_time_fmt; 1270 __string_view __utc(_GLIBCXX_WIDEN("UTC
"), 3); 1271 if constexpr (chrono::__is_time_point_v<_Tp>) 1273 if constexpr (is_same_v<typename _Tp::clock, 1274 chrono::system_clock>) 1275 return __format::__write(std::move(__out), __utc); 1277 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1281 __string_view __wsv; 1282 if constexpr (is_same_v<_CharT, char>) 1283 __wsv = *__t._M_abbrev; 1286 string_view __sv = *__t._M_abbrev; 1287 basic_string<_CharT> __ws(__sv.size()); 1288 auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx)); 1289 __ct.widen(__sv.data(), __sv.size(), __ws.data()); 1292 return __format::__write(std::move(__out), __wsv); 1295 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1296 return __format::__write(std::move(__out), __utc); 1298 __no_timezone_available(); 1301 // %% handled in _M_format 1303 // A single digit character in the range '0'..'9'. 1305 _S_digit(int __n) noexcept 1307 // Extra 9s avoid past-the-end read on bad input. 1308 return _GLIBCXX_WIDEN("0123456789999999
")[__n & 0xf]; 1311 // A string view of two digit characters, "00
".."99
". 1312 static basic_string_view<_CharT> 1313 _S_two_digits(int __n) noexcept 1316 _GLIBCXX_WIDEN("0001020304050607080910111213141516171819
" 1317 "2021222324252627282930313233343536373839
" 1318 "4041424344454647484950515253545556575859
" 1319 "6061626364656667686970717273747576777879
" 1320 "8081828384858687888990919293949596979899
" 1321 "9999999999999999999999999999999999999999
" 1322 "9999999999999999
") + 2 * (__n & 0x7f), 1327 // Convert a numeric string to the locale's alternative numeric symbols. 1328 static basic_string_view<_CharT> 1329 _S_altnum(const locale& __loc, basic_string<_CharT>& __s, 1330 bool __is_neg = false) 1332 if (__loc == locale::classic()) 1335 #if 0 // TODO how can we access numpunct_cache?! Need to go via std::time_put? 1336 auto& __np = use_facet<__numpunct_cache<_CharT>>(__loc); 1337 auto __nums = __np._M_atoms_out; // alts for "-+xX01234...
" 1340 __nums += 4; // now points to alternate digits 1341 for (int __i = __is_neg; __i < __s.size(); ++__i) 1342 __s[__i] = __nums[__s[__i] - '0']; 1347 // Write two digits, zero-filled. 1348 template<typename _FormatContext> 1349 typename _FormatContext::iterator 1350 _S_dd_zero_fill(int __val, typename _FormatContext::iterator __out, 1351 _FormatContext& __ctx, bool __alt_num) const 1353 auto __sv = _S_two_digits(__val); 1354 basic_string<_CharT> __s; 1356 __sv = _S_altnum(_M_locale(__ctx), __s.assign(__sv)); 1357 return __format::__write(std::move(__out), __sv); 1360 // Accessors for the components of chrono types: 1362 // Returns a hh_mm_ss. 1363 template<typename _Tp> 1364 static decltype(auto) 1365 _S_hms(const _Tp& __t) 1367 using ::std::chrono::__detail::__utc_leap_second; 1368 using ::std::chrono::__detail::__local_time_fmt; 1370 if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>) 1372 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1374 else if constexpr (chrono::__is_duration_v<_Tp>) 1375 return chrono::hh_mm_ss<_Tp>(__t); 1376 else if constexpr (chrono::__is_time_point_v<_Tp>) 1377 return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t)); 1378 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1379 return _S_hms(__t._M_time); 1382 __invalid_chrono_spec(); 1383 return chrono::hh_mm_ss<chrono::seconds>(); 1387 // Returns a sys_days or local_days. 1388 template<typename _Tp> 1390 _S_days(const _Tp& __t) 1392 using namespace chrono; 1393 using ::std::chrono::__detail::__utc_leap_second; 1394 using ::std::chrono::__detail::__local_time_fmt; 1396 if constexpr (__is_time_point_v<_Tp>) 1397 return chrono::floor<days>(__t); 1398 else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>) 1400 else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>) 1401 return chrono::floor<days>(__t._M_time); 1402 else if constexpr (is_same_v<_Tp, year_month_day> 1403 || is_same_v<_Tp, year_month_day_last> 1404 || is_same_v<_Tp, year_month_weekday> 1405 || is_same_v<_Tp, year_month_weekday_last>) 1406 return sys_days(__t); 1409 if constexpr (__is_duration_v<_Tp>) 1410 __not_valid_for_duration(); 1412 __invalid_chrono_spec(); 1413 return chrono::sys_days(); 1417 // Returns a year_month_day. 1418 template<typename _Tp> 1419 static chrono::year_month_day 1420 _S_date(const _Tp& __t) 1422 if constexpr (is_same_v<_Tp, chrono::year_month_day>) 1425 return chrono::year_month_day(_S_days(__t)); 1428 template<typename _Tp> 1430 _S_day(const _Tp& __t) 1432 using namespace chrono; 1434 if constexpr (is_same_v<_Tp, day>) 1436 else if constexpr (requires { __t.day(); }) 1439 return _S_date(__t).day(); 1442 template<typename _Tp> 1443 static chrono::month 1444 _S_month(const _Tp& __t) 1446 using namespace chrono; 1448 if constexpr (is_same_v<_Tp, month>) 1450 else if constexpr (requires { __t.month(); }) 1453 return _S_date(__t).month(); 1456 template<typename _Tp> 1458 _S_year(const _Tp& __t) 1460 using namespace chrono; 1462 if constexpr (is_same_v<_Tp, year>) 1464 else if constexpr (requires { __t.year(); }) 1467 return _S_date(__t).year(); 1470 template<typename _Tp> 1471 static chrono::weekday 1472 _S_weekday(const _Tp& __t) 1474 using namespace ::std::chrono; 1475 using ::std::chrono::__detail::__local_time_fmt; 1477 if constexpr (is_same_v<_Tp, weekday>) 1479 else if constexpr (requires { __t.weekday(); }) 1480 return __t.weekday(); 1481 else if constexpr (is_same_v<_Tp, month_weekday>) 1482 return __t.weekday_indexed().weekday(); 1483 else if constexpr (is_same_v<_Tp, month_weekday_last>) 1484 return __t.weekday_last().weekday(); 1486 return weekday(_S_days(__t)); 1490 } // namespace __format 1493 template<typename _Rep, typename _Period, typename _CharT>
1494 struct formatter<chrono::duration<_Rep, _Period>, _CharT>
1496 constexpr typename basic_format_parse_context<_CharT>::iterator
1497 parse(basic_format_parse_context<_CharT>& __pc)
1499 using namespace __format;
1500 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
1501 if constexpr (!is_floating_point_v<_Rep>)
1502 if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
1503 __throw_format_error("format error: invalid precision
for duration
"); 1507 template<typename _Out> 1508 typename basic_format_context<_Out, _CharT>::iterator 1509 format(const chrono::duration<_Rep, _Period>& __d, 1510 basic_format_context<_Out, _CharT>& __fc) const 1512 return _M_f._M_format(chrono::abs(__d), __fc, __d < __d.zero()); 1516 __format::__formatter_chrono<_CharT> _M_f; 1519 template<typename _CharT> 1520 struct formatter<chrono::day, _CharT> 1522 template<typename _ParseContext> 1523 constexpr typename _ParseContext::iterator 1524 parse(_ParseContext& __pc) 1525 { return _M_f._M_parse(__pc, __format::_Day); } 1527 template<typename _FormatContext> 1528 typename _FormatContext::iterator 1529 format(const chrono::day& __t, _FormatContext& __fc) const 1530 { return _M_f._M_format(__t, __fc); } 1533 __format::__formatter_chrono<_CharT> _M_f; 1536 template<typename _CharT> 1537 struct formatter<chrono::month, _CharT> 1539 template<typename _ParseContext> 1540 constexpr typename _ParseContext::iterator 1541 parse(_ParseContext& __pc) 1542 { return _M_f._M_parse(__pc, __format::_Month); } 1544 template<typename _FormatContext> 1545 typename _FormatContext::iterator 1546 format(const chrono::month& __t, _FormatContext& __fc) const 1547 { return _M_f._M_format(__t, __fc); } 1550 __format::__formatter_chrono<_CharT> _M_f; 1553 template<typename _CharT> 1554 struct formatter<chrono::year, _CharT> 1556 template<typename _ParseContext> 1557 constexpr typename _ParseContext::iterator 1558 parse(_ParseContext& __pc) 1559 { return _M_f._M_parse(__pc, __format::_Year); } 1561 template<typename _FormatContext> 1562 typename _FormatContext::iterator 1563 format(const chrono::year& __t, _FormatContext& __fc) const 1564 { return _M_f._M_format(__t, __fc); } 1567 __format::__formatter_chrono<_CharT> _M_f; 1570 template<typename _CharT> 1571 struct formatter<chrono::weekday, _CharT> 1573 template<typename _ParseContext> 1574 constexpr typename _ParseContext::iterator 1575 parse(_ParseContext& __pc) 1576 { return _M_f._M_parse(__pc, __format::_Weekday); } 1578 template<typename _FormatContext> 1579 typename _FormatContext::iterator 1580 format(const chrono::weekday& __t, _FormatContext& __fc) const 1581 { return _M_f._M_format(__t, __fc); } 1584 __format::__formatter_chrono<_CharT> _M_f; 1587 template<typename _CharT> 1588 struct formatter<chrono::weekday_indexed, _CharT> 1590 template<typename _ParseContext> 1591 constexpr typename _ParseContext::iterator 1592 parse(_ParseContext& __pc) 1593 { return _M_f._M_parse(__pc, __format::_Weekday); } 1595 template<typename _FormatContext> 1596 typename _FormatContext::iterator 1597 format(const chrono::weekday_indexed& __t, _FormatContext& __fc) const 1598 { return _M_f._M_format(__t, __fc); } 1601 __format::__formatter_chrono<_CharT> _M_f; 1604 template<typename _CharT> 1605 struct formatter<chrono::weekday_last, _CharT> 1607 template<typename _ParseContext> 1608 constexpr typename _ParseContext::iterator 1609 parse(_ParseContext& __pc) 1610 { return _M_f._M_parse(__pc, __format::_Weekday); } 1612 template<typename _FormatContext> 1613 typename _FormatContext::iterator 1614 format(const chrono::weekday_last& __t, _FormatContext& __fc) const 1615 { return _M_f._M_format(__t, __fc); } 1618 __format::__formatter_chrono<_CharT> _M_f; 1621 template<typename _CharT> 1622 struct formatter<chrono::month_day, _CharT> 1624 template<typename _ParseContext> 1625 constexpr typename _ParseContext::iterator 1626 parse(_ParseContext& __pc) 1627 { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); } 1629 template<typename _FormatContext> 1630 typename _FormatContext::iterator 1631 format(const chrono::month_day& __t, _FormatContext& __fc) const 1632 { return _M_f._M_format(__t, __fc); } 1635 __format::__formatter_chrono<_CharT> _M_f; 1638 template<typename _CharT> 1639 struct formatter<chrono::month_day_last, _CharT> 1641 template<typename _ParseContext> 1642 constexpr typename _ParseContext::iterator 1643 parse(_ParseContext& __pc) 1644 { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); } 1646 template<typename _FormatContext> 1647 typename _FormatContext::iterator 1648 format(const chrono::month_day_last& __t, _FormatContext& __fc) const 1649 { return _M_f._M_format(__t, __fc); } 1652 __format::__formatter_chrono<_CharT> _M_f; 1655 template<typename _CharT> 1656 struct formatter<chrono::month_weekday, _CharT> 1658 template<typename _ParseContext> 1659 constexpr typename _ParseContext::iterator 1660 parse(_ParseContext& __pc) 1661 { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); } 1663 template<typename _FormatContext> 1664 typename _FormatContext::iterator 1665 format(const chrono::month_weekday& __t, _FormatContext& __fc) const 1666 { return _M_f._M_format(__t, __fc); } 1669 __format::__formatter_chrono<_CharT> _M_f; 1672 template<typename _CharT> 1673 struct formatter<chrono::month_weekday_last, _CharT> 1675 template<typename _ParseContext> 1676 constexpr typename _ParseContext::iterator 1677 parse(_ParseContext& __pc) 1678 { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); } 1680 template<typename _FormatContext> 1681 typename _FormatContext::iterator 1682 format(const chrono::month_weekday_last& __t, 1683 _FormatContext& __fc) const 1684 { return _M_f._M_format(__t, __fc); } 1687 __format::__formatter_chrono<_CharT> _M_f; 1690 template<typename _CharT> 1691 struct formatter<chrono::year_month, _CharT> 1693 template<typename _ParseContext> 1694 constexpr typename _ParseContext::iterator 1695 parse(_ParseContext& __pc) 1696 { return _M_f._M_parse(__pc, __format::_Year|__format::_Month); } 1698 template<typename _FormatContext> 1699 typename _FormatContext::iterator 1700 format(const chrono::year_month& __t, _FormatContext& __fc) const 1701 { return _M_f._M_format(__t, __fc); } 1704 __format::__formatter_chrono<_CharT> _M_f; 1707 template<typename _CharT> 1708 struct formatter<chrono::year_month_day, _CharT> 1710 template<typename _ParseContext> 1711 constexpr typename _ParseContext::iterator 1712 parse(_ParseContext& __pc) 1713 { return _M_f._M_parse(__pc, __format::_Date); } 1715 template<typename _FormatContext> 1716 typename _FormatContext::iterator 1717 format(const chrono::year_month_day& __t, _FormatContext& __fc) const 1718 { return _M_f._M_format(__t, __fc); } 1721 __format::__formatter_chrono<_CharT> _M_f; 1724 template<typename _CharT> 1725 struct formatter<chrono::year_month_day_last, _CharT> 1727 template<typename _ParseContext> 1728 constexpr typename _ParseContext::iterator 1729 parse(_ParseContext& __pc) 1730 { return _M_f._M_parse(__pc, __format::_Date); } 1732 template<typename _FormatContext> 1733 typename _FormatContext::iterator 1734 format(const chrono::year_month_day_last& __t, 1735 _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::year_month_weekday, _CharT> 1745 template<typename _ParseContext> 1746 constexpr typename _ParseContext::iterator 1747 parse(_ParseContext& __pc) 1748 { return _M_f._M_parse(__pc, __format::_Date); } 1750 template<typename _FormatContext> 1751 typename _FormatContext::iterator 1752 format(const chrono::year_month_weekday& __t, 1753 _FormatContext& __fc) const 1754 { return _M_f._M_format(__t, __fc); } 1757 __format::__formatter_chrono<_CharT> _M_f; 1760 template<typename _CharT> 1761 struct formatter<chrono::year_month_weekday_last, _CharT> 1763 template<typename _ParseContext> 1764 constexpr typename _ParseContext::iterator 1765 parse(_ParseContext& __pc) 1766 { return _M_f._M_parse(__pc, __format::_Date); } 1768 template<typename _FormatContext> 1769 typename _FormatContext::iterator 1770 format(const chrono::year_month_weekday_last& __t, 1771 _FormatContext& __fc) const 1772 { return _M_f._M_format(__t, __fc); } 1775 __format::__formatter_chrono<_CharT> _M_f; 1778 template<typename _Rep, typename _Period, typename _CharT> 1779 struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT> 1781 template<typename _ParseContext> 1782 constexpr typename _ParseContext::iterator 1783 parse(_ParseContext& __pc) 1784 { return _M_f._M_parse(__pc, __format::_TimeOfDay); } 1786 template<typename _FormatContext> 1787 typename _FormatContext::iterator 1788 format(const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t, 1789 _FormatContext& __fc) const 1790 { return _M_f._M_format(__t, __fc); } 1793 __format::__formatter_chrono<_CharT> _M_f; 1796 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI 1797 template<typename _CharT> 1798 struct formatter<chrono::sys_info, _CharT> 1800 template<typename _ParseContext> 1801 constexpr typename _ParseContext::iterator 1802 parse(_ParseContext& __pc) 1803 { return _M_f._M_parse(__pc, __format::_ChronoParts{}); } 1805 template<typename _FormatContext> 1806 typename _FormatContext::iterator 1807 format(const chrono::sys_info& __i, _FormatContext& __fc) const 1808 { return _M_f._M_format(__i, __fc); } 1811 __format::__formatter_chrono<_CharT> _M_f; 1814 template<typename _CharT> 1815 struct formatter<chrono::local_info, _CharT> 1817 template<typename _ParseContext> 1818 constexpr typename _ParseContext::iterator 1819 parse(_ParseContext& __pc) 1820 { return _M_f._M_parse(__pc, __format::_ChronoParts{}); } 1822 template<typename _FormatContext> 1823 typename _FormatContext::iterator 1824 format(const chrono::local_info& __i, _FormatContext& __fc) const 1825 { return _M_f._M_format(__i, __fc); } 1828 __format::__formatter_chrono<_CharT> _M_f; 1832 template<typename _Duration, typename _CharT> 1833 struct formatter<chrono::sys_time<_Duration>, _CharT> 1835 template<typename _ParseContext> 1836 constexpr typename _ParseContext::iterator 1837 parse(_ParseContext& __pc) 1838 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1840 template<typename _FormatContext> 1841 typename _FormatContext::iterator 1842 format(const chrono::sys_time<_Duration>& __t, 1843 _FormatContext& __fc) const 1844 { return _M_f._M_format(__t, __fc); } 1847 __format::__formatter_chrono<_CharT> _M_f; 1850 template<typename _Duration, typename _CharT> 1851 struct formatter<chrono::utc_time<_Duration>, _CharT> 1852 : __format::__formatter_chrono<_CharT> 1854 template<typename _ParseContext> 1855 constexpr typename _ParseContext::iterator 1856 parse(_ParseContext& __pc) 1857 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1859 template<typename _FormatContext> 1860 typename _FormatContext::iterator 1861 format(const chrono::utc_time<_Duration>& __t, 1862 _FormatContext& __fc) const 1864 // Adjust by removing leap seconds to get equivalent sys_time. 1865 // We can't just use clock_cast because we want to know if the time 1866 // falls within a leap second insertion, and format seconds as "60
". 1867 using chrono::__detail::__utc_leap_second; 1868 using chrono::seconds; 1869 using chrono::sys_time; 1870 using _CDur = common_type_t<_Duration, seconds>; 1871 const auto __li = chrono::get_leap_second_info(__t); 1872 sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed}; 1873 if (!__li.is_leap_second) [[likely]] 1874 return _M_f._M_format(__s, __fc); 1876 return _M_f._M_format(__utc_leap_second(__s), __fc); 1880 friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>; 1882 __format::__formatter_chrono<_CharT> _M_f; 1885 template<typename _Duration, typename _CharT> 1886 struct formatter<chrono::tai_time<_Duration>, _CharT> 1887 : __format::__formatter_chrono<_CharT> 1889 template<typename _ParseContext> 1890 constexpr typename _ParseContext::iterator 1891 parse(_ParseContext& __pc) 1892 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1894 template<typename _FormatContext> 1895 typename _FormatContext::iterator 1896 format(const chrono::tai_time<_Duration>& __t, 1897 _FormatContext& __fc) const 1899 // Convert to __local_time_fmt with abbrev "TAI
" and offset 0s. 1901 // Offset is 1970y/January/1 - 1958y/January/1 1902 constexpr chrono::days __tai_offset = chrono::days(4383); 1903 using _CDur = common_type_t<_Duration, chrono::days>; 1904 chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset); 1905 const string __abbrev("TAI
", 3); 1906 const chrono::seconds __off = 0s; 1907 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off); 1908 return _M_f._M_format(__lf, __fc); 1912 __format::__formatter_chrono<_CharT> _M_f; 1915 template<typename _Duration, typename _CharT> 1916 struct formatter<chrono::gps_time<_Duration>, _CharT> 1917 : __format::__formatter_chrono<_CharT> 1919 template<typename _ParseContext> 1920 constexpr typename _ParseContext::iterator 1921 parse(_ParseContext& __pc) 1922 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1924 template<typename _FormatContext> 1925 typename _FormatContext::iterator 1926 format(const chrono::gps_time<_Duration>& __t, 1927 _FormatContext& __fc) const 1929 // Convert to __local_time_fmt with abbrev "GPS
" and offset 0s. 1931 // Offset is 1980y/January/Sunday[1] - 1970y/January/1 1932 constexpr chrono::days __gps_offset = chrono::days(3657); 1933 using _CDur = common_type_t<_Duration, chrono::days>; 1934 chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset); 1935 const string __abbrev("GPS
", 3); 1936 const chrono::seconds __off = 0s; 1937 const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off); 1938 return _M_f._M_format(__lf, __fc); 1942 __format::__formatter_chrono<_CharT> _M_f; 1945 template<typename _Duration, typename _CharT> 1946 struct formatter<chrono::file_time<_Duration>, _CharT> 1948 template<typename _ParseContext> 1949 constexpr typename _ParseContext::iterator 1950 parse(_ParseContext& __pc) 1951 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1953 template<typename _FormatContext> 1954 typename _FormatContext::iterator 1955 format(const chrono::file_time<_Duration>& __t, 1956 _FormatContext& __ctx) const 1958 using namespace chrono; 1959 return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __ctx); 1963 __format::__formatter_chrono<_CharT> _M_f; 1966 template<typename _Duration, typename _CharT> 1967 struct formatter<chrono::local_time<_Duration>, _CharT> 1969 template<typename _ParseContext> 1970 constexpr typename _ParseContext::iterator 1971 parse(_ParseContext& __pc) 1972 { return _M_f._M_parse(__pc, __format::_DateTime); } 1974 template<typename _FormatContext> 1975 typename _FormatContext::iterator 1976 format(const chrono::local_time<_Duration>& __t, 1977 _FormatContext& __ctx) const 1978 { return _M_f._M_format(__t, __ctx); } 1981 __format::__formatter_chrono<_CharT> _M_f; 1984 template<typename _Duration, typename _CharT> 1985 struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT> 1987 template<typename _ParseContext> 1988 constexpr typename _ParseContext::iterator 1989 parse(_ParseContext& __pc) 1990 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); } 1992 template<typename _FormatContext> 1993 typename _FormatContext::iterator 1994 format(const chrono::__detail::__local_time_fmt<_Duration>& __t, 1995 _FormatContext& __ctx) const 1996 { return _M_f._M_format(__t, __ctx); } 1999 __format::__formatter_chrono<_CharT> _M_f; 2002 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI 2003 template<typename _Duration, typename _TimeZonePtr, typename _CharT> 2004 struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT> 2005 : formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT> 2007 template<typename _FormatContext> 2008 typename _FormatContext::iterator 2009 format(const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp, 2010 _FormatContext& __ctx) const 2012 using chrono::__detail::__local_time_fmt; 2013 using _Base = formatter<__local_time_fmt<_Duration>, _CharT>; 2014 const chrono::sys_info __info = __tp.get_info(); 2015 const auto __lf = chrono::local_time_format(__tp.get_local_time(), 2018 return _Base::format(__lf, __ctx); 2023 // Partial specialization needed for %c formatting of __utc_leap_second. 2024 template<typename _Duration, typename _CharT> 2025 struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT> 2026 : formatter<chrono::utc_time<_Duration>, _CharT> 2028 template<typename _FormatContext> 2029 typename _FormatContext::iterator 2030 format(const chrono::__detail::__utc_leap_second<_Duration>& __t, 2031 _FormatContext& __fc) const 2032 { return this->_M_f._M_format(__t, __fc); } 2040 // TODO: from_stream for duration
2042 template<typename _CharT, typename _Traits, typename _Rep, typename _Period,
2043 typename _Alloc = allocator<_CharT>>
2044 basic_istream<_CharT, _Traits>&
2045 from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
2046 duration<_Rep, _Period>& __d,
2047 basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
2048 minutes* __offset = nullptr)
2053 template<typename _CharT, typename _Traits>
2054 inline basic_ostream<_CharT, _Traits>&
2055 operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d)
2057 using _Ctx = __conditional_t<is_same_v<_CharT, char>,
2058 format_context, wformat_context>;
2059 using _Str = basic_string_view<_CharT>;
2060 _Str __s = _GLIBCXX_WIDEN("{:02d} is not a valid day
"); 2062 __s = __s.substr(0, 6); 2063 __os << std::vformat(__s, make_format_args<_Ctx>((unsigned)__d)); 2067 // TODO from_stream for day 2069 template<typename _CharT, typename _Traits> 2070 inline basic_ostream<_CharT, _Traits>& 2071 operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m) 2073 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2074 format_context, wformat_context>; 2075 using _Str = basic_string_view<_CharT>; 2076 _Str __s = _GLIBCXX_WIDEN("{:L%b}{} is not a valid month
"); 2078 __os << std::vformat(__os.getloc(), __s.substr(0, 6), 2079 make_format_args<_Ctx>(__m)); 2081 __os << std::vformat(__s.substr(6), 2082 make_format_args<_Ctx>((unsigned)__m)); 2086 // TODO from_stream for month 2088 template<typename _CharT, typename _Traits> 2089 inline basic_ostream<_CharT, _Traits>& 2090 operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y) 2092 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2093 format_context, wformat_context>; 2094 using _Str = basic_string_view<_CharT>; 2095 _Str __s = _GLIBCXX_WIDEN("-{:04d} is not a valid year
"); 2097 __s = __s.substr(0, 7); 2099 if (__i >= 0) [[likely]] 2100 __s.remove_prefix(1); 2103 __os << std::vformat(__s, make_format_args<_Ctx>(__i)); 2107 // TODO from_stream for year 2109 template<typename _CharT, typename _Traits> 2110 inline basic_ostream<_CharT, _Traits>& 2111 operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd) 2113 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2114 format_context, wformat_context>; 2115 using _Str = basic_string_view<_CharT>; 2116 _Str __s = _GLIBCXX_WIDEN("{:L%a}{} is not a valid weekday
"); 2118 __os << std::vformat(__os.getloc(), __s.substr(0, 6), 2119 make_format_args<_Ctx>(__wd)); 2121 __os << std::vformat(__s.substr(6), 2122 make_format_args<_Ctx>(__wd.c_encoding())); 2126 // TODO from_stream for weekday 2128 template<typename _CharT, typename _Traits> 2129 inline basic_ostream<_CharT, _Traits>& 2130 operator<<(basic_ostream<_CharT, _Traits>& __os, 2131 const weekday_indexed& __wdi) 2133 // The standard says to format wdi.weekday() and wdi.index() using 2134 // either "{:L}[{}]
" or "{:L}[{} is not a valid index]
". The {:L} spec 2135 // means to format the weekday using ostringstream, so just do that. 2136 basic_stringstream<_CharT> __os2; 2137 __os2.imbue(__os.getloc()); 2138 __os2 << __wdi.weekday(); 2139 const auto __i = __wdi.index(); 2140 if constexpr (is_same_v<_CharT, char>) 2141 __os2 << std::format("[{}
", __i); 2143 __os2 << std::format(L"[{}
", __i); 2144 basic_string_view<_CharT> __s = _GLIBCXX_WIDEN(" is not a valid index]
"); 2145 if (__i >= 1 && __i <= 5) 2146 __os2 << __s.back(); 2149 __os << __os2.view(); 2153 template<typename _CharT, typename _Traits> 2154 inline basic_ostream<_CharT, _Traits>& 2155 operator<<(basic_ostream<_CharT, _Traits>& __os, 2156 const weekday_last& __wdl) 2158 // As above, just write straight to a stringstream, as if by "{:L}[last]
" 2159 basic_stringstream<_CharT> __os2; 2160 __os2.imbue(__os.getloc()); 2161 __os2 << __wdl.weekday() << _GLIBCXX_WIDEN("[last]
"); 2162 __os << __os2.view(); 2166 template<typename _CharT, typename _Traits> 2167 inline basic_ostream<_CharT, _Traits>& 2168 operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md) 2170 // As above, just write straight to a stringstream, as if by "{:L}/{}
" 2171 basic_stringstream<_CharT> __os2; 2172 __os2.imbue(__os.getloc()); 2173 __os2 << __md.month(); 2174 if constexpr (is_same_v<_CharT, char>) 2178 __os2 << __md.day(); 2179 __os << __os2.view(); 2183 // TODO from_stream for month_day 2185 template<typename _CharT, typename _Traits> 2186 inline basic_ostream<_CharT, _Traits>& 2187 operator<<(basic_ostream<_CharT, _Traits>& __os, 2188 const month_day_last& __mdl) 2190 // As above, just write straight to a stringstream, as if by "{:L}/last
" 2191 basic_stringstream<_CharT> __os2; 2192 __os2.imbue(__os.getloc()); 2193 __os2 << __mdl.month(); 2194 if constexpr (is_same_v<_CharT, char>) 2198 __os << __os2.view(); 2202 template<typename _CharT, typename _Traits> 2203 inline basic_ostream<_CharT, _Traits>& 2204 operator<<(basic_ostream<_CharT, _Traits>& __os, 2205 const month_weekday& __mwd) 2207 // As above, just write straight to a stringstream, as if by "{:L}/{:L}
" 2208 basic_stringstream<_CharT> __os2; 2209 __os2.imbue(__os.getloc()); 2210 __os2 << __mwd.month(); 2211 if constexpr (is_same_v<_CharT, char>) 2215 __os2 << __mwd.weekday_indexed(); 2216 __os << __os2.view(); 2220 template<typename _CharT, typename _Traits> 2221 inline basic_ostream<_CharT, _Traits>& 2222 operator<<(basic_ostream<_CharT, _Traits>& __os, 2223 const month_weekday_last& __mwdl) 2225 // As above, just write straight to a stringstream, as if by "{:L}/{:L}
" 2226 basic_stringstream<_CharT> __os2; 2227 __os2.imbue(__os.getloc()); 2228 __os2 << __mwdl.month(); 2229 if constexpr (is_same_v<_CharT, char>) 2233 __os2 << __mwdl.weekday_last(); 2234 __os << __os2.view(); 2238 template<typename _CharT, typename _Traits> 2239 inline basic_ostream<_CharT, _Traits>& 2240 operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym) 2242 // As above, just write straight to a stringstream, as if by "{}/{:L}
" 2243 basic_stringstream<_CharT> __os2; 2244 __os2.imbue(__os.getloc()); 2245 __os2 << __ym.year(); 2246 if constexpr (is_same_v<_CharT, char>) 2250 __os2 << __ym.month(); 2251 __os << __os2.view(); 2255 // TODO from_stream for year_month 2257 template<typename _CharT, typename _Traits> 2258 inline basic_ostream<_CharT, _Traits>& 2259 operator<<(basic_ostream<_CharT, _Traits>& __os, 2260 const year_month_day& __ymd) 2262 using _Ctx = __conditional_t<is_same_v<_CharT, char>, 2263 format_context, wformat_context>; 2264 using _Str = basic_string_view<_CharT>; 2265 _Str __s = _GLIBCXX_WIDEN("{:%F} is not a valid date
"); 2266 __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s, 2267 make_format_args<_Ctx>(__ymd)); 2271 // TODO from_stream for year_month_day 2273 template<typename _CharT, typename _Traits> 2274 inline basic_ostream<_CharT, _Traits>& 2275 operator<<(basic_ostream<_CharT, _Traits>& __os, 2276 const year_month_day_last& __ymdl) 2278 // As above, just write straight to a stringstream, as if by "{}/{:L}
" 2279 basic_stringstream<_CharT> __os2; 2280 __os2.imbue(__os.getloc()); 2281 __os2 << __ymdl.year(); 2282 if constexpr (is_same_v<_CharT, char>) 2286 __os2 << __ymdl.month_day_last(); 2287 __os << __os2.view(); 2291 template<typename _CharT, typename _Traits> 2292 inline basic_ostream<_CharT, _Traits>& 2293 operator<<(basic_ostream<_CharT, _Traits>& __os, 2294 const year_month_weekday& __ymwd) 2296 // As above, just write straight to a stringstream, as if by 2298 basic_stringstream<_CharT> __os2; 2299 __os2.imbue(__os.getloc()); 2301 if constexpr (is_same_v<_CharT, char>) 2305 __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash 2306 << __ymwd.weekday_indexed(); 2307 __os << __os2.view(); 2311 template<typename _CharT, typename _Traits> 2312 inline basic_ostream<_CharT, _Traits>& 2313 operator<<(basic_ostream<_CharT, _Traits>& __os, 2314 const year_month_weekday_last& __ymwdl) 2316 // As above, just write straight to a stringstream, as if by 2318 basic_stringstream<_CharT> __os2; 2319 __os2.imbue(__os.getloc()); 2321 if constexpr (is_same_v<_CharT, char>) 2325 __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash 2326 << __ymwdl.weekday_last(); 2327 __os << __os2.view(); 2331 template<typename _CharT, typename _Traits, typename _Duration> 2332 inline basic_ostream<_CharT, _Traits>& 2333 operator<<(basic_ostream<_CharT, _Traits>& __os, 2334 const hh_mm_ss<_Duration>& __hms) 2336 return __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%T}
"), __hms); 2339 #if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI 2341 template<typename _CharT, typename _Traits>
2342 basic_ostream<_CharT, _Traits>&
2343 operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __i)
2345 __os << '[' << __i.begin << ',' << __i.end
2346 << ',' << hh_mm_ss(__i.offset) << ',' << __i.save
2347 << ',' << __i.abbrev << ']';
2352 template<typename _CharT, typename _Traits>
2353 basic_ostream<_CharT, _Traits>&
2354 operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __li)
2357 if (__li.result == local_info::unique)
2361 if (__li.result == local_info::nonexistent)
2362 __os << "nonexistent
"; 2364 __os << "ambiguous
"; 2365 __os << " local time between
" << __li.first; 2366 __os << " and
" << __li.second; 2372 template<typename _CharT, typename _Traits, typename _Duration, 2373 typename _TimeZonePtr> 2374 inline basic_ostream<_CharT, _Traits>& 2375 operator<<(basic_ostream<_CharT, _Traits>& __os, 2376 const zoned_time<_Duration, _TimeZonePtr>& __t) 2378 __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T %Z}
"), __t); 2383 template<typename _CharT, typename _Traits, typename _Duration> 2384 requires (!treat_as_floating_point_v<typename _Duration::rep>) 2385 && ratio_less_v<typename _Duration::period, days::period> 2386 inline basic_ostream<_CharT, _Traits>& 2387 operator<<(basic_ostream<_CharT, _Traits>& __os, 2388 const sys_time<_Duration>& __tp) 2390 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __tp); 2394 template<typename _CharT, typename _Traits> 2395 inline basic_ostream<_CharT, _Traits>& 2396 operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp) 2398 __os << year_month_day{__dp}; 2402 // TODO: from_stream for sys_time 2404 template<typename _CharT, typename _Traits, typename _Duration> 2405 inline basic_ostream<_CharT, _Traits>& 2406 operator<<(basic_ostream<_CharT, _Traits>& __os, 2407 const utc_time<_Duration>& __t) 2409 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2413 // TODO: from_stream for utc_time 2415 template<typename _CharT, typename _Traits, typename _Duration> 2416 inline basic_ostream<_CharT, _Traits>& 2417 operator<<(basic_ostream<_CharT, _Traits>& __os, 2418 const tai_time<_Duration>& __t) 2420 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2424 // TODO: from_stream for tai_time 2426 template<typename _CharT, typename _Traits, typename _Duration> 2427 inline basic_ostream<_CharT, _Traits>& 2428 operator<<(basic_ostream<_CharT, _Traits>& __os, 2429 const gps_time<_Duration>& __t) 2431 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2435 // TODO: from_stream for gps_time 2438 template<typename _CharT, typename _Traits, typename _Duration> 2439 inline basic_ostream<_CharT, _Traits>& 2440 operator<<(basic_ostream<_CharT, _Traits>& __os, 2441 const file_time<_Duration>& __t) 2443 __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}
"), __t); 2447 // TODO: from_stream for file_time 2449 template<typename _CharT, typename _Traits, typename _Duration> 2450 inline basic_ostream<_CharT, _Traits>& 2451 operator<<(basic_ostream<_CharT, _Traits>& __os, 2452 const local_time<_Duration>& __lt) 2454 __os << sys_time<_Duration>{__lt.time_since_epoch()}; 2458 // TODO: from_stream for local_time 2459 #undef _GLIBCXX_WIDEN 2462 } // namespace chrono
2464 _GLIBCXX_END_NAMESPACE_VERSION
2469 #endif //_GLIBCXX_CHRONO_IO_H
static const locale & classic()
Return reference to the C locale.
duration< int64_t > seconds
seconds
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)
duration< int64_t, ratio< 60 > > minutes
minutes
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
duration< int64_t, ratio< 3600 > > hours
hours
Implementation details not part of the namespace std interface.