105fef5dca
Some of the calendar types have landed before, this adds the missing set. Note this does not complete the implementation of the chrono formatters. This removes the `chrono` header for some transitive include in C++17 mode. This is needed to avoid inclusion cycles. Partially implements: - P1361 Integration of chrono with text formatting - P2372 Fixing locale handling in chrono formatters Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D137022
717 lines
28 KiB
C++
717 lines
28 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP___CHRONO_FORMATTER_H
|
|
#define _LIBCPP___CHRONO_FORMATTER_H
|
|
|
|
#include <__chrono/calendar.h>
|
|
#include <__chrono/convert_to_tm.h>
|
|
#include <__chrono/day.h>
|
|
#include <__chrono/duration.h>
|
|
#include <__chrono/hh_mm_ss.h>
|
|
#include <__chrono/month.h>
|
|
#include <__chrono/month_weekday.h>
|
|
#include <__chrono/monthday.h>
|
|
#include <__chrono/ostream.h>
|
|
#include <__chrono/parser_std_format_spec.h>
|
|
#include <__chrono/statically_widen.h>
|
|
#include <__chrono/time_point.h>
|
|
#include <__chrono/weekday.h>
|
|
#include <__chrono/year.h>
|
|
#include <__chrono/year_month.h>
|
|
#include <__chrono/year_month_day.h>
|
|
#include <__chrono/year_month_weekday.h>
|
|
#include <__concepts/arithmetic.h>
|
|
#include <__concepts/same_as.h>
|
|
#include <__config>
|
|
#include <__format/concepts.h>
|
|
#include <__format/format_error.h>
|
|
#include <__format/format_functions.h>
|
|
#include <__format/format_parse_context.h>
|
|
#include <__format/formatter.h>
|
|
#include <__format/formatter_output.h>
|
|
#include <__format/parser_std_format_spec.h>
|
|
#include <__memory/addressof.h>
|
|
#include <cmath>
|
|
#include <ctime>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
# pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
|
|
|
|
namespace __formatter {
|
|
|
|
/// Formats a time based on a tm struct.
|
|
///
|
|
/// This formatter passes the formatting to time_put which uses strftime. When
|
|
/// the value is outside the valid range it's unspecified what strftime will
|
|
/// output. For example weekday 8 can print 1 when the day is processed modulo
|
|
/// 7 since that handles the Sunday for 0-based weekday. It can also print 8 if
|
|
/// 7 is handled as a special case.
|
|
///
|
|
/// The Standard doesn't specify what to do in this case so the result depends
|
|
/// on the result of the underlying code.
|
|
///
|
|
/// \pre When the (abbreviated) weekday or month name are used, the caller
|
|
/// validates whether the value is valid. So the caller handles that
|
|
/// requirement of Table 97: Meaning of conversion specifiers
|
|
/// [tab:time.format.spec].
|
|
///
|
|
/// When no chrono-specs are provided it uses the stream formatter.
|
|
|
|
// For tiny ratios it's not possible to convert a duration to a hh_mm_ss. This
|
|
// fails compile-time due to the limited precision of the ratio (64-bit is too
|
|
// small). Therefore a duration uses its own conversion.
|
|
template <class _CharT, class _Tp>
|
|
requires(chrono::__is_duration<_Tp>::value)
|
|
_LIBCPP_HIDE_FROM_ABI void __format_sub_seconds(const _Tp& __value, basic_stringstream<_CharT>& __sstr) {
|
|
__sstr << std::use_facet<numpunct<_CharT>>(__sstr.getloc()).decimal_point();
|
|
|
|
auto __fraction = __value - chrono::duration_cast<chrono::seconds>(__value);
|
|
if constexpr (chrono::treat_as_floating_point_v<typename _Tp::rep>)
|
|
// When the floating-point value has digits itself they are ignored based
|
|
// on the wording in [tab:time.format.spec]
|
|
// If the precision of the input cannot be exactly represented with
|
|
// seconds, then the format is a decimal floating-point number with a
|
|
// fixed format and a precision matching that of the precision of the
|
|
// input (or to a microseconds precision if the conversion to
|
|
// floating-point decimal seconds cannot be made within 18 fractional
|
|
// digits).
|
|
//
|
|
// This matches the behaviour of MSVC STL, fmtlib interprets this
|
|
// differently and uses 3 decimals.
|
|
// https://godbolt.org/z/6dsbnW8ba
|
|
std::format_to(std::ostreambuf_iterator<_CharT>{__sstr},
|
|
_LIBCPP_STATICALLY_WIDEN(_CharT, "{:0{}.0f}"),
|
|
__fraction.count(),
|
|
chrono::hh_mm_ss<_Tp>::fractional_width);
|
|
else
|
|
std::format_to(std::ostreambuf_iterator<_CharT>{__sstr},
|
|
_LIBCPP_STATICALLY_WIDEN(_CharT, "{:0{}}"),
|
|
__fraction.count(),
|
|
chrono::hh_mm_ss<_Tp>::fractional_width);
|
|
}
|
|
|
|
template <class _Tp>
|
|
consteval bool __use_fraction() {
|
|
if constexpr (chrono::__is_duration<_Tp>::value)
|
|
return chrono::hh_mm_ss<_Tp>::fractional_width;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
template <class _CharT>
|
|
_LIBCPP_HIDE_FROM_ABI void __format_year(int __year, basic_stringstream<_CharT>& __sstr) {
|
|
if (__year < 0) {
|
|
__sstr << _CharT('-');
|
|
__year = -__year;
|
|
}
|
|
|
|
// TODO FMT Write an issue
|
|
// If the result has less than four digits it is zero-padded with 0 to two digits.
|
|
// is less -> has less
|
|
// left-padded -> zero-padded, otherwise the proper value would be 000-0.
|
|
|
|
// Note according to the wording it should be left padded, which is odd.
|
|
__sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:04}"), __year);
|
|
}
|
|
|
|
template <class _CharT>
|
|
_LIBCPP_HIDE_FROM_ABI void __format_century(int __year, basic_stringstream<_CharT>& __sstr) {
|
|
// TODO FMT Write an issue
|
|
// [tab:time.format.spec]
|
|
// %C The year divided by 100 using floored division. If the result is a
|
|
// single decimal digit, it is prefixed with 0.
|
|
|
|
bool __negative = __year < 0;
|
|
int __century = (__year - (99 * __negative)) / 100; // floored division
|
|
__sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:02}"), __century);
|
|
}
|
|
|
|
template <class _CharT, class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
|
|
const _Tp& __value, basic_stringstream<_CharT>& __sstr, basic_string_view<_CharT> __chrono_specs) {
|
|
tm __t = std::__convert_to_tm<tm>(__value);
|
|
const auto& __facet = std::use_facet<time_put<_CharT>>(__sstr.getloc());
|
|
for (auto __it = __chrono_specs.begin(); __it != __chrono_specs.end(); ++__it) {
|
|
if (*__it == _CharT('%')) {
|
|
auto __s = __it;
|
|
++__it;
|
|
// We only handle the types that can't be directly handled by time_put.
|
|
// (as an optimization n, t, and % are also handled directly.)
|
|
switch (*__it) {
|
|
case _CharT('n'):
|
|
__sstr << _CharT('\n');
|
|
break;
|
|
case _CharT('t'):
|
|
__sstr << _CharT('\t');
|
|
break;
|
|
case _CharT('%'):
|
|
__sstr << *__it;
|
|
break;
|
|
|
|
case _CharT('C'): {
|
|
// strftime's output is only defined in the range [00, 99].
|
|
int __year = __t.tm_year + 1900;
|
|
if (__year < 1000 || __year > 9999)
|
|
__formatter::__format_century(__year, __sstr);
|
|
else
|
|
__facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
|
|
} break;
|
|
|
|
case _CharT('j'):
|
|
if constexpr (chrono::__is_duration<_Tp>::value)
|
|
// Converting a duration where the period has a small ratio to days
|
|
// may fail to compile. This due to loss of precision in the
|
|
// conversion. In order to avoid that issue convert to seconds as
|
|
// an intemediate step.
|
|
__sstr << chrono::duration_cast<chrono::days>(chrono::duration_cast<chrono::seconds>(__value)).count();
|
|
else
|
|
__facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
|
|
break;
|
|
|
|
case _CharT('q'):
|
|
if constexpr (chrono::__is_duration<_Tp>::value) {
|
|
__sstr << chrono::__units_suffix<_CharT, typename _Tp::period>();
|
|
break;
|
|
}
|
|
__builtin_unreachable();
|
|
|
|
case _CharT('Q'):
|
|
// TODO FMT Determine the proper ideas
|
|
// - Should it honour the precision?
|
|
// - Shoult it honour the locale setting for the separators?
|
|
// The wording for Q doesn't use the word locale and the effect of
|
|
// precision is unspecified.
|
|
//
|
|
// MSVC STL ignores precision but uses separator
|
|
// FMT honours precision and has a bug for separator
|
|
// https://godbolt.org/z/78b7sMxns
|
|
if constexpr (chrono::__is_duration<_Tp>::value) {
|
|
__sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{}"), __value.count());
|
|
break;
|
|
}
|
|
__builtin_unreachable();
|
|
|
|
case _CharT('S'):
|
|
case _CharT('T'):
|
|
__facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
|
|
if constexpr (__use_fraction<_Tp>())
|
|
__formatter::__format_sub_seconds(__value, __sstr);
|
|
break;
|
|
|
|
// Unlike time_put and strftime the formatting library requires %Y
|
|
//
|
|
// [tab:time.format.spec]
|
|
// The year as a decimal number. If the result is less than four digits
|
|
// it is left-padded with 0 to four digits.
|
|
//
|
|
// This means years in the range (-1000, 1000) need manual formatting.
|
|
// It's unclear whether %EY needs the same treatment. For example the
|
|
// Japanese EY contains the era name and year. This is zero-padded to 2
|
|
// digits in time_put (note that older glibc versions didn't do
|
|
// padding.) However most eras won't reach 100 years, let alone 1000.
|
|
// So padding to 4 digits seems unwanted for Japanese.
|
|
//
|
|
// The same applies to %Ex since that too depends on the era.
|
|
//
|
|
// %x the locale's date representation is currently doesn't handle the
|
|
// zero-padding too.
|
|
//
|
|
// The 4 digits can be implemented better at a later time. On POSIX
|
|
// systems the required information can be extracted by nl_langinfo
|
|
// https://man7.org/linux/man-pages/man3/nl_langinfo.3.html
|
|
//
|
|
// Note since year < -1000 is expected to be rare it uses the more
|
|
// expensive year routine.
|
|
//
|
|
// TODO FMT evaluate the comment above.
|
|
|
|
# if defined(__GLIBC__) || defined(_AIX)
|
|
case _CharT('y'):
|
|
// Glibc fails for negative values, AIX for positive values too.
|
|
__sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:02}"), (std::abs(__t.tm_year + 1900)) % 100);
|
|
break;
|
|
# endif // defined(__GLIBC__) || defined(_AIX)
|
|
|
|
case _CharT('Y'): {
|
|
int __year = __t.tm_year + 1900;
|
|
if (__year < 1000)
|
|
__formatter::__format_year(__year, __sstr);
|
|
else
|
|
__facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
|
|
} break;
|
|
|
|
case _CharT('F'): {
|
|
int __year = __t.tm_year + 1900;
|
|
if (__year < 1000) {
|
|
__formatter::__format_year(__year, __sstr);
|
|
__sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "-{:02}-{:02}"), __t.tm_mon + 1, __t.tm_mday);
|
|
} else
|
|
__facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
|
|
} break;
|
|
|
|
case _CharT('O'):
|
|
if constexpr (__use_fraction<_Tp>()) {
|
|
// Handle OS using the normal representation for the non-fractional
|
|
// part. There seems to be no locale information regarding how the
|
|
// fractional part should be formatted.
|
|
if (*(__it + 1) == 'S') {
|
|
++__it;
|
|
__facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
|
|
__formatter::__format_sub_seconds(__value, __sstr);
|
|
break;
|
|
}
|
|
}
|
|
[[fallthrough]];
|
|
case _CharT('E'):
|
|
++__it;
|
|
[[fallthrough]];
|
|
default:
|
|
__facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
|
|
break;
|
|
}
|
|
} else {
|
|
__sstr << *__it;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI constexpr bool __weekday_ok(const _Tp& __value) {
|
|
if constexpr (same_as<_Tp, chrono::day>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_day>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_day_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::year_month>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
|
|
return __value.weekday().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
|
|
return __value.weekday().ok();
|
|
else
|
|
static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
|
|
}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI constexpr bool __weekday_name_ok(const _Tp& __value) {
|
|
if constexpr (same_as<_Tp, chrono::day>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
|
|
return __value.weekday().ok();
|
|
else if constexpr (same_as<_Tp, chrono::weekday_last>)
|
|
return __value.weekday().ok();
|
|
else if constexpr (same_as<_Tp, chrono::month_day>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_day_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday>)
|
|
return __value.weekday_indexed().ok();
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
|
|
return __value.weekday_indexed().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
|
|
return __value.weekday().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
|
|
return __value.weekday().ok();
|
|
else
|
|
static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
|
|
}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI constexpr bool __date_ok(const _Tp& __value) {
|
|
if constexpr (same_as<_Tp, chrono::day>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_day>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_day_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::year_month>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
|
|
return __value.ok();
|
|
else
|
|
static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
|
|
}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI constexpr bool __month_name_ok(const _Tp& __value) {
|
|
if constexpr (same_as<_Tp, chrono::day>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month>)
|
|
return __value.ok();
|
|
else if constexpr (same_as<_Tp, chrono::year>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday_indexed>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::weekday_last>)
|
|
return true;
|
|
else if constexpr (same_as<_Tp, chrono::month_day>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::month_day_last>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::month_weekday_last>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_day_last>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday>)
|
|
return __value.month().ok();
|
|
else if constexpr (same_as<_Tp, chrono::year_month_weekday_last>)
|
|
return __value.month().ok();
|
|
else
|
|
static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
|
|
}
|
|
|
|
template <class _CharT, class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI auto
|
|
__format_chrono(const _Tp& __value,
|
|
auto& __ctx,
|
|
__format_spec::__parsed_specifications<_CharT> __specs,
|
|
basic_string_view<_CharT> __chrono_specs) -> decltype(__ctx.out()) {
|
|
basic_stringstream<_CharT> __sstr;
|
|
// [time.format]/2
|
|
// 2.1 - the "C" locale if the L option is not present in chrono-format-spec, otherwise
|
|
// 2.2 - the locale passed to the formatting function if any, otherwise
|
|
// 2.3 - the global locale.
|
|
// Note that the __ctx's locale() call does 2.2 and 2.3.
|
|
if (__specs.__chrono_.__locale_specific_form_)
|
|
__sstr.imbue(__ctx.locale());
|
|
else
|
|
__sstr.imbue(locale::classic());
|
|
|
|
if (__chrono_specs.empty())
|
|
__sstr << __value;
|
|
else {
|
|
if constexpr (chrono::__is_duration<_Tp>::value) {
|
|
if (__value < __value.zero())
|
|
__sstr << _CharT('-');
|
|
__formatter::__format_chrono_using_chrono_specs(chrono::abs(__value), __sstr, __chrono_specs);
|
|
// TODO FMT When keeping the precision it will truncate the string.
|
|
// Note that the behaviour what the precision does isn't specified.
|
|
__specs.__precision_ = -1;
|
|
} else {
|
|
// Test __weekday_name_ before __weekday_ to give a better error.
|
|
if (__specs.__chrono_.__weekday_name_ && !__formatter::__weekday_name_ok(__value))
|
|
std::__throw_format_error("formatting a weekday name needs a valid weekday");
|
|
|
|
if (__specs.__chrono_.__weekday_ && !__formatter::__weekday_ok(__value))
|
|
std::__throw_format_error("formatting a weekday needs a valid weekday");
|
|
|
|
if (__specs.__chrono_.__day_of_year_ && !__formatter::__date_ok(__value))
|
|
std::__throw_format_error("formatting a day of year needs a valid date");
|
|
|
|
if (__specs.__chrono_.__week_of_year_ && !__formatter::__date_ok(__value))
|
|
std::__throw_format_error("formatting a week of year needs a valid date");
|
|
|
|
if (__specs.__chrono_.__month_name_ && !__formatter::__month_name_ok(__value))
|
|
std::__throw_format_error("formatting a month name from an invalid month number");
|
|
|
|
__formatter::__format_chrono_using_chrono_specs(__value, __sstr, __chrono_specs);
|
|
}
|
|
}
|
|
|
|
// TODO FMT Use the stringstream's view after P0408R7 has been implemented.
|
|
basic_string<_CharT> __str = __sstr.str();
|
|
return __formatter::__write_string(basic_string_view<_CharT>{__str}, __ctx.out(), __specs);
|
|
}
|
|
|
|
} // namespace __formatter
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_chrono {
|
|
public:
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto __parse(
|
|
basic_format_parse_context<_CharT>& __parse_ctx, __format_spec::__fields __fields, __format_spec::__flags __flags)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return __parser_.__parse(__parse_ctx, __fields, __flags);
|
|
}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI auto format(const _Tp& __value, auto& __ctx) const -> decltype(__ctx.out()) const {
|
|
return __formatter::__format_chrono(
|
|
__value, __ctx, __parser_.__parser_.__get_parsed_chrono_specifications(__ctx), __parser_.__chrono_specs_);
|
|
}
|
|
|
|
__format_spec::__parser_chrono<_CharT> __parser_;
|
|
};
|
|
|
|
template <class _Rep, class _Period, __fmt_char_type _CharT>
|
|
struct formatter<chrono::duration<_Rep, _Period>, _CharT> : public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
// [time.format]/1
|
|
// Giving a precision specification in the chrono-format-spec is valid only
|
|
// for std::chrono::duration types where the representation type Rep is a
|
|
// floating-point type. For all other Rep types, an exception of type
|
|
// format_error is thrown if the chrono-format-spec contains a precision
|
|
// specification.
|
|
//
|
|
// Note this doesn't refer to chrono::treat_as_floating_point_v<_Rep>.
|
|
if constexpr (std::floating_point<_Rep>)
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono_fractional, __format_spec::__flags::__duration);
|
|
else
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__duration);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::day, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__day);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::weekday, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::weekday_indexed, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::weekday_last, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__weekday);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_day, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_day);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_day_last, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_weekday, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::month_weekday_last, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__month_weekday);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__year_month);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_day, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_day_last, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_weekday, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
|
|
}
|
|
};
|
|
|
|
template <__fmt_char_type _CharT>
|
|
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::year_month_weekday_last, _CharT>
|
|
: public __formatter_chrono<_CharT> {
|
|
public:
|
|
using _Base = __formatter_chrono<_CharT>;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
|
|
-> decltype(__parse_ctx.begin()) {
|
|
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__date);
|
|
}
|
|
};
|
|
|
|
#endif // if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // _LIBCPP___CHRONO_FORMATTER_H
|