Charconv is used to serialize doubles

Author: grisumbras

include/boost/json/detail/format.hpp

@@ -10,16 +10,13 @@
 #ifndef BOOST_JSON_DETAIL_FORMAT_HPP
 #define BOOST_JSON_DETAIL_FORMAT_HPP
 
+#include <boost/charconv/limits.hpp>
+
 namespace boost {
 namespace json {
 namespace detail {
 
-int constexpr max_number_chars =
-     1 +    // '-'
-    19 +    // unsigned 64-bit mantissa
-     1 +    // 'e'
-     1 +    // '-'
-     5;     // unsigned 16-bit exponent
+std::size_t constexpr max_number_chars = charconv::limits<double>::max_chars;
 
 BOOST_JSON_DECL
 unsigned
@@ -33,7 +30,7 @@ format_int64(
     char* dest, int64_t i) noexcept;
 
 BOOST_JSON_DECL
-unsigned
+std::size_t
 format_double(
     char* dest, double d, bool allow_infinity_and_nan = false) noexcept;
 

include/boost/json/detail/impl/format.ipp

@@ -11,7 +11,8 @@
 #ifndef BOOST_JSON_DETAIL_IMPL_FORMAT_IPP
 #define BOOST_JSON_DETAIL_IMPL_FORMAT_IPP
 
-#include <boost/json/detail/ryu/ryu.hpp>
+#include <boost/charconv/to_chars.hpp>
+#include <cmath>
 #include <cstring>
 
 namespace boost {
@@ -110,12 +111,59 @@ format_int64(
     return 1 + format_uint64(dest, ui);
 }
 
-unsigned
+std::size_t
 format_double(
     char* dest, double d, bool allow_infinity_and_nan) noexcept
 {
-    return static_cast<int>(
-        ryu::d2s_buffered_n(d, dest, allow_infinity_and_nan));
+    unsigned variant = allow_infinity_and_nan ? 8 : 0;
+    variant |= std::isnan(d) ? 1 : 0;
+    if( std::isinf(d) )
+    {
+        variant |= 2;
+        variant |= std::signbit(d) ? 4 : 0;
+    }
+
+    std::size_t size;
+    switch( variant )
+    {
+    default:
+    {
+        charconv::to_chars_result result = charconv::to_chars(
+            dest,
+            dest + detail::max_number_chars,
+            d,
+            charconv::chars_format::scientific);
+        BOOST_ASSERT( result.ec == std::errc() );
+        size = result.ptr - dest;
+        break;
+    }
+    case (8 + 1):
+        std::memcpy(dest, "NaN", 3);
+        size = 3;
+        break;
+    case (0 + 1):
+        std::memcpy(dest, "null", 4);
+        size = 4;
+        break;
+    case (8 + 0 + 2):
+        std::memcpy(dest, "Infinity", 8);
+        size = 8;
+        break;
+    case (8 + 4 + 2):
+        std::memcpy(dest, "-Infinity", 9);
+        size = 9;
+        break;
+    case (0 + 0 + 2):
+        std::memcpy(dest, "1e99999", 7);
+        size = 7;
+        break;
+    case (0 + 4 + 2):
+        std::memcpy(dest, "-1e99999", 8);
+        size = 8;
+        break;
+    }
+
+    return size;
 }
 
 } // detail