MyJansson small refactoring.

2 files changed, 67 insertions, 166 deletions

diff --git a/3party/jansson/myjansson.cpp b/3party/jansson/myjansson.cpp
index 18135740db..ed59a2c7a0 100644
--- a/3party/jansson/myjansson.cpp
+++ b/3party/jansson/myjansson.cpp
@@ -4,36 +4,6 @@
 
 using namespace std;
 
-namespace
-{
-template <typename T>
-void ReadIntegral(json_t * root, string const & field, T & result)
-{
-  static_assert(is_integral<T>::value, "T must be an integral type");
-
-  auto * val = my::GetJSONObligatoryField(root, field);
-  if (!json_is_number(val))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json number."));
-  result = static_cast<T>(json_integer_value(val));
-}
-
-template <typename T>
-void ReadIntegralOptional(json_t * root, string const & field, T & result)
-{
-  static_assert(is_integral<T>::value, "T must be an integral type");
-
-  auto * val = my::GetJSONOptionalField(root, field);
-  if (!val)
-  {
-    result = 0;
-    return;
-  }
-  if (!json_is_number(val))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json number."));
-  result = static_cast<T>(json_integer_value(val));
-}
-}  // namespace
-
 namespace my
 {
 json_t * GetJSONObligatoryField(json_t * root, std::string const & field)
@@ -54,120 +24,29 @@ json_t * GetJSONOptionalField(json_t * root, std::string const & field)
 bool JSONIsNull(json_t * root) { return json_is_null(root); }
 }  // namespace my
 
-void FromJSONObject(json_t * root, string const & field, double & result)
-{
-  auto * val = my::GetJSONObligatoryField(root, field);
-  if (!json_is_number(val))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json number."));
-  result = json_number_value(val);
-}
-
-void FromJSONObject(json_t * root, string const & field, int & result)
-{
-  ReadIntegral(root, field, result);
-}
-
-void FromJSONObject(json_t * root, string const & field, int64_t & result)
+void FromJSON(json_t * root, double & result)
 {
-  ReadIntegral(root, field, result);
+  if (!json_is_number(root))
+    MYTHROW(my::Json::Exception, ("Object must contain a json number."));
+  result = json_number_value(root);
 }
 
-void FromJSONObjectOptionalField(json_t * root, string const & field, int & result)
+void FromJSON(json_t * root, bool & result)
 {
-  ReadIntegralOptional(root, field, result);
+  if (!json_is_true(root) && !json_is_false(root) )
+    MYTHROW(my::Json::Exception, ("Object must contain a boolean value."));
+  result = json_is_true(root);
 }
 
-void FromJSONObjectOptionalField(json_t * root, string const & field, int64_t & result)
+namespace std
 {
-  ReadIntegralOptional(root, field, result);
-}
-
-void FromJSONObjectOptionalField(json_t * root, string const & field, double & result)
-{
-  json_t * val = my::GetJSONOptionalField(root, field);
-  if (!val)
-  {
-    result = 0.0;
-    return;
-  }
-  if (!json_is_number(val))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json number."));
-  result = json_number_value(val);
-}
-
-void FromJSONObjectOptionalField(json_t * root, string const & field, bool & result, bool def)
-{
-  json_t * val = my::GetJSONOptionalField(root, field);
-  if (!val)
-  {
-    result = def;
-    return;
-  }
-  if (!json_is_boolean(val))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a boolean value."));
-  result = json_is_true(val);
-}
-
-void FromJSONObjectOptionalField(json_t * root, string const & field, json_t *& result)
-{
-  json_t * obj = my::GetJSONOptionalField(root, field);
-  if (!obj)
-  {
-    result = nullptr;
-    return;
-  }
-  if (!json_is_object(obj))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json object."));
-  FromJSON(obj, result);
-}
-
-void ToJSONObject(json_t & root, string const & field, double value)
-{
-  json_object_set_new(&root, field.c_str(), json_real(value));
-}
-
-void ToJSONObject(json_t & root, string const & field, int value)
-{
-  ToJSONObject(root, field, static_cast<int64_t>(value));
-}
-
-void ToJSONObject(json_t & root, std::string const & field, int64_t value)
-{
-  json_object_set_new(&root, field.c_str(), json_integer(value));
-}
-
 void FromJSON(json_t * root, string & result)
 {
   if (!json_is_string(root))
     MYTHROW(my::Json::Exception, ("The field must contain a json string."));
   result = json_string_value(root);
 }
-
-void FromJSONObject(json_t * root, string const & field, string & result)
-{
-  auto * val = my::GetJSONObligatoryField(root, field);
-  if (!json_is_string(val))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json string."));
-  result = json_string_value(val);
-}
-
-void ToJSONObject(json_t & root, string const & field, string const & value)
-{
-  json_object_set_new(&root, field.c_str(), json_string(value.c_str()));
-}
-
-void FromJSONObjectOptionalField(json_t * root, string const & field, string & result)
-{
-  auto * val = my::GetJSONOptionalField(root, field);
-  if (!val || my::JSONIsNull(val))
-  {
-    result.clear();
-    return;
-  }
-  if (!json_is_string(val))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json string."));
-  result = json_string_value(val);
-}
+}  // namespace std
 
 namespace strings
 {
@@ -178,17 +57,5 @@ void FromJSON(json_t * root, UniString & result)
   result = MakeUniString(s);
 }
 
