1

include/json.hpp

@@ -271,6 +271,9 @@ class basic_value
     explicit operator long double() const { return as_long_double(); }
     explicit operator string_t() const { return as_string(); }
 
+    explicit operator basic_array<string_t>() const { return as_array(); }
+    explicit operator basic_object<string_t>() const { return as_object(); }
+
     template <typename value_t, template <typename...> typename collection_t = std::vector,
               typename _ = std::enable_if_t<utils::is_collection<collection_t<value_t>>>>
     explicit operator collection_t<value_t>() const
@@ -334,8 +337,8 @@ class basic_array
     basic_array(std::initializer_list<value_type> init_list);
     basic_array(typename raw_array::size_type size);
 
-    explicit basic_array(const basic_value<string_t>& val);
-    explicit basic_array(basic_value<string_t>&& val);
+    // explicit basic_array(const basic_value<string_t>& val);
+    // explicit basic_array(basic_value<string_t>&& val);
 
     template <typename collection_t,
               typename = std::enable_if_t<std::is_constructible_v<value_type, utils::range_value_t<collection_t>>>>
@@ -450,8 +453,10 @@ class basic_object
     basic_object(const basic_object<string_t>& rhs) = default;
     basic_object(basic_object<string_t>&& rhs) noexcept = default;
     basic_object(std::initializer_list<value_type> init_list);
-    explicit basic_object(const basic_value<string_t>& val);
-    explicit basic_object(basic_value<string_t>&& val);
+
+    // explicit basic_object(const basic_value<string_t>& val);
+    // explicit basic_object(basic_value<string_t>&& val);
+
     template <typename map_t,
               typename = std::enable_if_t<std::is_constructible_v<value_type, utils::range_value_t<map_t>>>>
     basic_object(map_t map) : _object_data(std::make_move_iterator(map.begin()), std::make_move_iterator(map.end()))
@@ -1428,14 +1433,14 @@ template <typename string_t>
 inline basic_array<string_t>::basic_array(typename raw_array::size_type size) : _array_data(size)
 {}
 
-template <typename string_t>
-inline basic_array<string_t>::basic_array(const basic_value<string_t>& val) : basic_array<string_t>(val.as_array())
-{}
-
-template <typename string_t>
-inline basic_array<string_t>::basic_array(basic_value<string_t>&& val)
-    : basic_array<string_t>(std::move(val.as_array()))
-{}
+// template <typename string_t>
+// inline basic_array<string_t>::basic_array(const basic_value<string_t>& val) : basic_array<string_t>(val.as_array())
+//{}
+//
+// template <typename string_t>
+// inline basic_array<string_t>::basic_array(basic_value<string_t>&& val)
+//     : basic_array<string_t>(std::move(val.as_array()))
+//{}
 
 template <typename string_t>
 inline void basic_array<string_t>::clear() noexcept
@@ -1768,14 +1773,15 @@ inline basic_object<string_t>::basic_object(std::initializer_list<value_type> in
     : _object_data(std::make_move_iterator(init_list.begin()), std::make_move_iterator(init_list.end()))
 {}
 
-template <typename string_t>
-inline basic_object<string_t>::basic_object(const basic_value<string_t>& val) : basic_object<string_t>(val.as_object())
-{}
-
-template <typename string_t>
-inline basic_object<string_t>::basic_object(basic_value<string_t>&& val)
-    : basic_object<string_t>(std::move(val.as_object()))
-{}
+// template <typename string_t>
+// inline basic_object<string_t>::basic_object(const basic_value<string_t>& val) :
+// basic_object<string_t>(val.as_object())
+//{}
+//
+// template <typename string_t>
+// inline basic_object<string_t>::basic_object(basic_value<string_t>&& val)
+//     : basic_object<string_t>(std::move(val.as_object()))
+//{}
 
 template <typename string_t>
 inline bool basic_object<string_t>::contains(const string_t& key) const

sample/sample.cpp

@@ -299,14 +299,41 @@ bool serializing()
 
 void test_jsonization()
 {
-    struct MyStruct : json::bind_helper
+    struct AAA
     {
-        int aaa = 100;
+        int a_i = 100;
 
-        MEO_JSONIZATION(aaa);
+        MEO_JSONIZATION(a_i);
+    };
+
+    struct MyStruct
+    {
+        std::vector<int> vec;
+        std::map<std::string, int> map;
+
+        int i = 0;
+        double d = 0;
+
+        AAA aaa;
+
+        MEO_JSONIZATION(vec, map, MEO_OPTIONAL i, MEO_OPTIONAL d, aaa);
     };
 
     MyStruct a;
-    auto j1 = a.operator json::object();
-    auto j2 = (json::object)a;  // error
+    a.vec = { 1, 2, 3 };
+    a.map = { { "key", 5 } };
+    a.i = 100;
+    a.d = 0.5;
+
+    json::object j = a.dump_to_json();
+    std::cout << j << std::endl;
+
+    // for test MEO_OPTIONAL
+    j.erase("i");
+
+    MyStruct b;
+    bool loaded = b.load_from_json(j);
+
+    std::cout << "loaded: " << loaded << std::endl;
+    std::cout << b.dump_to_json() << std::endl;
 }