Json updates (#37)

* Provide json_encode for const char*

* json_encode for std::vector and std::map: propagate errors

* Implement json_encode for pointers and std::array

Testing revealed difficulties regarding extending json_encode with
user-defined types. In the following chain of calls:

    struct S { ... };
    json_encode(std::string,  std::vector<std::array<S, 6>>); // 1
    json_encode(std::ostream, std::vector<std::array<S, 6>>); // 2
    json_encode(std::ostream, std::array<S, 6>*, ...); // 3
    json_encode(std::ostream, std::array<S, 6>); // 4
    json_encode(std::ostream, S*); // 5
    json_encode(std::ostream, S); // 6, implemented in the user code

the compiler might only be able to find the user function if it was
called with unqualified names and argument-dependent lookup took
action. Also, without forward declarations provided by this patch the
compiler could not reach step 4 since json_encode for array has been
declared after json_encode for pointers. This suggests possible problems
with user and other STL containers. See

https://stackoverflow.com/questions/28187170/c-enforce-second-pass-name-lookup-in-template-function
https://akrzemi1.wordpress.com/2015/11/19/overload-resolution/

for the discussion.

One possible solution is to declare

    template <typename T> void json_encode(std::ostream&, const T&);

and use template specializations instead of overloaded functions, but it
needs special casing to exclude arithmetic types implemented by a
different template --- and possibly it may clash in a similar way with
other user defined types.

* Implement json_encode_object

---------

Co-authored-by: Evgenii Zhemchugov <[email protected]>

Author: jini-zh

src/Store/Json.cpp

@@ -2,14 +2,18 @@
 
 namespace ToolFramework {
 
-bool json_encode(std::ostream& output, const std::string& datum) {
+bool json_encode(std::ostream& output, const char* datum) {
   output << '"';
-  for (char c : datum) {
-    if (c == '"' || c == '\\') output << '\\';
-    output << c;
+  while (*datum) {
+    if (*datum == '"' || *datum == '\\') output << '\\';
+    output << *datum;
   };
   output << '"';
   return true;
-}
+};
+
+bool json_encode(std::ostream& output, const std::string& datum) {
+  return json_encode(output, datum.c_str());
+};
 
 }

src/Store/Json.h

@@ -10,29 +10,48 @@
 
 namespace ToolFramework {
 
+template <typename T, size_t N>
+bool json_encode(std::ostream&, const std::array<T, N>&);
+
+template <typename T>
+bool json_encode(std::ostream&, const std::vector<T>&);
+
+template <typename T>
+bool json_encode(std::ostream&, const std::map<std::string, T>&);
+
 template <typename T>
 typename std::enable_if<std::is_arithmetic<T>::value, bool>::type
 json_encode(std::ostream& output, T datum) {
   output << datum;
   return true;
 }
 
+bool json_encode(std::ostream& output, const char* datum);
 bool json_encode(std::ostream& output, const std::string& datum);
 
 template <typename T>
-bool json_encode(std::ostream& output, const std::vector<T>& data) {
+bool json_encode(std::ostream& output, const T* data, size_t size) {
   output << '[';
   bool comma = false;
-  for (const T& datum : data) {
+  for (size_t i = 0; i < size; ++i) {
     if (comma)
       output << ',';
-    else
-      comma = true;
-    json_encode(output, datum);
+    comma = true;
+    if (!json_encode(output, data[i])) return false;
   };
   output << ']';
   return true;
-}
+};
+
+template <typename T, size_t N>
+bool json_encode(std::ostream& output, const std::array<T, N>& array) {
+  return json_encode(output, array.data(), array.size());
+};
+
+template <typename T>
+bool json_encode(std::ostream& output, const std::vector<T>& vector) {
+  return json_encode(output, vector.data(), vector.size());
+};
 
 template <typename T>
 bool json_encode(std::ostream& output, const std::map<std::string, T>& data) {
@@ -43,9 +62,9 @@ bool json_encode(std::ostream& output, const std::map<std::string, T>& data) {
       output << ',';
     else
       comma = true;
-    json_encode(output, datum.first);
+    if (!json_encode(output, datum.first)) return false;
     output << ':';
-    json_encode(output, datum.second);
+    if (!json_encode(output, datum.second)) return false;
   };
   output << '}';
   return true;
@@ -59,6 +78,54 @@ bool json_encode(std::string& output, T data) {
   return true;
 }
 
+namespace json_internal {
+
+  inline bool json_encode_object_slots(std::ostream& output, bool& comma) {
+    return true;
+  };
+
+  template <typename Slot, typename... Rest>
+  bool json_encode_object_slots(
+      std::ostream& output,
+      bool& comma,
+      const char* name,
+      const Slot& slot,
+      Rest... rest
+  ) {
+    if (comma) output << ',';
+    comma = true;
+    output << '"' << name << '"' << ':';
+    if (!json_encode(output, slot)) return false;
+    return json_encode_object_slots(output, comma, rest...);
+  };
+
+  template <typename Slot, typename... Rest>
+  bool json_encode_object_slots(
+      std::ostream& output,
+      bool& comma,
+      const std::string& name,
+      const Slot& slot,
+      Rest... rest
+  ) {
+    return json_encode_object_slots(output, comma, name.c_str(), slot, rest...);
+  };
+
+}; // json_internal
+
+
+// A helper function to write fixed-size objects
+// Example: call `json_encode_object(output, "x", 42, "a", false)`
+// to produce `{"x":42,"a":false}`
+template <typename... Args>
+bool json_encode_object(std::ostream& output, Args... args) {
+  output << '{';
+  bool comma = false;
+  if (!json_internal::json_encode_object_slots(output, comma, args...))
+    return false;
+  output << '}';
+  return true;
 }
 
+}; // ToolFramework
+
 #endif