blame: source/misc/embedded_libs/fmt-11.0.2/include/fmt/chrono.h

// Formatting library for C++ - chrono support

//

// Copyright (c) 2012 - present, Victor Zverovich

// All rights reserved.

//

// For the license information refer to format.h.

#ifndef FMT_CHRONO_H_

#define FMT_CHRONO_H_

#ifndef FMT_MODULE

#  include <algorithm>

#  include <chrono>

#  include <cmath>    // std::isfinite

#  include <cstring>  // std::memcpy

#  include <ctime>

#  include <iterator>

#  include <locale>

#  include <ostream>

#  include <type_traits>

#endif

#include "format.h"

FMT_BEGIN_NAMESPACE

// Check if std::chrono::local_t is available.

#ifndef FMT_USE_LOCAL_TIME

#  ifdef __cpp_lib_chrono

#    define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L)

#  else

#    define FMT_USE_LOCAL_TIME 0

#  endif

#endif

// Check if std::chrono::utc_timestamp is available.

#ifndef FMT_USE_UTC_TIME

#  ifdef __cpp_lib_chrono

#    define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L)

#  else

#    define FMT_USE_UTC_TIME 0

#  endif

#endif

// Enable tzset.

#ifndef FMT_USE_TZSET

// UWP doesn't provide _tzset.

#  if FMT_HAS_INCLUDE("winapifamily.h")

#    include <winapifamily.h>

#  endif

#  if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \

                          (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))

#    define FMT_USE_TZSET 1

#  else

#    define FMT_USE_TZSET 0

#  endif

#endif

// Enable safe chrono durations, unless explicitly disabled.

#ifndef FMT_SAFE_DURATION_CAST

#  define FMT_SAFE_DURATION_CAST 1

#endif

#if FMT_SAFE_DURATION_CAST

// For conversion between std::chrono::durations without undefined

// behaviour or erroneous results.

// This is a stripped down version of duration_cast, for inclusion in fmt.

// See https://github.com/pauldreik/safe_duration_cast

//

// Copyright Paul Dreik 2019

namespace safe_duration_cast {

template <typename To, typename From,

          FMT_ENABLE_IF(!std::is_same<From, To>::value &&

                        std::numeric_limits<From>::is_signed ==

                            std::numeric_limits<To>::is_signed)>

FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)

    -> To {

  ec = 0;

  using F = std::numeric_limits<From>;

  using T = std::numeric_limits<To>;

  static_assert(F::is_integer, "From must be integral");

  static_assert(T::is_integer, "To must be integral");

  // A and B are both signed, or both unsigned.

  if (detail::const_check(F::digits <= T::digits)) {

    // From fits in To without any problem.

  } else {

    // From does not always fit in To, resort to a dynamic check.

    if (from < (T::min)() || from > (T::max)()) {

      // outside range.

      ec = 1;

      return {};

    }

  }

  return static_cast<To>(from);

}

/// Converts From to To, without loss. If the dynamic value of from

/// can't be converted to To without loss, ec is set.

template <typename To, typename From,

          FMT_ENABLE_IF(!std::is_same<From, To>::value &&

                        std::numeric_limits<From>::is_signed !=

                            std::numeric_limits<To>::is_signed)>

FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)

    -> To {

  ec = 0;

  using F = std::numeric_limits<From>;

  using T = std::numeric_limits<To>;

  static_assert(F::is_integer, "From must be integral");

  static_assert(T::is_integer, "To must be integral");

  if (detail::const_check(F::is_signed && !T::is_signed)) {

    // From may be negative, not allowed!

    if (fmt::detail::is_negative(from)) {

      ec = 1;

      return {};

    }

    // From is positive. Can it always fit in To?

    if (detail::const_check(F::digits > T::digits) &&

        from > static_cast<From>(detail::max_value<To>())) {

      ec = 1;

      return {};

    }

  }

  if (detail::const_check(!F::is_signed && T::is_signed &&

                          F::digits >= T::digits) &&

      from > static_cast<From>(detail::max_value<To>())) {

    ec = 1;

    return {};

  }

  return static_cast<To>(from);  // Lossless conversion.

}

template <typename To, typename From,

          FMT_ENABLE_IF(std::is_same<From, To>::value)>

FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)

    -> To {

  ec = 0;

  return from;

}  // function

// clang-format off

