tested map of floats (#48)

Author: mristin

test_cases/general/map/of/float/cpp/live_test_generate_jsoncpp/example_ok/expected.err

@@ -0,0 +1,6 @@
+{
+    "map_of_floats": 
+    {
+        "some-key": 1.1000000000000001
+    }
+}

test_cases/general/map/of/float/cpp/live_test_generate_jsoncpp/example_ok/expected.out

@@ -0,0 +1,160 @@
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!
+
+#include "jsoncpp.h"
+#include "parse.h"
+#include "types.h"
+
+#include <cstring>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+namespace some {
+namespace graph {
+
+namespace jsoncpp {
+
+/**
+ * generates an error message.
+ *
+ * @param cc char array as the description part of the message
+ * @param cc_size size of the char array
+ * @param s string as the detail part of the message
+ * @return concatenated string
+ */
+std::string message(const char* cc, size_t cc_size, std::string s) {
+  std::string result;
+  result.reserve(cc_size + s.size());
+  result.append(cc, cc_size);
+  result.append(s);
+  return result;
+}
+
+/**
+ * converts a JSON value type to a human-readable string representation.
+ *
+ * @param value_type to be converted
+ * @return string representation of the JSON value type
+ */
+std::string value_type_to_string(Json::ValueType value_type) {
+  switch (value_type) {
+    case Json::ValueType::nullValue: return "null";
+    case Json::ValueType::intValue: return "int";
+    case Json::ValueType::uintValue: return "uint";
+    case Json::ValueType::realValue: return "real";
+    case Json::ValueType::stringValue: return "string";
+    case Json::ValueType::booleanValue: return "bool";
+    case Json::ValueType::arrayValue: return "array";
+    case Json::ValueType::objectValue: return "object";
+    default:
+      std::stringstream ss;
+      ss << "Unhandled value type in value_to_string: "
+        << value_type;
+      throw std::domain_error(ss.str());
+  }
+}
+
+void some_graph_from(
+    const Json::Value& value,
+    std::string ref,
+    SomeGraph* target,
+    parse::Errors* errors) {
+  if (errors == nullptr) {
+    throw std::invalid_argument("Unexpected null errors");
+  }
+
+  if (not errors->empty()) {
+    throw std::invalid_argument("Unexpected non-empty errors");
+  }
+
+  if (not value.isObject()) {
+    constexpr auto expected_but_got(
+      "Expected an object, but got: ");
+
+    errors->add(
+      ref,
+      message(
+        expected_but_got,
+        strlen(expected_but_got),
+        value_type_to_string(
+          value.type())));
+    return;
+  }
+
+  ////
+  // Parse map_of_floats
+  ////
+
+  if (not value.isMember("map_of_floats")) {
+    errors->add(
+      ref,
+      "Property is missing: map_of_floats");
+  } else {
+    const Json::Value& value_0 = value["map_of_floats"];
+    if (not value_0.isObject()) {
+      constexpr auto expected_but_got(
+        "Expected an object, but got: ");
+
+      errors->add(
+        std::string(ref)
+          .append("/map_of_floats"),
+        message(
+          expected_but_got,
+          strlen(expected_but_got),
+          value_type_to_string(
+            value_0.type())));
+    } else {
+      std::map<std::string, double>& target_0 = target->map_of_floats;
+      for (Json::ValueConstIterator it_0 = value_0.begin(); it_0 != value_0.end(); ++it_0) {
+        const Json::Value& value_1 = *it_0;
+        if (not value_1.isDouble()) {
+          constexpr auto expected_but_got(
+            "Expected a double, but got: ");
+
+          errors->add(
+            std::string(ref)
+              .append("/map_of_floats")
+              .append("/")
+              .append(it_0.name()),
+            message(
+              expected_but_got,
+              strlen(expected_but_got),
+              value_type_to_string(
+                value_1.type())));
+        } else {
+          target_0[it_0.name()] = value_1.asDouble();
+        }
+
+        if (errors->full()) {
+          break;
+        }
+      }
+    }
+  }
+  if (errors->full()) {
+    return;
+  }
+}
+
+Json::Value serialize_some_graph(
+    const SomeGraph& some_graph) {
+  Json::Value some_graph_as_value;
+
+  Json::Value target_0(Json::objectValue);
+  const auto& map_0 = some_graph.map_of_floats;
+  for (const auto& kv_0 : map_0) {
+    target_0[kv_0.first] = kv_0.second;
+  }
+  some_graph_as_value["map_of_floats"] = std::move(target_0);
+
+  return some_graph_as_value;
+}
+
+}  // namespace jsoncpp
+
+}  // namespace graph
+}  // namespace some
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!

