couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/third_party/spdlog/include/spdlog/cfg/helpers-inl.h

@@ -78,24 +78,40 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
     return rv;
 }
 
-SPDLOG_INLINE log_levels extract_levels(const std::string &input)
+SPDLOG_INLINE void load_levels(const std::string &input)
 {
+    if (input.empty() || input.size() > 512)
+    {
+        return;
+    }
+
     auto key_vals = extract_key_vals_(input);
-    log_levels rv;
+    std::unordered_map<std::string, level::level_enum> levels;
+    level::level_enum global_level = level::info;
+    bool global_level_found = false;
 
     for (auto &name_level : key_vals)
     {
         auto &logger_name = name_level.first;
         auto level_name = to_lower_(name_level.second);
         auto level = level::from_str(level_name);
-        // fallback to "info" if unrecognized level name
+        // ignore unrecognized level names
         if (level == level::off && level_name != "off")
         {
-            level = level::info;
+            continue;
+        }
+        if (logger_name.empty()) // no logger name indicate global level
+        {
+            global_level_found = true;
+            global_level = level;
+        }
+        else
+        {
+            levels[logger_name] = level;
         }
-        rv.set(logger_name, level);
     }
-    return rv;
+
+    details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr);
 }
 
 } // namespace helpers

data/ext/third_party/spdlog/include/spdlog/cfg/helpers.h

@@ -3,7 +3,8 @@
 
 #pragma once
 
-#include <spdlog/cfg/log_levels.h>
+#include <spdlog/common.h>
+#include <unordered_map>
 
 namespace spdlog {
 namespace cfg {
@@ -17,7 +18,7 @@ namespace helpers {
 // turn off all logging except for logger1: "off,logger1=debug"
 // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
 //
-SPDLOG_API log_levels extract_levels(const std::string &txt);
+SPDLOG_API void load_levels(const std::string &txt);
 } // namespace helpers
 
 } // namespace cfg

data/ext/third_party/spdlog/include/spdlog/common.h

@@ -167,7 +167,6 @@ SPDLOG_API string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOE
 SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
 SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
 
-using level_hasher = std::hash<int>;
 } // namespace level
 
 //
@@ -232,7 +231,7 @@ namespace details {
 using std::make_unique;
 #else
 template<typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args &&... args)
+std::unique_ptr<T> make_unique(Args &&...args)
 {
     static_assert(!std::is_array<T>::value, "arrays not supported");
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));

data/ext/third_party/spdlog/include/spdlog/details/fmt_helper.h

@@ -34,7 +34,15 @@ template<typename T>
 inline unsigned int count_digits(T n)
 {
     using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
-    return static_cast<unsigned int>(fmt::internal::count_digits(static_cast<count_type>(n)));
+    return static_cast<unsigned int>(fmt::
+// fmt 7.0.0 renamed the internal namespace to detail.
+// See: https://github.com/fmtlib/fmt/issues/1538
+#if FMT_VERSION < 70000
+            internal
+#else
+            detail
+#endif
+        ::count_digits(static_cast<count_type>(n)));
 }
 
 inline void pad2(int n, memory_buf_t &dest)

data/ext/third_party/spdlog/include/spdlog/details/os.h

@@ -84,7 +84,7 @@ SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT;
 SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;
 
 #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
-void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);
+SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);
 #endif
 
 // Return directory name from given path or empty string

data/ext/third_party/spdlog/include/spdlog/details/registry-inl.h

@@ -67,7 +67,11 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logge
         new_logger->set_error_handler(err_handler_);
     }
 
-    new_logger->set_level(levels_.get(new_logger->name()));
+    // set new level according to previously configured level or default level
+    auto it = log_levels_.find(new_logger->name());
+    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    new_logger->set_level(new_level);
+
     new_logger->flush_on(flush_level_);
 
     if (backtrace_n_messages_ > 0)
@@ -171,7 +175,7 @@ SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
     {
         l.second->set_level(log_level);
     }
-    levels_.set_default(log_level);
+    global_log_level_ = log_level;
 }
 
 SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
@@ -263,14 +267,24 @@ SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registrat
     automatic_registration_ = automatic_registration;
 }
 