/**

 * converts From to To if possible, otherwise ec is set.

 *

 * input                            |    output

 * ---------------------------------|---------------

 * NaN                              | NaN

 * Inf                              | Inf

 * normal, fits in output           | converted (possibly lossy)

 * normal, does not fit in output   | ec is set

 * subnormal                        | best effort

 * -Inf                             | -Inf

 */

// clang-format on

template <typename To, typename From,

          FMT_ENABLE_IF(!std::is_same<From, To>::value)>

FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {

  ec = 0;

  using T = std::numeric_limits<To>;

  static_assert(std::is_floating_point<From>::value, "From must be floating");

  static_assert(std::is_floating_point<To>::value, "To must be floating");

  // catch the only happy case

  if (std::isfinite(from)) {

    if (from >= T::lowest() && from <= (T::max)()) {

      return static_cast<To>(from);

    }

    // not within range.

    ec = 1;

    return {};

  }

  // nan and inf will be preserved

  return static_cast<To>(from);

}  // function

template <typename To, typename From,

          FMT_ENABLE_IF(std::is_same<From, To>::value)>

FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {

  ec = 0;

  static_assert(std::is_floating_point<From>::value, "From must be floating");

  return from;

}

/// Safe duration cast between integral durations

template <typename To, typename FromRep, typename FromPeriod,

          FMT_ENABLE_IF(std::is_integral<FromRep>::value),

          FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>

auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,

                        int& ec) -> To {

  using From = std::chrono::duration<FromRep, FromPeriod>;

  ec = 0;

  // the basic idea is that we need to convert from count() in the from type

  // to count() in the To type, by multiplying it with this:

  struct Factor

      : std::ratio_divide<typename From::period, typename To::period> {};

  static_assert(Factor::num > 0, "num must be positive");

  static_assert(Factor::den > 0, "den must be positive");

  // the conversion is like this: multiply from.count() with Factor::num

  // /Factor::den and convert it to To::rep, all this without

  // overflow/underflow. let's start by finding a suitable type that can hold

  // both To, From and Factor::num

  using IntermediateRep =

      typename std::common_type<typename From::rep, typename To::rep,

                                decltype(Factor::num)>::type;

  // safe conversion to IntermediateRep

  IntermediateRep count =

      lossless_integral_conversion<IntermediateRep>(from.count(), ec);

  if (ec) return {};

  // multiply with Factor::num without overflow or underflow

  if (detail::const_check(Factor::num != 1)) {

    const auto max1 = detail::max_value<IntermediateRep>() / Factor::num;

    if (count > max1) {

      ec = 1;

      return {};

    }

    const auto min1 =

        (std::numeric_limits<IntermediateRep>::min)() / Factor::num;

    if (detail::const_check(!std::is_unsigned<IntermediateRep>::value) &&

        count < min1) {

      ec = 1;

      return {};

    }

    count *= Factor::num;

  }

  if (detail::const_check(Factor::den != 1)) count /= Factor::den;

  auto tocount = lossless_integral_conversion<typename To::rep>(count, ec);

  return ec ? To() : To(tocount);

}

/// Safe duration_cast between floating point durations

template <typename To, typename FromRep, typename FromPeriod,

          FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),

          FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>

auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,

                        int& ec) -> To {

  using From = std::chrono::duration<FromRep, FromPeriod>;

  ec = 0;

  if (std::isnan(from.count())) {

    // nan in, gives nan out. easy.

    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};

  }

  // maybe we should also check if from is denormal, and decide what to do about

  // it.

  // +-inf should be preserved.

  if (std::isinf(from.count())) {

    return To{from.count()};

  }

  // the basic idea is that we need to convert from count() in the from type

  // to count() in the To type, by multiplying it with this:

  struct Factor

      : std::ratio_divide<typename From::period, typename To::period> {};

  static_assert(Factor::num > 0, "num must be positive");

  static_assert(Factor::den > 0, "den must be positive");

  // the conversion is like this: multiply from.count() with Factor::num

  // /Factor::den and convert it to To::rep, all this without

  // overflow/underflow. let's start by finding a suitable type that can hold

  // both To, From and Factor::num

  using IntermediateRep =

      typename std::common_type<typename From::rep, typename To::rep,

                                decltype(Factor::num)>::type;

  // force conversion of From::rep -> IntermediateRep to be safe,

  // even if it will never happen be narrowing in this context.

  IntermediateRep count =

      safe_float_conversion<IntermediateRep>(from.count(), ec);

  if (ec) {

    return {};

  }

  // multiply with Factor::num without overflow or underflow

  if (detail::const_check(Factor::num != 1)) {

    constexpr auto max1 = detail::max_value<IntermediateRep>() /

                          static_cast<IntermediateRep>(Factor::num);

    if (count > max1) {

      ec = 1;

      return {};

    }

    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /

                          static_cast<IntermediateRep>(Factor::num);

    if (count < min1) {

      ec = 1;

      return {};

    }

    count *= static_cast<IntermediateRep>(Factor::num);

  }

  // this can't go wrong, right? den>0 is checked earlier.

  if (detail::const_check(Factor::den != 1)) {

    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;

    count /= static_cast<common_t>(Factor::den);

  }

  // convert to the to type, safely

  using ToRep = typename To::rep;

  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);

  if (ec) {

    return {};

  }

  return To{tocount};

}

}  // namespace safe_duration_cast

