Charconv is used to serialize doubles

Author: grisumbras

CMakeLists.txt

@@ -88,6 +88,7 @@ function(boost_json_setup_properties target)
             Boost::align
             Boost::assert
             Boost::config
+            Boost::charconv
             Boost::container
             Boost::container_hash
             Boost::core

build.jam

@@ -13,6 +13,7 @@ using boost-pretty-printers ;
 constant boost_dependencies :
     /boost/align//boost_align
     /boost/assert//boost_assert
+    /boost/charconv//boost_charconv
     /boost/config//boost_config
     /boost/container//boost_container
     /boost/container_hash//boost_container_hash

build/Jamfile

@@ -50,6 +50,7 @@ project
       <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
     : usage-requirements
       <library>/boost/container//boost_container/<warnings-as-errors>off
+      <library>/boost/charconv//boost_charconv/<warnings-as-errors>off
       <define>BOOST_JSON_NO_LIB=1
     : source-location ../src
     ;

include/boost/json/detail/format.hpp

@@ -10,16 +10,15 @@
 #ifndef BOOST_JSON_DETAIL_FORMAT_HPP
 #define BOOST_JSON_DETAIL_FORMAT_HPP
 
+#include <boost/charconv/limits.hpp>
+#include <boost/json/detail/config.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
+constexpr std::size_t max_number_chars =
+    boost::charconv::limits<double>::max_chars;
 
 BOOST_JSON_DECL
 unsigned
@@ -33,7 +32,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:
+    {
+        boost::charconv::to_chars_result result = boost::charconv::to_chars(
+            dest,
+            dest + detail::max_number_chars,
+            d,
+            boost::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