-my::JSONPtr ToJSON(UniString const & s) { return ::ToJSON(ToUtf8(s)); }
-
-void FromJSONObject(json_t * root, string const & field, UniString & result)
-{
-  string s;
-  FromJSONObject(root, field, s);
-  result = strings::MakeUniString(s);
-}
-
-void ToJSONObject(json_t & root, string const & field, UniString const & value)
-{
-  return ToJSONObject(root, field, strings::ToUtf8(value));
-}
+my::JSONPtr ToJSON(UniString const & s) { return ToJSON(ToUtf8(s)); }
 }  // namespace strings
diff --git a/3party/jansson/myjansson.hpp b/3party/jansson/myjansson.hpp
index 1e4673a07f..8a6aa4f3c9 100644
--- a/3party/jansson/myjansson.hpp
+++ b/3party/jansson/myjansson.hpp
@@ -24,6 +24,10 @@ using JSONPtr = std::unique_ptr<json_t, JSONDecRef>;
 inline JSONPtr NewJSONObject() { return JSONPtr(json_object()); }
 inline JSONPtr NewJSONArray() { return JSONPtr(json_array()); }
 inline JSONPtr NewJSONString(std::string const & s) { return JSONPtr(json_string(s.c_str())); }
+inline JSONPtr NewJSONInt(json_int_t value) { return JSONPtr(json_integer(value)); }
+inline JSONPtr NewJSONReal(double value) { return JSONPtr(json_real(value)); }
+inline JSONPtr NewJSONBool(bool value) { return JSONPtr(value ? json_true() : json_false()); }
+inline JSONPtr NewJSONNull() { return JSONPtr(json_null()); }
 
 class Json
 {
@@ -50,26 +54,55 @@ bool JSONIsNull(json_t * root);
 
 inline void FromJSON(json_t * root, json_t *& value) { value = root; }
 
-void FromJSONObject(json_t * root, std::string const & field, double & result);
-void FromJSONObject(json_t * root, std::string const & field, int & result);
-void FromJSONObject(json_t * root, std::string const & field, int64_t & result);
+void FromJSON(json_t * root, double & result);
+void FromJSON(json_t * root, bool & result);
 
-void FromJSONObjectOptionalField(json_t * root, std::string const & field, int & result);
-void FromJSONObjectOptionalField(json_t * root, std::string const & field, int64_t & result);
-void FromJSONObjectOptionalField(json_t * root, std::string const & field, double & result);
-void FromJSONObjectOptionalField(json_t * root, std::string const & field, bool & result,
-                                 bool def = false);
-void FromJSONObjectOptionalField(json_t * root, std::string const & field, json_t *& result);
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value, void>::type* = nullptr>
+void FromJSON(json_t * root, T & result)
+{
+  if (!json_is_number(root))
+    MYTHROW(my::Json::Exception, ("Object must contain a json number."));
+  result = static_cast<T>(json_integer_value(root));
+}
 
-void ToJSONObject(json_t & root, std::string const & field, double value);
-void ToJSONObject(json_t & root, std::string const & field, int value);
-void ToJSONObject(json_t & root, std::string const & field, int64_t value);
+template <typename T>
+void FromJSONObject(json_t * root, std::string const & field, T & result)
+{
+  auto * json = my::GetJSONObligatoryField(root, field);
+  try
+  {
+    FromJSON(json, result);
+  }
+  catch (my::Json::Exception const & e)
+  {
+    MYTHROW(my::Json::Exception, ("An error occured while parsing field", field, e.Msg()));
+  }
+}
 
-void FromJSON(json_t * root, std::string & result);
-inline my::JSONPtr ToJSON(std::string const & s) { return my::NewJSONString(s); }
+template <typename T>
+void FromJSONObjectOptionalField(json_t * root, std::string const & field, T & result)
+{
+  auto * json = my::GetJSONOptionalField(root, field);
+  if (!json)
+  {
+    result = T{};
+    return;
+  }
+  FromJSON(json, result);
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value, void>::type* = nullptr>
+inline my::JSONPtr ToJSON(T value) { return my::NewJSONInt(value); }
+inline my::JSONPtr ToJSON(double value) { return my::NewJSONReal(value); }
+inline my::JSONPtr ToJSON(bool value) { return my::NewJSONBool(value); }
 
-void FromJSONObject(json_t * root, std::string const & field, std::string & result);
-void ToJSONObject(json_t & root, std::string const & field, std::string const & value);
+template <typename T>
+void ToJSONObject(json_t & root, std::string const & field, T const & value)
+{
+  json_object_set_new(&root, field.c_str(), ToJSON(value).release());
+}
 
 template <typename T>
 void FromJSONObject(json_t * root, std::string const & field, std::vector<T> & result)
@@ -116,8 +149,6 @@ void ToJSONObject(json_t & root, std::string const & field, std::vector<T> const
   json_object_set_new(&root, field.c_str(), arr.release());
 }
 
-void FromJSONObjectOptionalField(json_t * root, std::string const & field, std::string & result);
-
 template <typename T>
 void FromJSONObjectOptionalField(json_t * root, std::string const & field, std::vector<T> & result)
 {
@@ -140,11 +171,14 @@ struct JSONFreeDeleter
   void operator()(char * buffer) const { free(buffer); }
 };
 
+namespace std
+{
+void FromJSON(json_t * root, std::string & result);
+inline my::JSONPtr ToJSON(std::string const & s) { return my::NewJSONString(s); }
+}  // namespace std
+
 namespace strings
 {
 void FromJSON(json_t * root, UniString & result);
 my::JSONPtr ToJSON(UniString const & s);
-
-void FromJSONObject(json_t * root, std::string const & field, UniString & result);
-void ToJSONObject(json_t & root, std::string const & field, UniString const & value);
-}
+}  // namespace strings