-SPDLOG_INLINE void registry::update_levels(cfg::log_levels levels)
+SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    levels_ = std::move(levels);
-    for (auto &l : loggers_)
+    log_levels_ = std::move(levels);
+    auto global_level_requested = global_level != nullptr;
+    global_log_level_ = global_level_requested ? *global_level : global_log_level_;
+
+    for (auto &logger : loggers_)
     {
-        auto &logger = l.second;
-        logger->set_level(levels_.get(logger->name()));
+        auto logger_entry = log_levels_.find(logger.first);
+        if (logger_entry != log_levels_.end())
+        {
+            logger.second->set_level(logger_entry->second);
+        }
+        else if (global_level_requested)
+        {
+            logger.second->set_level(*global_level);
+        }
     }
 }
 

data/ext/third_party/spdlog/include/spdlog/details/registry.h

@@ -9,7 +9,6 @@
 // This class is thread safe
 
 #include <spdlog/common.h>
-#include <spdlog/cfg/log_levels.h>
 
 #include <chrono>
 #include <functional>
@@ -28,6 +27,7 @@ class periodic_worker;
 class SPDLOG_API registry
 {
 public:
+    using log_levels = std::unordered_map<std::string, level::level_enum>;
     registry(const registry &) = delete;
     registry &operator=(const registry &) = delete;
 
@@ -80,7 +80,8 @@ public:
 
     void set_automatic_registration(bool automatic_registration);
 
-    void update_levels(cfg::log_levels levels);
+    // set levels for all existing/future loggers. global_level can be null if should not set.
+    void set_levels(log_levels levels, level::level_enum *global_level);
 
     static registry &instance();
 
@@ -90,11 +91,13 @@ private:
 
     void throw_if_exists_(const std::string &logger_name);
     void register_logger_(std::shared_ptr<logger> new_logger);
+    bool set_level_from_cfg_(logger *logger);
     std::mutex logger_map_mutex_, flusher_mutex_;
     std::recursive_mutex tp_mutex_;
     std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
-    cfg::log_levels levels_;
+    log_levels log_levels_;
     std::unique_ptr<formatter> formatter_;
+    spdlog::level::level_enum global_log_level_ = level::info;
     level::level_enum flush_level_ = level::off;
     void (*err_handler_)(const std::string &msg);
     std::shared_ptr<thread_pool> tp_;

data/ext/third_party/spdlog/include/spdlog/details/synchronous_factory.h

@@ -13,7 +13,7 @@ class logger;
 struct synchronous_factory
 {
     template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)
     {
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
         auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));

data/ext/third_party/spdlog/include/spdlog/details/tcp_client-windows.h

@@ -8,8 +8,8 @@
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 
-#include <windows.h>
 #include <winsock2.h>
+#include <windows.h>
 #include <ws2tcpip.h>
 #include <stdlib.h>
 #include <stdio.h>

data/ext/third_party/spdlog/include/spdlog/details/tcp_client.h

@@ -75,7 +75,11 @@ public:
         int last_errno = 0;
         for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
         {
-            int const flags = SOCK_CLOEXEC;
+#if defined(SOCK_CLOEXEC)
+            const int flags = SOCK_CLOEXEC;
+#else
+            const int flags = 0;
+#endif
             socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);
             if (socket_ == -1)
             {
@@ -87,12 +91,9 @@ public:
             {
                 break;
             }
-            else
-            {
-                last_errno = errno;
-                ::close(socket_);
-                socket_ = -1;
-            }
+            last_errno = errno;
+            ::close(socket_);
+            socket_ = -1;
         }
         ::freeaddrinfo(addrinfo_result);
         if (socket_ == -1)

data/ext/third_party/spdlog/include/spdlog/fmt/bin_to_hex.h

@@ -9,7 +9,7 @@
 
 //
 // Support for logging binary data as hex
-// format flags:
+// format flags, any combination of the followng:
 // {:X} - print in uppercase.
 // {:s} - don't separate each byte with space.
 // {:p} - don't print the position on each line start.