#endif

// Prevents expansion of a preceding token as a function-style macro.

// Usage: f FMT_NOMACRO()

#define FMT_NOMACRO

namespace detail {

template <typename T = void> struct null {};

inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); }

inline auto localtime_s(...) -> null<> { return null<>(); }

inline auto gmtime_r(...) -> null<> { return null<>(); }

inline auto gmtime_s(...) -> null<> { return null<>(); }

// It is defined here and not in ostream.h because the latter has expensive

// includes.

template <typename Streambuf> class formatbuf : public Streambuf {

 private:

  using char_type = typename Streambuf::char_type;

  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));

  using int_type = typename Streambuf::int_type;

  using traits_type = typename Streambuf::traits_type;

  buffer<char_type>& buffer_;

 public:

  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}

 protected:

  // The put area is always empty. This makes the implementation simpler and has

  // the advantage that the streambuf and the buffer are always in sync and

  // sputc never writes into uninitialized memory. A disadvantage is that each

  // call to sputc always results in a (virtual) call to overflow. There is no

  // disadvantage here for sputn since this always results in a call to xsputn.

  auto overflow(int_type ch) -> int_type override {

    if (!traits_type::eq_int_type(ch, traits_type::eof()))

      buffer_.push_back(static_cast<char_type>(ch));

    return ch;

  }

  auto xsputn(const char_type* s, streamsize count) -> streamsize override {

    buffer_.append(s, s + count);

    return count;

  }

};

inline auto get_classic_locale() -> const std::locale& {

  static const auto& locale = std::locale::classic();

  return locale;

}

template <typename CodeUnit> struct codecvt_result {

  static constexpr const size_t max_size = 32;

  CodeUnit buf[max_size];

  CodeUnit* end;

};

template <typename CodeUnit>

void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,

                   const std::locale& loc) {

#if FMT_CLANG_VERSION

#  pragma clang diagnostic push

#  pragma clang diagnostic ignored "-Wdeprecated"

  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);

#  pragma clang diagnostic pop

#else

  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);

#endif

  auto mb = std::mbstate_t();

  const char* from_next = nullptr;

  auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next,

                     std::begin(out.buf), std::end(out.buf), out.end);

  if (result != std::codecvt_base::ok)

    FMT_THROW(format_error("failed to format time"));

}

template <typename OutputIt>

auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)

    -> OutputIt {

  if (detail::use_utf8() && loc != get_classic_locale()) {

    // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and

    // gcc-4.

#if FMT_MSC_VERSION != 0 ||  \

    (defined(__GLIBCXX__) && \

     (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0))

    // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5

    // and newer.

    using code_unit = wchar_t;

#else

    using code_unit = char32_t;

#endif

    using unit_t = codecvt_result<code_unit>;

    unit_t unit;

    write_codecvt(unit, in, loc);

    // In UTF-8 is used one to four one-byte code units.

    auto u =

        to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>();

    if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)}))

      FMT_THROW(format_error("failed to format time"));

    return copy<char>(u.c_str(), u.c_str() + u.size(), out);

  }

  return copy<char>(in.data(), in.data() + in.size(), out);

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>

auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)

    -> OutputIt {

  codecvt_result<Char> unit;

  write_codecvt(unit, sv, loc);

  return copy<Char>(unit.buf, unit.end, out);

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(std::is_same<Char, char>::value)>

auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)

    -> OutputIt {

  return write_encoded_tm_str(out, sv, loc);

}

template <typename Char>

