Merge pull request #37 from simdjson/using_reflection_for_simdjson_ondemand_daniel

Using reflection for simdjson ondemand daniel

Author: FranciscoThiesen

examples/CMakeLists.txt

@@ -4,8 +4,8 @@ add_compile_options(-Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strin
 add_executable(example example.cpp)
 target_link_libraries(example PRIVATE simdjson::serialization simdjson::simdjson)
 
-add_executable(example2 example2.cpp)
-target_link_libraries(example2 PRIVATE simdjson::serialization simdjson::simdjson)
+#add_executable(example2 example2.cpp)
+#target_link_libraries(example2 PRIVATE simdjson::serialization simdjson::simdjson)
 
 add_executable(example3 example3.cpp)
 target_link_libraries(example3 PRIVATE simdjson::serialization simdjson::simdjson)

examples/example3.cpp

@@ -1,5 +1,6 @@
 #include "simdjson.h"
 #include "simdjson/json_builder/json_builder.h"
+#include <cstdlib>
 #include <string>
 #include <vector>
 #include <iostream>
@@ -68,8 +69,14 @@ tag_invoke(deserialize_tag, std::type_identity<T>, ondemand::value &val) {
   return vec;
 } 
 
+
+///
+/// For simplicity, the definitions of invoke should be non-overlapping.
+/// If we provide both a specialization for a container and a specialization for a user-defined type,
+/// which one gets picked is maybe unclear???
+/// 
 template <typename T>
-  requires json_builder::UserDefinedType<T>
+  requires (json_builder::UserDefinedType<T> && ! PushableContainer<T>)
 simdjson_result<T>
 tag_invoke(deserialize_tag, std::type_identity<T>, ondemand::value &val) {
   ondemand::object obj;
@@ -79,27 +86,17 @@ tag_invoke(deserialize_tag, std::type_identity<T>, ondemand::value &val) {
   }
   T t;
   [:json_builder::expand(std::meta::nonstatic_data_members_of(^T)):] >> [&]<auto mem> {
-    auto it = obj[to_string_view(std::meta::identifier_of(mem))];
+    auto it = obj[(std::string_view)std::meta::identifier_of(mem)];
     using MemberType = typename std::remove_reference_t<decltype(t.[:mem:])>;
 
     if constexpr (std::is_same_v<MemberType, int>) {
-      auto int_result = it.get_int64();
-      if (int_result.error()) throw std::runtime_error("Error getting int64");
-      t.[:mem:] = static_cast<int>(int_result.value());
-    } else if constexpr (std::is_same_v<MemberType, double>) {
-      auto double_result = it.get_double();
-      if (double_result.error()) throw std::runtime_error("Error getting double");
-      t.[:mem:] = double_result.value();
+      int64_t val;
+      if(auto err = it.get(val); err) { return err; }
+      t.[:mem:] = static_cast<int>(val);
     } else if constexpr (std::is_same_v<MemberType, std::string>) {
-      auto string_result = it.get_string();
-      if (string_result.error()) throw std::runtime_error("Error getting string");
-      t.[:mem:] = std::string(string_result.value());
-    } else if constexpr (std::is_same_v<MemberType, bool>) {
-      auto bool_result = it.get_bool();
-      if (bool_result.error()) throw std::runtime_error("Error getting bool");
-      t.[:mem:] = bool_result.value();
+      if(auto err = it.get_string(t.[:mem:]); err) { return err; }
     } else {
-      t.[:mem:] = it.template get<MemberType>().value();
+      if(auto err = it.get(t.[:mem:]); err) { return err; }
     }
   };
   return t;
@@ -112,34 +109,33 @@ int main() {
   std::string json_str = R"({"values": [1, 2, 3]})";
   ondemand::parser parser;
   auto doc = parser.iterate(json_str);
-
-  auto result = doc["values"].get<std::vector<int>>();
-  if (result.error()) {
-    std::cerr << "Error parsing JSON: " << result.error() << std::endl;
-    return 1;
+  std::vector<int> result;
+  if(auto err = doc["values"].get<std::vector<int>>().get(result); err) {
+    std::cerr << "Error parsing JSON: " << simdjson::error_message(err) << std::endl;
+    return EXIT_FAILURE;
   }
-
-  std::vector<int> z = result.value();
-  for (const int &x : z) {
+  for (const int x : result) {
     std::cout << x << std::endl;
   }
 
-  // Test for user-defined type MyStruct
-  std::string json_str3 = R"({"id": 1, "name": "example", "values": [1, 2, 3]})";
+  /////////////
+  /// Notice how we won't parse directly the *document* but a value inside the document.
+  /// That's because the document is not an instance of a value in simdjson, and so the
+  /// current patch would require a bit of extra work to make it work with both values
+  /// and documents
+  //////////////
+  std::string json_str3 = R"({"toto":{"id": 1, "name": "example", "values": [4, 42, 43]}})";
   ondemand::parser parser3;
   auto doc3 = parser3.iterate(json_str3);
 
-  auto result3 = doc3.get<MyStruct>();
-  if (result3.error()) {
-    std::cerr << "Error parsing JSON: " << result3.error() << std::endl;
-    return 1;
+  MyStruct result3;
+  if(auto err = doc3["toto"].get(result3); err) {
+    std::cerr << "Error parsing JSON: " << simdjson::error_message(err) << std::endl;
+    return EXIT_FAILURE;
   }
-
-  MyStruct my_struct = result3.value();
-  std::cout << "ID: " << my_struct.id << ", Name: " << my_struct.name << ", Values: ";
-  for (const int &x : my_struct.values) {
-    std::cout << x << " ";
+  std::cout << "ID: " << result3.id << ", Name: " << result3.name ;
+  for (const int x : result3.values) {
+    std::cout << x << std::endl;
   }
-  std::cout << std::endl;
-  return 0;
+  return EXIT_SUCCESS;
 }