From 67a602a43c18c95b5e59a0e901e0794674e90c85 Mon Sep 17 00:00:00 2001
From: MistEO <mistereo@hotmail.com>
Date: Sat, 21 Oct 2023 05:44:40 +0800
Subject: [PATCH] =?UTF-8?q?perf:=20=E8=BF=9B=E4=B8=80=E6=AD=A5=E4=BC=98?=
 =?UTF-8?q?=E5=8C=96=20serialize?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/json.hpp  | 56 ++++++++++++++++++++++-------------------------
 sample/sample.cpp |  2 +-
 2 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/include/json.hpp b/include/json.hpp
index 0c95ae4..59eac9b 100644
--- a/include/json.hpp
+++ b/include/json.hpp
@@ -565,9 +565,9 @@ namespace literals
 template <typename string_t = default_string_t>
 const basic_value<string_t> invalid_value();
 
-template <bool stream, typename any_t, typename string_t = default_string_t,
-          typename streamer_t = _serialization_helper::string_streamer<string_t>>
-basic_value<string_t> serialize(any_t&& arg, streamer_t&& streamer = streamer_t());
+template <bool loose, typename any_t, typename string_t = default_string_t,
+          typename string_converter_t = serialization_helper::string_converter<loose, string_t>>
+basic_value<string_t> serialize(any_t&& arg, string_converter_t&& string_converter = {});
 
 // ******************************
 // *      basic_value impl      *
@@ -2527,7 +2527,7 @@ MEOJSON_INLINE const basic_value<string_t> invalid_value()
     return basic_value<string_t>(basic_value<string_t>::value_type::invalid, typename basic_value<string_t>::var_t());
 }
 
-namespace _serialization_helper
+namespace serialization_helper
 {
     template <typename char_t, typename T>
     class has_output_operator
@@ -2566,40 +2566,36 @@ namespace _serialization_helper
     template <typename T>
     constexpr bool is_sequence_container<T> = is_container<T> && !is_associative_container<T>;
 
-    template <typename string_t>
-    struct string_streamer
+    template <bool loose, typename string_t = default_string_t>
+    struct string_converter
     {
         using char_t = typename string_t::value_type;
         using ostringstream_t = std::basic_ostringstream<char_t, std::char_traits<char_t>, std::allocator<char_t>>;
 
+        static constexpr bool stream = loose;
+
         template <typename input_t>
         string_t operator()(input_t&& arg) const
         {
-            ostringstream_t os;
-            os << std::forward<input_t>(arg);
-            return std::move(os).str();
+            if constexpr (std::is_constructible_v<string_t, input_t>) {
+                return arg;
+            }
+            else if constexpr (stream && has_output_operator<char_t, input_t>::value) {
+                ostringstream_t os;
+                os << std::forward<input_t>(arg);
+                return std::move(os).str();
+            }
+            else {
+                static_assert(!sizeof(input_t), "Unable to convert type to string.");
+            }
         }
     };
-
-    template <bool stream, typename input_t, typename string_t, typename streamer_t>
-    MEOJSON_INLINE string_t to_string(input_t&& arg, streamer_t&& streamer)
-    {
-        if constexpr (std::is_constructible_v<string_t, input_t>) {
-            return arg;
-        }
-        else if constexpr (stream) {
-            return streamer(std::forward<input_t>(arg));
-        }
-        else {
-            static_assert(!sizeof(input_t), "Unable to convert type to string.");
-        }
-    }
 }
 
-template <bool stream, typename any_t, typename string_t, typename streamer_t>
-MEOJSON_INLINE basic_value<string_t> serialize(any_t&& arg, streamer_t&& streamer)
+template <bool loose, typename any_t, typename string_t, typename string_converter_t>
+MEOJSON_INLINE basic_value<string_t> serialize(any_t&& arg, string_converter_t&& string_converter)
 {
-    using namespace _serialization_helper;
+    using namespace serialization_helper;
 
     if constexpr (std::is_constructible_v<basic_value<string_t>, any_t>) {
         return arg;
@@ -2615,7 +2611,7 @@ MEOJSON_INLINE basic_value<string_t> serialize(any_t&& arg, streamer_t&& streame
         for (auto&& val : arg) {
             using value_t = decltype(val);
 
-            result.emplace(serialize<stream, value_t, string_t>(std::forward<value_t>(val), streamer));
+            result.emplace(serialize<loose, value_t, string_t>(std::forward<value_t>(val), string_converter));
         }
         return result;
     }
@@ -2625,13 +2621,13 @@ MEOJSON_INLINE basic_value<string_t> serialize(any_t&& arg, streamer_t&& streame
             using key_t = decltype(key);
             using value_t = decltype(val);
 
-            result.emplace(to_string<stream, key_t, string_t>(std::forward<key_t>(key), streamer),
-                           serialize<stream, value_t, string_t>(std::forward<value_t>(val), streamer));
+            result.emplace(string_converter(std::forward<key_t>(key)),
+                           serialize<loose, value_t, string_t>(std::forward<value_t>(val), string_converter));
         }
         return result;
     }
     else {
-        return to_string<stream, any_t, string_t>(std::forward<any_t>(arg), streamer);
+        return string_converter(std::forward<any_t>(arg));
     }
 }
 
diff --git a/sample/sample.cpp b/sample/sample.cpp
index 5bddff5..3aeb740 100644
--- a/sample/sample.cpp
+++ b/sample/sample.cpp
@@ -246,7 +246,7 @@ bool serializing()
         { "key2", { { 3, { 0.4 } }, { 4, { 0.5, 0.6, 0.7 } } } },
     };
     // the "std::map<int, xxx>" cannot be converted to json because the key is "int",
-    // you can set the template parameter "stream" of "serialize" to true, which will make a more relaxed conversion.
+    // you can set the template parameter "loose" of "serialize" to true, which will make a more relaxed conversion.
     root["more_complex"] = json::serialize<true>(more_complex);
 
     // for test