Allow custom FP formatters

Author: vitaut

Diff for: include/fmt/base.h

@@ -1442,9 +1442,12 @@ template <typename Context> struct arg_mapper {
     return {};
   }
 
-  FMT_MAP_API auto map(float val) -> float { return val; }
-  FMT_MAP_API auto map(double val) -> double { return val; }
-  FMT_MAP_API auto map(long double val) -> long double { return val; }
+  // Use references to allow custom floating point formatters.
+  template <typename T, FMT_ENABLE_IF(std::is_fundamental<T>::value &&
+                                      !std::is_integral<T>::value)>
+  FMT_MAP_API auto map(const T& val) -> const T& {
+    return val;
+  }
 
   FMT_MAP_API auto map(char_type* val) -> const char_type* { return val; }
   FMT_MAP_API auto map(const char_type* val) -> const char_type* { return val; }
@@ -1527,7 +1530,8 @@ template <typename Context> struct arg_mapper {
 // A type constant after applying arg_mapper<Context>.
 template <typename T, typename Context>
 using mapped_type_constant =
-    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
+    type_constant<remove_cvref_t<decltype(arg_mapper<Context>().map(
+                      std::declval<const T&>()))>,
                   typename Context::char_type>;
 
 enum { packed_arg_bits = 4 };
@@ -2650,10 +2654,12 @@ FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
     -> decltype(ctx.begin()) {
   using char_type = typename ParseContext::char_type;
   using context = buffered_context<char_type>;
-  using mapped_type = conditional_t<
-      mapped_type_constant<T, context>::value != type::custom_type,
-      decltype(arg_mapper<context>().map(std::declval<const T&>())),
-      typename strip_named_arg<T>::type>;
+  using mapped_type =
+      conditional_t<mapped_type_constant<T, context>::value !=
+                        type::custom_type,
+                    remove_cvref_t<decltype(arg_mapper<context>().map(
+                        std::declval<const T&>()))>,
+                    typename strip_named_arg<T>::type>;
 #if defined(__cpp_if_constexpr)
   if constexpr (std::is_default_constructible<
                     formatter<mapped_type, char_type>>::value) {

Diff for: include/fmt/format.h

@@ -761,28 +761,22 @@ using is_integer =
 #  define FMT_USE_LONG_DOUBLE 1
 #endif
 
-#ifndef FMT_USE_FLOAT128
-#  ifdef __clang__
-// Clang emulates GCC, so it has to appear early.
-#    if FMT_HAS_INCLUDE(<quadmath.h>)
-#      define FMT_USE_FLOAT128 1
-#    endif
-#  elif defined(__GNUC__)
-// GNU C++:
-#    if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__)
-#      define FMT_USE_FLOAT128 1
-#    endif
-#  endif
-#  ifndef FMT_USE_FLOAT128
-#    define FMT_USE_FLOAT128 0
-#  endif
+#if defined(FMT_USE_FLOAT128)
+// Use the provided definition.
+#elif FMT_CLANG_VERSION && FMT_HAS_INCLUDE(<quadmath.h>)
+#  define FMT_USE_FLOAT128 1
+#elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \
+    !defined(__STRICT_ANSI__)
+#  define FMT_USE_FLOAT128 1
+#else
+#  define FMT_USE_FLOAT128 0
 #endif
-
 #if FMT_USE_FLOAT128
 using float128 = __float128;
 #else
 using float128 = void;
 #endif
+
 template <typename T> using is_float128 = std::is_same<T, float128>;
 
 template <typename T>
@@ -3722,7 +3716,9 @@ FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t<
 template <typename Char, typename OutputIt, typename T,
           typename Context = basic_format_context<OutputIt, Char>>
 FMT_CONSTEXPR auto write(OutputIt out, const T& value)
-    -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
+    -> enable_if_t<mapped_type_constant<T, Context>::value ==
+                           type::custom_type &&
+                       !is_floating_point<T>::value,
                    OutputIt> {
   auto formatter = typename Context::template formatter_type<T>();
   auto parse_ctx = typename Context::parse_context_type({});

Diff for: test/format-impl-test.cc

@@ -290,7 +290,9 @@ struct double_double {
   auto operator-() const -> double_double { return double_double(-a, -b); }
 };
 
-auto format_as(double_double d) -> double { return d; }
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<double_double> : formatter<double> {};
+FMT_END_NAMESPACE
 
 bool operator>=(const double_double& lhs, const double_double& rhs) {
   return lhs.a + lhs.b >= rhs.a + rhs.b;
@@ -304,7 +306,9 @@ struct slow_float {
   auto operator-() const -> slow_float { return slow_float(-value); }
 };
 
-auto format_as(slow_float f) -> float { return f; }
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<slow_float> : formatter<float> {};
+FMT_END_NAMESPACE
 
 namespace std {
 template <> struct is_floating_point<double_double> : std::true_type {};

Diff for: test/format-test.cc

@@ -1793,15 +1793,14 @@ struct deadlockable {
 
 FMT_BEGIN_NAMESPACE
 template <> struct formatter<deadlockable> {
-  FMT_CONSTEXPR auto parse(fmt::format_parse_context& ctx)
-      -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
   }
 
-  auto format(const deadlockable& d, fmt::format_context& ctx) const
+  auto format(const deadlockable& d, format_context& ctx) const
       -> decltype(ctx.out()) {
     std::lock_guard<std::mutex> lock(d.mutex);
-    return fmt::format_to(ctx.out(), "{}", d.value);
+    return format_to(ctx.out(), "{}", d.value);
   }
 };
 FMT_END_NAMESPACE