Reuse precision modifier in seconds specification
This commit is contained in:
Stepan Ponomarev
parent
8c19bf3f2f
commit
85a4cefd86
@ -1056,6 +1056,43 @@ void write_fractional_seconds(OutputIt& out, Duration d) {
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Char, typename OutputIt, typename Duration>
|
||||
void write_fractional_seconds(OutputIt& out, Duration d, int precision) {
|
||||
constexpr auto num_fractional_digits =
|
||||
count_fractional_digits<Duration::period::num,
|
||||
Duration::period::den>::value;
|
||||
|
||||
using subsecond_precision = std::chrono::duration<
|
||||
typename std::common_type<typename Duration::rep,
|
||||
std::chrono::seconds::rep>::type,
|
||||
std::ratio<1, detail::pow10(num_fractional_digits)>>;
|
||||
if (precision > 0) {
|
||||
*out++ = '.';
|
||||
auto fractional =
|
||||
detail::abs(d) - std::chrono::duration_cast<std::chrono::seconds>(d);
|
||||
auto subseconds =
|
||||
std::chrono::treat_as_floating_point<
|
||||
typename subsecond_precision::rep>::value
|
||||
? fractional.count()
|
||||
: std::chrono::duration_cast<subsecond_precision>(fractional)
|
||||
.count();
|
||||
uint32_or_64_or_128_t<long long> n =
|
||||
to_unsigned(to_nonnegative_int(subseconds, max_value<long long>()));
|
||||
int num_digits = detail::count_digits(n);
|
||||
int zeroes = std::min(num_fractional_digits - num_digits, precision);
|
||||
if (num_fractional_digits > num_digits) out = std::fill_n(out, zeroes, '0');
|
||||
int remaining = precision - (zeroes > 0 ? zeroes : 0);
|
||||
if (remaining < num_digits) {
|
||||
n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining)));
|
||||
out = format_decimal<Char>(out, n, remaining).end;
|
||||
return;
|
||||
}
|
||||
out = format_decimal<Char>(out, n, num_digits).end;
|
||||
remaining -= num_digits;
|
||||
out = std::fill_n(out, remaining, '0');
|
||||
}
|
||||
}
|
||||
|
||||
// Format subseconds which are given as a floating point type with an appropiate
|
||||
// number of digits. We cannot pass the Duration here, as we explicitly need to
|
||||
// pass the Rep value in the chrono_formatter.
|
||||
@ -1081,6 +1118,25 @@ void write_floating_seconds(memory_buffer& buf, Duration duration) {
|
||||
num_fractional_digits);
|
||||
}
|
||||
|
||||
template <typename Duration>
|
||||
void write_floating_seconds(memory_buffer& buf, Duration duration, int precision) {
|
||||
if (precision < 0) {
|
||||
write_floating_seconds(buf, duration);
|
||||
return;
|
||||
}
|
||||
|
||||
FMT_ASSERT(std::is_floating_point<typename Duration::rep>::value, "");
|
||||
auto val = duration.count();
|
||||
|
||||
format_to(
|
||||
std::back_inserter(buf), runtime("{:.{}f}"),
|
||||
std::fmod(val *
|
||||
static_cast<typename Duration::rep>(Duration::period::num) /
|
||||
static_cast<typename Duration::rep>(Duration::period::den),
|
||||
static_cast<typename Duration::rep>(60)),
|
||||
precision);
|
||||
}
|
||||
|
||||
template <typename OutputIt, typename Char,
|
||||
typename Duration = std::chrono::seconds>
|
||||
class tm_writer {
|
||||
@ -1518,6 +1574,9 @@ class tm_writer {
|
||||
};
|
||||
|
||||
struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
|
||||
bool is_floating_point = false;
|
||||
bool has_precision = false;
|
||||
|
||||
FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); }
|
||||
|
||||
template <typename Char>
|
||||
@ -1530,7 +1589,11 @@ struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
|
||||
FMT_CONSTEXPR void on_24_hour_time() {}
|
||||
FMT_CONSTEXPR void on_iso_time() {}
|
||||
FMT_CONSTEXPR void on_am_pm() {}
|
||||
FMT_CONSTEXPR void on_duration_value() {}
|
||||
FMT_CONSTEXPR void on_duration_value() const {
|
||||
if (has_precision && !is_floating_point) {
|
||||
FMT_THROW(format_error("precision not allowed for this argument type"));
|
||||
}
|
||||
}
|
||||
FMT_CONSTEXPR void on_duration_unit() {}
|
||||
};
|
||||
|
||||
@ -1831,14 +1894,17 @@ struct chrono_formatter {
|
||||
if (ns == numeric_system::standard) {
|
||||
if (std::is_floating_point<rep>::value) {
|
||||
auto buf = memory_buffer();
|
||||
write_floating_seconds(buf, std::chrono::duration<rep, Period>(val));
|
||||
write_floating_seconds(buf, std::chrono::duration<rep, Period>(val), precision);
|
||||
if (negative) *out++ = '-';
|
||||
if (buf.size() < 2 || buf[1] == '.') *out++ = '0';
|
||||
out = std::copy(buf.begin(), buf.end(), out);
|
||||
} else {
|
||||
write(second(), 2);
|
||||
write_fractional_seconds<char_type>(
|
||||
out, std::chrono::duration<rep, Period>(val));
|
||||
if (precision >= 0) {
|
||||
write_fractional_seconds<char_type>(out, std::chrono::duration<rep, Period>(val), precision);
|
||||
} else {
|
||||
write_fractional_seconds<char_type>(out, std::chrono::duration<rep, Period>(val));
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
@ -1999,18 +2065,17 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
|
||||
if (begin == end) return {begin, begin};
|
||||
begin = detail::parse_width(begin, end, handler);
|
||||
if (begin == end) return {begin, begin};
|
||||
auto checker = detail::chrono_format_checker();
|
||||
checker.is_floating_point = std::is_floating_point<Rep>::value;
|
||||
if (*begin == '.') {
|
||||
if (std::is_floating_point<Rep>::value)
|
||||
begin = detail::parse_precision(begin, end, handler);
|
||||
else
|
||||
handler.on_error("precision not allowed for this argument type");
|
||||
checker.has_precision = true;
|
||||
begin = detail::parse_precision(begin, end, handler);
|
||||
}
|
||||
if (begin != end && *begin == 'L') {
|
||||
++begin;
|
||||
localized = true;
|
||||
}
|
||||
end = detail::parse_chrono_format(begin, end,
|
||||
detail::chrono_format_checker());
|
||||
end = detail::parse_chrono_format(begin, end, checker);
|
||||
return {begin, end};
|
||||
}
|
||||
|
||||
|
||||
@ -466,7 +466,7 @@ TEST(chrono_test, format_default_fp) {
|
||||
|
||||
TEST(chrono_test, format_precision) {
|
||||
EXPECT_THROW_MSG(
|
||||
(void)fmt::format(runtime("{:.2}"), std::chrono::seconds(42)),
|
||||
(void)fmt::format(runtime("{:.2%Q}"), std::chrono::seconds(42)),
|
||||
fmt::format_error, "precision not allowed for this argument type");
|
||||
EXPECT_EQ("1ms", fmt::format("{:.0}", dms(1.234)));
|
||||
EXPECT_EQ("1.2ms", fmt::format("{:.1}", dms(1.234)));
|
||||
@ -611,12 +611,23 @@ TEST(chrono_test, cpp20_duration_subsecond_support) {
|
||||
EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{-13420148734}),
|
||||
"-13.420148734");
|
||||
EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds{1234}), "01.234");
|
||||
// Check subsecond presision modifier.
|
||||
EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::nanoseconds{1234}), "00.000001");
|
||||
EXPECT_EQ(fmt::format("{:.18%S}", std::chrono::nanoseconds{1234}), "00.000001234000000000");
|
||||
EXPECT_EQ(fmt::format("{:.{}%S}", std::chrono::nanoseconds{1234}, 6), "00.000001");
|
||||
EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{1234}), "01.234000");
|
||||
EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{-1234}), "-01.234000");
|
||||
EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::seconds{1234}), "34.000");
|
||||
EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::hours{1234}), "00.000");
|
||||
EXPECT_EQ(fmt::format("{:.5%S}", dms(1.234)), "00.00123");
|
||||
EXPECT_EQ(fmt::format("{:.8%S}", dms(1.234)), "00.00123400");
|
||||
{
|
||||
// Check that {:%H:%M:%S} is equivalent to {:%T}.
|
||||
auto dur = std::chrono::milliseconds{3601234};
|
||||
auto formatted_dur = fmt::format("{:%T}", dur);
|
||||
EXPECT_EQ(formatted_dur, "01:00:01.234");
|
||||
EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur);
|
||||
EXPECT_EQ(fmt::format("{:.6%H:%M:%S}", dur), "01:00:01.234000");
|
||||
}
|
||||
using nanoseconds_dbl = std::chrono::duration<double, std::nano>;
|
||||
EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{-123456789}), "-00.123456789");
|
||||
@ -630,6 +641,7 @@ TEST(chrono_test, cpp20_duration_subsecond_support) {
|
||||
auto formatted_dur = fmt::format("{:%T}", dur);
|
||||
EXPECT_EQ(formatted_dur, "-00:01:39.123456789");
|
||||
EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur);
|
||||
EXPECT_EQ(fmt::format("{:.3%H:%M:%S}", dur), "-00:01:39.123");
|
||||
}
|
||||
// Check that durations with precision greater than std::chrono::seconds have
|
||||
// fixed precision, and print zeros even if there is no fractional part.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user