use value_from for initializer_list construction

Author: grisumbras

doc/pages/dom/init_lists.adoc

@@ -97,6 +97,14 @@ Do not create variables of type {std_initializer_list}. This may result in
 temporaries being destroyed before the initializer list is used.
 ====
 
+Initializer lists use <<ref_value_from>> conversion under the hood if the
+element is not natively convertible to `value`. For example:
+
+[source]
+----
+include::../../../test/snippets.cpp[tag=snippet_init_list_10,indent=0]
+----
+
 In all cases, the <<ref_storage_ptr>> owned by an <<ref_object>>,
 <<ref_array>>, or <<ref_value>> constructed from an initializer list will be
 propagated to each element, recursively.

include/boost/json/detail/parse_into.hpp

@@ -15,6 +15,7 @@
 
 #include <boost/json/error.hpp>
 #include <boost/json/conversion.hpp>
+#include <boost/json/value.hpp>
 #include <boost/describe/enum_from_string.hpp>
 
 #include <vector>

include/boost/json/detail/value_from.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_JSON_DETAIL_VALUE_FROM_HPP
 #define BOOST_JSON_DETAIL_VALUE_FROM_HPP
 
+#include <boost/json/value.hpp>
 #include <boost/json/conversion.hpp>
 #include <boost/describe/enum_to_string.hpp>
 #include <boost/mp11/algorithm.hpp>

include/boost/json/impl/conversion.hpp

@@ -12,7 +12,6 @@
 #define BOOST_JSON_IMPL_CONVERSION_HPP
 
 #include <boost/json/fwd.hpp>
-#include <boost/json/value.hpp>
 #include <boost/json/string_view.hpp>
 #include <boost/describe/enumerators.hpp>
 #include <boost/describe/members.hpp>
@@ -30,6 +29,9 @@
 
 namespace boost {
 namespace json {
+
+class value_ref;
+
 namespace detail {
 
 #ifdef __cpp_lib_nonmember_container_access
@@ -196,6 +198,7 @@ struct object_conversion_tag : native_conversion_tag { };
 struct array_conversion_tag : native_conversion_tag { };
 struct string_conversion_tag : native_conversion_tag { };
 struct bool_conversion_tag : native_conversion_tag { };
+struct value_ref_tag : native_conversion_tag { };
 struct number_conversion_tag : native_conversion_tag { };
 struct integral_conversion_tag : number_conversion_tag { };
 struct floating_point_conversion_tag : number_conversion_tag { };
@@ -358,6 +361,9 @@ using native_conversion_category = mp11::mp_cond<
 // generic conversions
 template< class T >
 using generic_conversion_category = mp11::mp_cond<
+    // std::is_same<T,std::initializer_list<value_ref>>, init_list_tag,
+    std::is_same<T, value_ref>, value_ref_tag,
+
     std::is_same<T, bool>,     bool_conversion_tag,
     std::is_integral<T>,       integral_conversion_tag,
     std::is_floating_point<T>, floating_point_conversion_tag,

include/boost/json/impl/value_ref.hpp

@@ -10,46 +10,30 @@
 #ifndef BOOST_JSON_IMPL_VALUE_REF_HPP
 #define BOOST_JSON_IMPL_VALUE_REF_HPP
 
+#include <boost/json/value_from.hpp>
+
 namespace boost {
 namespace json {
 
 template<class T>
 value
-value_ref::
-from_builtin(
-    void const* p,
-    storage_ptr sp) noexcept
+value_ref::from_builtin(void const* p, storage_ptr sp) noexcept
 {
-    return value(
-        *reinterpret_cast<
-            T const*>(p),
-        std::move(sp));
+    return value( *reinterpret_cast<T const*>(p), std::move(sp) );
 }
 
 template<class T>
 value
-value_ref::
-from_const(
-    void const* p,
-    storage_ptr sp)
+value_ref::from_const(void const* p, storage_ptr sp)
 {
-    return value(
-        *reinterpret_cast<
-            T const*>(p),
-        std::move(sp));
+    return value_from( *reinterpret_cast<T const*>(p), std::move(sp) );
 }
 
 template<class T>
 value
-value_ref::
-from_rvalue(
-    void* p,
-    storage_ptr sp)
+value_ref::from_rvalue(void* p, storage_ptr sp)
 {
-    return value(
-        std::move(
-            *reinterpret_cast<T*>(p)),
-        std::move(sp));
+    return value_from( std::move(*reinterpret_cast<T*>(p)), std::move(sp) );
 }
 
 } // namespace json

test/snippets.cpp

@@ -616,6 +616,20 @@ usingInitLists()
 
         (void)jo2;
     }
+
+    {
+        // tag::snippet_init_list_10[]
+
+        value jv = { { "fibs", std::vector<int>{1,2,3,5,8} } };
+
+        array& fibs = jv.at("fibs").as_array();
+
+        assert(( fibs == array{1,2,3,5,8} ));
+
+        // end::snippet_init_list_10[]
+
+        (void)fibs;
+    }
 }
 
 //----------------------------------------------------------

test/value_ref.cpp

@@ -389,6 +389,27 @@ class value_ref_test
         }
     }
 
+    void
+    testAutoConversion()
+    {
+        value jv = { 1, false, std::vector<int>{1,2,3} };
+        auto& ja = jv.as_array();
+        BOOST_TEST(ja.size() == 3);
+        BOOST_TEST(ja[0] == 1);
+        BOOST_TEST(ja[1] == false);
+        BOOST_TEST(( ja[2].as_array() == array{1,2,3} ));
+
+        jv = { {"a", std::vector<int>{1,2,3}}, {"b", std::string("foo")} };
+        auto& jo = jv.as_object();
+        BOOST_TEST(jo.size() == 2);
+        BOOST_TEST(( jo["a"] == array{1,2,3} ));
+        BOOST_TEST(( jo["b"] == "foo" ));
+
+        jv = {std::string("bar")};
+        BOOST_TEST( jv.is_string() );
+        BOOST_TEST(( jv == "bar" ));
+    }
+
     void
     run()
     {
@@ -397,6 +418,7 @@ class value_ref_test
         testMakeValue();
         testObjects();
         testMoveFrom();
+        testAutoConversion();
     }
 };