inline void do_write(buffer<Char>& buf, const std::tm& time,

                     const std::locale& loc, char format, char modifier) {

  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);

  auto&& os = std::basic_ostream<Char>(&format_buf);

  os.imbue(loc);

  const auto& facet = std::use_facet<std::time_put<Char>>(loc);

  auto end = facet.put(os, os, Char(' '), &time, format, modifier);

  if (end.failed()) FMT_THROW(format_error("failed to format time"));

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>

auto write(OutputIt out, const std::tm& time, const std::locale& loc,

           char format, char modifier = 0) -> OutputIt {

  auto&& buf = get_buffer<Char>(out);

  do_write<Char>(buf, time, loc, format, modifier);

  return get_iterator(buf, out);

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(std::is_same<Char, char>::value)>

auto write(OutputIt out, const std::tm& time, const std::locale& loc,

           char format, char modifier = 0) -> OutputIt {

  auto&& buf = basic_memory_buffer<Char>();

  do_write<char>(buf, time, loc, format, modifier);

  return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);

}

template <typename Rep1, typename Rep2>

struct is_same_arithmetic_type

    : public std::integral_constant<bool,

                                    (std::is_integral<Rep1>::value &&

                                     std::is_integral<Rep2>::value) ||

                                        (std::is_floating_point<Rep1>::value &&

                                         std::is_floating_point<Rep2>::value)> {

};

template <

    typename To, typename FromRep, typename FromPeriod,

    FMT_ENABLE_IF(is_same_arithmetic_type<FromRep, typename To::rep>::value)>

auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {

#if FMT_SAFE_DURATION_CAST

  // Throwing version of safe_duration_cast is only available for

  // integer to integer or float to float casts.

  int ec;

  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);

  if (ec) FMT_THROW(format_error("cannot format duration"));

  return to;

#else

  // Standard duration cast, may overflow.

  return std::chrono::duration_cast<To>(from);

#endif

}

template <

    typename To, typename FromRep, typename FromPeriod,

    FMT_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)>

auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {

  // Mixed integer <-> float cast is not supported by safe_duration_cast.

  return std::chrono::duration_cast<To>(from);

}

template <typename Duration>

auto to_time_t(

    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)

    -> std::time_t {

  // Cannot use std::chrono::system_clock::to_time_t since this would first

  // require a cast to std::chrono::system_clock::time_point, which could

  // overflow.

  return fmt_duration_cast<std::chrono::duration<std::time_t>>(

             time_point.time_since_epoch())

      .count();

}

}  // namespace detail

FMT_BEGIN_EXPORT

/**

 * Converts given time since epoch as `std::time_t` value into calendar time,

 * expressed in local time. Unlike `std::localtime`, this function is

 * thread-safe on most platforms.

 */

inline auto localtime(std::time_t time) -> std::tm {

  struct dispatcher {

    std::time_t time_;

    std::tm tm_;

    dispatcher(std::time_t t) : time_(t) {}

    auto run() -> bool {

      using namespace fmt::detail;

      return handle(localtime_r(&time_, &tm_));

    }

    auto handle(std::tm* tm) -> bool { return tm != nullptr; }

    auto handle(detail::null<>) -> bool {

      using namespace fmt::detail;

      return fallback(localtime_s(&tm_, &time_));

    }

    auto fallback(int res) -> bool { return res == 0; }

#if !FMT_MSC_VERSION

    auto fallback(detail::null<>) -> bool {

      using namespace fmt::detail;

      std::tm* tm = std::localtime(&time_);

      if (tm) tm_ = *tm;

      return tm != nullptr;

    }

#endif

  };

  dispatcher lt(time);

  // Too big time values may be unsupported.

  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));

  return lt.tm_;

}

#if FMT_USE_LOCAL_TIME

template <typename Duration>

inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {

  return localtime(

      detail::to_time_t(std::chrono::current_zone()->to_sys(time)));

}

#endif

/**

 * Converts given time since epoch as `std::time_t` value into calendar time,

 * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this

 * function is thread-safe on most platforms.

 */

inline auto gmtime(std::time_t time) -> std::tm {

  struct dispatcher {

    std::time_t time_;

    std::tm tm_;

    dispatcher(std::time_t t) : time_(t) {}

    auto run() -> bool {

      using namespace fmt::detail;

      return handle(gmtime_r(&time_, &tm_));

    }

    auto handle(std::tm* tm) -> bool { return tm != nullptr; }

    auto handle(detail::null<>) -> bool {

      using namespace fmt::detail;

      return fallback(gmtime_s(&tm_, &time_));

    }

    auto fallback(int res) -> bool { return res == 0; }

#if !FMT_MSC_VERSION

    auto fallback(detail::null<>) -> bool {

      std::tm* tm = std::gmtime(&time_);

      if (tm) tm_ = *tm;

      return tm != nullptr;

    }

#endif

  };

  auto gt = dispatcher(time);

  // Too big time values may be unsupported.

  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));

  return gt.tm_;

}

