Merge pull request #141 from rschlaikjer/rs-support-unordered-map

Add support for unordered_map, deque JSON Ser/Des

Author: ziyan

include/mujincontrollerclient/mujinjson.h

@@ -27,7 +27,9 @@
 #include <string>
 #include <stdexcept>
 #include <vector>
+#include <unordered_map>
 #include <map>
+#include <deque>
 #include <iostream>
 
 #include <rapidjson/pointer.h>
@@ -206,7 +208,7 @@ inline void ParseJson(rapidjson::Value& r, rapidjson::Document::AllocatorType& a
         throw MujinJSONException(boost::str(boost::format("Json stream is invalid (offset %u) %s")%((unsigned)rTemp.GetErrorOffset())%GetParseError_En(rTemp.GetParseError())));
     }
     r.Swap(rTemp);
-    
+
 //    rapidjson::ParseResult parseResult = reader.template Parse<rapidjson::kParseFullPrecisionFlag>(isw, rTemp);
 //    if( parseResult.IsError() ) {
 //        *stack_.template Pop<ValueType>(1)
@@ -490,17 +492,60 @@ template<class U> inline void LoadJsonValue(const rapidjson::Value& v, std::map<
         }
     } else if (v.IsObject()) {
         t.clear();
-        U value;
         for (rapidjson::Value::ConstMemberIterator it = v.MemberBegin();
              it != v.MemberEnd(); ++it) {
-            LoadJsonValue(it->value, value);
-            t[std::string(it->name.GetString(), it->name.GetStringLength())] = value; // string can contain null character
+            // Deserialize directly into the map to avoid copying temporaries.
+            // Note that our key needs to be explicitly length-constructed since
+            // it may contain \0 bytes.
+            LoadJsonValue(it->value,
+                          t[std::string(it->name.GetString(),
+                                        it->name.GetStringLength())]);
         }
     } else {
         throw MujinJSONException("Cannot convert json type " + GetJsonTypeName(v) + " to Map");
     }
 }
 
+template<class U> inline void LoadJsonValue(const rapidjson::Value& v, std::deque<U>& t) {
+    // It doesn't make sense to construct a deque from anything other than a JSON array
+    if (!v.IsArray()) {
+        throw MujinJSONException("Cannot convert json type " + GetJsonTypeName(v) + " to deque");
+    }
+
+    // Ensure our output is a blank slate
+    t.clear();
+
+    // Preallocate to fit the incoming data. Deque has no reserve, only resize.
+    t.resize(v.Size());
+
+    // Iterate each array entry and attempt to deserialize it directly as a member type
+    typename std::deque<U>::size_type emplaceIndex = 0;
+    for (rapidjson::Value::ConstValueIterator it = v.Begin(); it != v.End(); ++it) {
+        // Deserialize directly into the map to avoid copying temporaries.
+        LoadJsonValue(*it, t[emplaceIndex++]);
+    }
+}
+
+template<class U> inline void LoadJsonValue(const rapidjson::Value& v, std::unordered_map<std::string, U>& t) {
+    // It doesn't make sense to construct an unordered map from anything other
+    // than a full JSON object
+    if (!v.IsObject()) {
+        throw MujinJSONException("Cannot convert json type " + GetJsonTypeName(v) + " to unordered_map");
+    }
+
+    // Ensure our output is a blank slate
+    t.clear();
+    for (rapidjson::Value::ConstMemberIterator it = v.MemberBegin();
+         it != v.MemberEnd(); ++it) {
+        // Deserialize directly into the map to avoid copying temporaries.
+        // Note that our key needs to be explicitly length-constructed since it
+        // may contain \0 bytes.
+        LoadJsonValue(
+            it->value,
+            t[std::string(it->name.GetString(), it->name.GetStringLength())]);
+    }
+}
+
 //Save a data structure to rapidjson::Value format
 
 /*template<class T> inline void SaveJsonValue(rapidjson::Value& v, const T& t, rapidjson::Document::AllocatorType& alloc) {*/
@@ -650,6 +695,26 @@ template<class U> inline void SaveJsonValue(rapidjson::Value& v, const std::map<
     }
 }
 
+template<class U> inline void SaveJsonValue(rapidjson::Value& v, const std::unordered_map<std::string, U>& t, rapidjson::Document::AllocatorType& alloc) {
+    v.SetObject();
+    for (typename std::unordered_map<std::string, U>::const_iterator it = t.begin(); it != t.end(); ++it) {
+        rapidjson::Value name, value;
+        SaveJsonValue(name, it->first, alloc);
+        SaveJsonValue(value, it->second, alloc);
+        v.AddMember(name, value, alloc);
+    }
+}
+
+template <class T, class AllocT> inline void SaveJsonValue(rapidjson::Value& v, const std::deque<T, AllocT>& t, rapidjson::Document::AllocatorType& alloc) {
+    v.SetArray();
+    v.Reserve(t.size(), alloc);
+    for (typename std::deque<T, AllocT>::const_iterator it = t.begin(); it != t.end(); ++it) {
+        rapidjson::Value value;
+        SaveJsonValue(value, *it, alloc);
+        v.PushBack(value, alloc);
+    }
+}
+
 template<class T> inline void SaveJsonValue(rapidjson::Document& v, const T& t) {
     // rapidjson::Value::CopyFrom also doesn't free up memory, need to clear memory
     // see note in: void ParseJson(rapidjson::Document& d, const std::string& str)