@@ -92,7 +92,7 @@ struct formatter<spdlog::details::dump_info<T>>
     auto parse(ParseContext &ctx) -> decltype(ctx.begin())
     {
         auto it = ctx.begin();
-        while (*it && *it != '}')
+        while (it != ctx.end() && *it != '}')
         {
             switch (*it)
             {

data/ext/third_party/spdlog/include/spdlog/fmt/bundled/chrono.h

@@ -48,7 +48,7 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
     // 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()) {
+    if (from < (T::min)() || from > (T::max)()) {
       // outside range.
       ec = 1;
       return {};
@@ -74,7 +74,7 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
 
   if (F::is_signed && !T::is_signed) {
     // From may be negative, not allowed!
-    if (fmt::internal::is_negative(from)) {
+    if (fmt::detail::is_negative(from)) {
       ec = 1;
       return {};
     }
@@ -84,7 +84,7 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
       // yes, From always fits in To.
     } else {
       // from may not fit in To, we have to do a dynamic check
-      if (from > static_cast<From>(T::max())) {
+      if (from > static_cast<From>((T::max)())) {
         ec = 1;
         return {};
       }
@@ -97,7 +97,7 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
       // yes, From always fits in To.
     } else {
       // from may not fit in To, we have to do a dynamic check
-      if (from > static_cast<From>(T::max())) {
+      if (from > static_cast<From>((T::max)())) {
         // outside range.
         ec = 1;
         return {};
@@ -141,7 +141,7 @@ FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
 
   // catch the only happy case
   if (std::isfinite(from)) {
-    if (from >= T::lowest() && from <= T::max()) {
+    if (from >= T::lowest() && from <= (T::max)()) {
       return static_cast<To>(from);
     }
     // not within range.
@@ -195,12 +195,13 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
   }
   // multiply with Factor::num without overflow or underflow
   if (Factor::num != 1) {
-    const auto max1 = internal::max_value<IntermediateRep>() / Factor::num;
+    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;
+    const auto min1 =
+        (std::numeric_limits<IntermediateRep>::min)() / Factor::num;
     if (count < min1) {
       ec = 1;
       return {};
@@ -269,7 +270,7 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
 
   // multiply with Factor::num without overflow or underflow
   if (Factor::num != 1) {
-    constexpr auto max1 = internal::max_value<IntermediateRep>() /
+    constexpr auto max1 = detail::max_value<IntermediateRep>() /
                           static_cast<IntermediateRep>(Factor::num);
     if (count > max1) {
       ec = 1;
@@ -306,12 +307,12 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
 // Usage: f FMT_NOMACRO()
 #define FMT_NOMACRO
 
-namespace internal {
+namespace detail {
 inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
 inline null<> localtime_s(...) { return null<>(); }
 inline null<> gmtime_r(...) { return null<>(); }
 inline null<> gmtime_s(...) { return null<>(); }
-}  // namespace internal
+}  // namespace detail
 
 // Thread-safe replacement for std::localtime
 inline std::tm localtime(std::time_t time) {
@@ -322,22 +323,22 @@ inline std::tm localtime(std::time_t time) {
     dispatcher(std::time_t t) : time_(t) {}
 
     bool run() {
-      using namespace fmt::internal;
+      using namespace fmt::detail;
       return handle(localtime_r(&time_, &tm_));
     }
 
     bool handle(std::tm* tm) { return tm != nullptr; }
 
-    bool handle(internal::null<>) {
-      using namespace fmt::internal;
+    bool handle(detail::null<>) {
+      using namespace fmt::detail;
       return fallback(localtime_s(&tm_, &time_));
     }
 
     bool fallback(int res) { return res == 0; }
 
 #if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
-      using namespace fmt::internal;
+    bool fallback(detail::null<>) {
+      using namespace fmt::detail;
       std::tm* tm = std::localtime(&time_);
       if (tm) tm_ = *tm;
       return tm != nullptr;
@@ -359,21 +360,21 @@ inline std::tm gmtime(std::time_t time) {
     dispatcher(std::time_t t) : time_(t) {}
 
     bool run() {
-      using namespace fmt::internal;
+      using namespace fmt::detail;
       return handle(gmtime_r(&time_, &tm_));
     }
 
     bool handle(std::tm* tm) { return tm != nullptr; }
 
-    bool handle(internal::null<>) {
-      using namespace fmt::internal;
+    bool handle(detail::null<>) {
+      using namespace fmt::detail;
       return fallback(gmtime_s(&tm_, &time_));
     }
 
     bool fallback(int res) { return res == 0; }
 
 #if !FMT_MSC_VER
-    bool fallback(internal::null<>) {
+    bool fallback(detail::null<>) {
       std::tm* tm = std::gmtime(&time_);
       if (tm) tm_ = *tm;
       return tm != nullptr;
@@ -386,17 +387,17 @@ inline std::tm gmtime(std::time_t time) {
   return gt.tm_;
 }
 
-namespace internal {
-inline std::size_t strftime(char* str, std::size_t count, const char* format,
-                            const std::tm* time) {
+namespace detail {
+inline size_t strftime(char* str, size_t count, const char* format,
+                       const std::tm* time) {
   return std::strftime(str, count, format, time);
 }
 
-inline std::size_t strftime(wchar_t* str, std::size_t count,
-                            const wchar_t* format, const std::tm* time) {
+inline size_t strftime(wchar_t* str, size_t count, const wchar_t* format,
+                       const std::tm* time) {
   return std::wcsftime(str, count, format, time);
 }
-}  // namespace internal
+}  // namespace detail
 
 template <typename Char> struct formatter<std::tm, Char> {
   template <typename ParseContext>
@@ -405,7 +406,7 @@ template <typename Char> struct formatter<std::tm, Char> {
     if (it != ctx.end() && *it == ':') ++it;
     auto end = it;
     while (end != ctx.end() && *end != '}') ++end;
-    tm_format.reserve(internal::to_unsigned(end - it + 1));
+    tm_format.reserve(detail::to_unsigned(end - it + 1));
     tm_format.append(it, end);
     tm_format.push_back('\0');
     return end;
@@ -414,11 +415,10 @@ template <typename Char> struct formatter<std::tm, Char> {
   template <typename FormatContext>
   auto format(const std::tm& tm, FormatContext& ctx) -> decltype(ctx.out()) {
     basic_memory_buffer<Char> buf;
-    std::size_t start = buf.size();
+    size_t start = buf.size();
     for (;;) {
-      std::size_t size = buf.capacity() - start;
-      std::size_t count =
-          internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      size_t size = buf.capacity() - start;
+      size_t count = detail::strftime(&buf[start], size, &tm_format[0], &tm);
       if (count != 0) {
         buf.resize(start + count);
         break;
@@ -430,7 +430,7 @@ template <typename Char> struct formatter<std::tm, Char> {
         // https://github.com/fmtlib/fmt/issues/367
         break;
       }
-      const std::size_t MIN_GROWTH = 10;
+      const size_t MIN_GROWTH = 10;
       buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
     }
     return std::copy(buf.begin(), buf.end(), ctx.out());
@@ -439,7 +439,7 @@ template <typename Char> struct formatter<std::tm, Char> {
   basic_memory_buffer<Char> tm_format;
 };
 
-namespace internal {
+namespace detail {
 template <typename Period> FMT_CONSTEXPR const char* get_units() {
   return nullptr;
 }
@@ -768,19 +768,25 @@ OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
   return format_to(out, std::is_floating_point<Rep>::value ? fp_f : format,
                    val);
 }
+template <typename Char, typename OutputIt>
+OutputIt copy_unit(string_view unit, OutputIt out, Char) {
+  return std::copy(unit.begin(), unit.end(), out);
+}
+
+template <typename OutputIt>
+OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) {
+  // This works when wchar_t is UTF-32 because units only contain characters
+  // that have the same representation in UTF-16 and UTF-32.
+  utf8_to_utf16 u(unit);
+  return std::copy(u.c_str(), u.c_str() + u.size(), out);
+}
 
 template <typename Char, typename Period, typename OutputIt>
 OutputIt format_duration_unit(OutputIt out) {
-  if (const char* unit = get_units<Period>()) {
-    string_view s(unit);
-    if (const_check(std::is_same<Char, wchar_t>())) {
-      utf8_to_utf16 u(s);
-      return std::copy(u.c_str(), u.c_str() + u.size(), out);
-    }
-    return std::copy(s.begin(), s.end(), out);
-  }
+  if (const char* unit = get_units<Period>())
+    return copy_unit(string_view(unit), out, Char());
   const Char num_f[] = {'[', '{', '}', ']', 's', 0};
-  if (Period::den == 1) return format_to(out, num_f, Period::num);
+  if (const_check(Period::den == 1)) return format_to(out, num_f, Period::num);
   const Char num_def_f[] = {'[', '{', '}', '/', '{', '}', ']', 's', 0};
   return format_to(out, num_def_f, Period::num, Period::den);
 }
@@ -874,9 +880,9 @@ struct chrono_formatter {
     if (isnan(value)) return write_nan();
     uint32_or_64_or_128_t<int> n =
         to_unsigned(to_nonnegative_int(value, max_value<int>()));
-    int num_digits = internal::count_digits(n);
+    int num_digits = detail::count_digits(n);
     if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
-    out = format_decimal<char_type>(out, n, num_digits);
+    out = format_decimal<char_type>(out, n, num_digits).end;
   }
 
   void write_nan() { std::copy_n("nan", 3, out); }
@@ -1004,14 +1010,14 @@ struct chrono_formatter {
     out = format_duration_unit<char_type, Period>(out);
   }
 };
-}  // namespace internal
+}  // namespace detail
 
 template <typename Rep, typename Period, typename Char>
 struct formatter<std::chrono::duration<Rep, Period>, Char> {
  private:
   basic_format_specs<Char> specs;
   int precision;
-  using arg_ref_type = internal::arg_ref<Char>;
+  using arg_ref_type = detail::arg_ref<Char>;
   arg_ref_type width_ref;
   arg_ref_type precision_ref;
   mutable basic_string_view<Char> format_str;
@@ -1032,7 +1038,7 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
       return arg_ref_type(arg_id);
     }
 
-    FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id) {
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(detail::auto_id) {
       return arg_ref_type(context.next_arg_id());
     }
 
@@ -1062,17 +1068,17 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
     auto begin = ctx.begin(), end = ctx.end();
     if (begin == end || *begin == '}') return {begin, begin};
     spec_handler handler{*this, ctx, format_str};
-    begin = internal::parse_align(begin, end, handler);
+    begin = detail::parse_align(begin, end, handler);
     if (begin == end) return {begin, begin};
-    begin = internal::parse_width(begin, end, handler);
+    begin = detail::parse_width(begin, end, handler);
     if (begin == end) return {begin, begin};
     if (*begin == '.') {
       if (std::is_floating_point<Rep>::value)
-        begin = internal::parse_precision(begin, end, handler);
+        begin = detail::parse_precision(begin, end, handler);
       else
         handler.on_error("precision not allowed for this argument type");
     }
-    end = parse_chrono_format(begin, end, internal::chrono_format_checker());
+    end = parse_chrono_format(begin, end, detail::chrono_format_checker());
     return {begin, end};
   }
 
@@ -1083,7 +1089,7 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
       -> decltype(ctx.begin()) {
     auto range = do_parse(ctx);
     format_str = basic_string_view<Char>(
-        &*range.begin, internal::to_unsigned(range.end - range.begin));
+        &*range.begin, detail::to_unsigned(range.end - range.begin));
     return range.end;
   }
 
@@ -1094,23 +1100,21 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
     // is not specified.
     basic_memory_buffer<Char> buf;
     auto out = std::back_inserter(buf);
-    using range = internal::output_range<decltype(ctx.out()), Char>;
-    internal::basic_writer<range> w(range(ctx.out()));
-    internal::handle_dynamic_spec<internal::width_checker>(specs.width,
-                                                           width_ref, ctx);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-        precision, precision_ref, ctx);
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref,
+                                                       ctx);
+    detail::handle_dynamic_spec<detail::precision_checker>(precision,
+                                                           precision_ref, ctx);
     if (begin == end || *begin == '}') {
-      out = internal::format_duration_value<Char>(out, d.count(), precision);
-      internal::format_duration_unit<Char, Period>(out);
+      out = detail::format_duration_value<Char>(out, d.count(), precision);
+      detail::format_duration_unit<Char, Period>(out);
     } else {
-      internal::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
+      detail::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
           ctx, out, d);
       f.precision = precision;
       parse_chrono_format(begin, end, f);
     }
-    w.write(buf.data(), buf.size(), specs);
-    return w.out();
+    return detail::write(
+        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
   }
 };