template <typename Duration>

inline auto gmtime(

    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)

    -> std::tm {

  return gmtime(detail::to_time_t(time_point));

}

namespace detail {

// Writes two-digit numbers a, b and c separated by sep to buf.

// The method by Pavel Novikov based on

// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/.

inline void write_digit2_separated(char* buf, unsigned a, unsigned b,

                                   unsigned c, char sep) {

  unsigned long long digits =

      a | (b << 24) | (static_cast<unsigned long long>(c) << 48);

  // Convert each value to BCD.

  // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b.

  // The difference is

  //   y - x = a * 6

  // a can be found from x:

  //   a = floor(x / 10)

  // then

  //   y = x + a * 6 = x + floor(x / 10) * 6

  // floor(x / 10) is (x * 205) >> 11 (needs 16 bits).

  digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6;

  // Put low nibbles to high bytes and high nibbles to low bytes.

  digits = ((digits & 0x00f00000f00000f0) >> 4) |

           ((digits & 0x000f00000f00000f) << 8);

  auto usep = static_cast<unsigned long long>(sep);

  // Add ASCII '0' to each digit byte and insert separators.

  digits |= 0x3030003030003030 | (usep << 16) | (usep << 40);

  constexpr const size_t len = 8;

  if (const_check(is_big_endian())) {

    char tmp[len];

    std::memcpy(tmp, &digits, len);

    std::reverse_copy(tmp, tmp + len, buf);

  } else {

    std::memcpy(buf, &digits, len);

  }

}

template <typename Period>

FMT_CONSTEXPR inline auto get_units() -> const char* {

  if (std::is_same<Period, std::atto>::value) return "as";

  if (std::is_same<Period, std::femto>::value) return "fs";

  if (std::is_same<Period, std::pico>::value) return "ps";

  if (std::is_same<Period, std::nano>::value) return "ns";

  if (std::is_same<Period, std::micro>::value) return "µs";

  if (std::is_same<Period, std::milli>::value) return "ms";

  if (std::is_same<Period, std::centi>::value) return "cs";

  if (std::is_same<Period, std::deci>::value) return "ds";

  if (std::is_same<Period, std::ratio<1>>::value) return "s";

  if (std::is_same<Period, std::deca>::value) return "das";

  if (std::is_same<Period, std::hecto>::value) return "hs";

  if (std::is_same<Period, std::kilo>::value) return "ks";

  if (std::is_same<Period, std::mega>::value) return "Ms";

  if (std::is_same<Period, std::giga>::value) return "Gs";

  if (std::is_same<Period, std::tera>::value) return "Ts";

  if (std::is_same<Period, std::peta>::value) return "Ps";

  if (std::is_same<Period, std::exa>::value) return "Es";

  if (std::is_same<Period, std::ratio<60>>::value) return "min";

  if (std::is_same<Period, std::ratio<3600>>::value) return "h";

  if (std::is_same<Period, std::ratio<86400>>::value) return "d";

  return nullptr;

}

enum class numeric_system {

  standard,

  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.

  alternative

};

// Glibc extensions for formatting numeric values.

enum class pad_type {

  // Pad a numeric result string with zeros (the default).

  zero,

  // Do not pad a numeric result string.

  none,

  // Pad a numeric result string with spaces.

  space,

};

template <typename OutputIt>

auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt {

  if (pad == pad_type::none) return out;

  return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0');

}

template <typename OutputIt>

auto write_padding(OutputIt out, pad_type pad) -> OutputIt {

  if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0';

  return out;

}

// Parses a put_time-like format string and invokes handler actions.

template <typename Char, typename Handler>

FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,