test_cases/general/map/of/float/cpp/test_generate/jsoncpp.cpp

@@ -0,0 +1,46 @@
+#pragma once
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!
+
+#include <json/json.h>  // jsoncpp
+
+
+
+#include "parse.h"
+#include "types.h"
+
+namespace some {
+namespace graph {
+
+namespace jsoncpp {
+
+/**
+ * parses SomeGraph from a JSON value.
+ *
+ * @param [in] value to be parsed
+ * @param [in] ref reference to the value (e.g., a reference path)
+ * @param [out] target parsed SomeGraph
+ * @param [out] errors encountered during parsing
+ */
+void some_graph_from(
+  const Json::Value& value,
+  std::string ref,
+  SomeGraph* target,
+  parse::Errors* errors);
+
+
+/**
+ * serializes SomeGraph to a JSON value.
+ *
+ * @param some_graph to be serialized
+ * @return JSON value
+ */
+Json::Value serialize_some_graph(
+  const SomeGraph& some_graph);
+
+}  // namespace jsoncpp
+
+}  // namespace graph
+}  // namespace some
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!

test_cases/general/map/of/float/cpp/test_generate/jsoncpp.h

@@ -0,0 +1,42 @@
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!
+
+#include "parse.h"
+
+#include <string>
+#include <vector>
+
+namespace some {
+namespace graph {
+
+namespace parse {
+
+Errors::Errors(size_t cap) : cap_(cap) {}
+
+void Errors::reserve(size_t expected_errors) {
+  errors_.reserve(expected_errors);
+}
+
+void Errors::add(const std::string& ref, const std::string& message) {
+  if (errors_.size() < cap_) {
+    errors_.emplace_back(Error{.ref = ref, .message = message});
+  }
+}
+
+bool Errors::full() const {
+  return errors_.size() == cap_;
+}
+
+bool Errors::empty() const {
+  return errors_.empty();
+}
+
+const std::vector<Error>& Errors::get() const {
+  return errors_;
+}
+
+}  // namespace parse
+
+}  // namespace graph
+}  // namespace some
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!

test_cases/general/map/of/float/cpp/test_generate/parse.cpp

@@ -0,0 +1,72 @@
+#pragma once
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!
+
+#include <string>
+#include <vector>
+
+namespace some {
+namespace graph {
+
+namespace parse {
+
+/**
+ * represents an error occurred while parsing.
+ */
+struct Error {
+  // references the cause (e.g., a reference path).
+  const std::string ref;
+
+  // describes the error.
+  const std::string message;
+};
+
+/**
+ * collects errors capped at a certain quantity.
+ *
+ * The space for the errors will not be reserved.
+ * Make sure you reserve the necessary space by calling reserve()
+ * at the initialization.
+ */
+class Errors {
+public:
+  explicit Errors(size_t cap);
+
+  /**
+   * reserves the space for the errors.
+   *
+   * You need to reserve the space only if you think there will
+   * be an excessive amount of errors (e.g., >1000).
+   */
+   void reserve(size_t expected_errors);
+
+  /**
+   * adds an error to the container.
+   *
+   * If the container is already full, the error is ignored.
+   */
+  void add(const std::string& ref, const std::string& message);
+
+  /**
+   * @return true when there are exactly cap errors.
+   */
+  bool full() const;
+
+  /**
+   * @return true when there are no errors.
+   */
+  bool empty() const;
+
+  const std::vector<Error>& get() const;
+
+private:
+  const size_t cap_;
+  std::vector<Error> errors_;
+};
+
+}  // namespace parse
+
+}  // namespace graph
+}  // namespace some
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!

test_cases/general/map/of/float/cpp/test_generate/parse.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!
+
+#include <map>
+
+namespace some {
+namespace graph {
+
+struct SomeGraph;
+
+// defines some object graph.
+struct SomeGraph {
+  // tests a map of floats.
+  std::map<std::string, double> map_of_floats;
+};
+
+}  // namespace graph
+}  // namespace some
+
+// File automatically generated by mapry. DO NOT EDIT OR APPEND!

test_cases/general/map/of/float/cpp/test_generate/types.h

@@ -0,0 +1,5 @@
+{
+  "map_of_floats": {
+    "some-key": 1.1
+  }
+}

test_cases/general/map/of/float/example_ok.json

@@ -0,0 +1,5 @@
+{
+  "map_of_floats": {
+    "some-key": 1.1
+  }
+}