                                       Handler&& handler) -> const Char* {

  if (begin == end || *begin == '}') return begin;

  if (*begin != '%') FMT_THROW(format_error("invalid format"));

  auto ptr = begin;

  while (ptr != end) {

    pad_type pad = pad_type::zero;

    auto c = *ptr;

    if (c == '}') break;

    if (c != '%') {

      ++ptr;

      continue;

    }

    if (begin != ptr) handler.on_text(begin, ptr);

    ++ptr;  // consume '%'

    if (ptr == end) FMT_THROW(format_error("invalid format"));

    c = *ptr;

    switch (c) {

    case '_':

      pad = pad_type::space;

      ++ptr;

      break;

    case '-':

      pad = pad_type::none;

      ++ptr;

      break;

    }

    if (ptr == end) FMT_THROW(format_error("invalid format"));

    c = *ptr++;

    switch (c) {

    case '%':

      handler.on_text(ptr - 1, ptr);

      break;

    case 'n': {

      const Char newline[] = {'\n'};

      handler.on_text(newline, newline + 1);

      break;

    }

    case 't': {

      const Char tab[] = {'\t'};

      handler.on_text(tab, tab + 1);

      break;

    }

    // Year:

    case 'Y':

      handler.on_year(numeric_system::standard);

      break;

    case 'y':

      handler.on_short_year(numeric_system::standard);

      break;

    case 'C':

      handler.on_century(numeric_system::standard);

      break;

    case 'G':

      handler.on_iso_week_based_year();

      break;

    case 'g':

      handler.on_iso_week_based_short_year();

      break;

    // Day of the week:

    case 'a':

      handler.on_abbr_weekday();

      break;

    case 'A':

      handler.on_full_weekday();

      break;

    case 'w':

      handler.on_dec0_weekday(numeric_system::standard);

      break;

    case 'u':

      handler.on_dec1_weekday(numeric_system::standard);

      break;

    // Month:

    case 'b':

    case 'h':

      handler.on_abbr_month();

      break;

    case 'B':

      handler.on_full_month();

      break;

    case 'm':

      handler.on_dec_month(numeric_system::standard);

      break;

    // Day of the year/month:

    case 'U':

      handler.on_dec0_week_of_year(numeric_system::standard, pad);

      break;

    case 'W':

      handler.on_dec1_week_of_year(numeric_system::standard, pad);

      break;

    case 'V':

      handler.on_iso_week_of_year(numeric_system::standard, pad);

      break;

    case 'j':

      handler.on_day_of_year();

      break;

    case 'd':

      handler.on_day_of_month(numeric_system::standard, pad);

      break;

    case 'e':

      handler.on_day_of_month(numeric_system::standard, pad_type::space);

      break;

    // Hour, minute, second:

    case 'H':

      handler.on_24_hour(numeric_system::standard, pad);

      break;

    case 'I':

      handler.on_12_hour(numeric_system::standard, pad);

      break;

    case 'M':

      handler.on_minute(numeric_system::standard, pad);

      break;

    case 'S':

      handler.on_second(numeric_system::standard, pad);

      break;

    // Other:

    case 'c':

      handler.on_datetime(numeric_system::standard);

      break;

    case 'x':

      handler.on_loc_date(numeric_system::standard);

      break;

    case 'X':

      handler.on_loc_time(numeric_system::standard);

      break;

    case 'D':

      handler.on_us_date();

      break;

    case 'F':

      handler.on_iso_date();

      break;

    case 'r':

      handler.on_12_hour_time();

      break;

    case 'R':

      handler.on_24_hour_time();

      break;

    case 'T':

      handler.on_iso_time();

      break;

    case 'p':

      handler.on_am_pm();

      break;

    case 'Q':

      handler.on_duration_value();

      break;

    case 'q':

      handler.on_duration_unit();

      break;

    case 'z':

      handler.on_utc_offset(numeric_system::standard);

      break;

    case 'Z':

      handler.on_tz_name();

      break;

    // Alternative representation:

    case 'E': {

      if (ptr == end) FMT_THROW(format_error("invalid format"));

      c = *ptr++;

      switch (c) {

      case 'Y':

        handler.on_year(numeric_system::alternative);

        break;

      case 'y':

        handler.on_offset_year();

        break;

      case 'C':

        handler.on_century(numeric_system::alternative);

        break;

      case 'c':

        handler.on_datetime(numeric_system::alternative);

        break;

      case 'x':

        handler.on_loc_date(numeric_system::alternative);

        break;

      case 'X':

        handler.on_loc_time(numeric_system::alternative);

        break;

      case 'z':

        handler.on_utc_offset(numeric_system::alternative);

        break;

      default:

        FMT_THROW(format_error("invalid format"));

      }

      break;

    }

    case 'O':

      if (ptr == end) FMT_THROW(format_error("invalid format"));