Latest JSON (from other work); tweaked certain GNDStk codes as necessary.

Author: staleyLANL

autogen/json2class-fun.cpp

@@ -138,8 +138,10 @@ std::string replace(const std::string &str, const char from, const char to)
 // Stringify JSON
 std::string stringify(const json::value &j)
 {
-   const std::string tmp = j.dump();
-   return j.has<json::string>()
+   std::ostringstream oss;
+   j.write(oss);
+   const std::string tmp = oss.str();
+   return j.holds<json::string>()
       ? tmp.substr(1, tmp.size()-2)
       : tmp;
 }
@@ -235,8 +237,8 @@ const std::string &nameGNDS(
    // As-is, directly as stipulated in the key in the JSON spec, except
    // that we allow a "name" entry in the key's value to override the key.
    return keyval.second.has("name")
-      ? keyval.second["name"].get<json::string>()
-      : keyval.first;
+      ? (std::string &)keyval.second["name"].get<json::string>()
+      : (std::string &)keyval.first;
 }
 
 // nameField
@@ -376,7 +378,7 @@ void getClassMetadata(
    for (const auto &field : j) {
       if (beginsin(field.first, "//"))
          continue;
-      if (!field.second.has<json::object>())
+      if (!field.second.holds<json::object>())
          continue;
       const json::object &metaRHS = field.second.get<json::object>();
 
@@ -395,7 +397,7 @@ void getClassMetadata(
 
       // Has default?
       m.defaultValue = "";
-      if (metaRHS.has("default") && !metaRHS["default"].is_null()) {
+      if (metaRHS.has("default") && !metaRHS["default"].holds<json::null>()) {
          m.defaultValue = stringify(metaRHS["default"]);
          // Apply the "changes.json" change, if any, to the given value
          const auto it = specs.mapMetaDefault.find(m.defaultValue);
@@ -452,7 +454,7 @@ void getClassChildren(
    for (const auto &field : j) {
       if (beginsin(field.first, "//"))
          continue;
-      if (!field.second.has<json::object>())
+      if (!field.second.holds<json::object>())
          continue;
       const json::object &elemRHS = field.second.get<json::object>();
 
@@ -549,7 +551,7 @@ void getClassVariants(
          continue;
 
       // Is it a choice child?
-      if (!field.second.has<json::object>())
+      if (!field.second.holds<json::object>())
          continue;
       const json::object &elemRHS = field.second.get<json::object>();
       const std::string &times = getTimes(per,field.first,elemRHS);
@@ -569,7 +571,7 @@ void getClassVariants(
          continue;
 
       // Is it a choice child?
-      if (!field.second.has<json::object>())
+      if (!field.second.holds<json::object>())
          continue;
       const json::object &elemRHS = field.second.get<json::object>();
       const std::string &times = getTimes(per,field.first,elemRHS);
@@ -712,7 +714,7 @@ void readChangesFile(const std::string &file, InfoSpecs &specs)
 
    // Changes to name?
    if (jchanges.has("name"))
-      for (const auto &item : jchanges["name"].items())
+      for (const auto &item : jchanges["name"].pairs())
          if (!isComment(item.first))
             specs.mapName.insert(
                pair(item.first, item.second.get<json::string>())
@@ -723,14 +725,14 @@ void readChangesFile(const std::string &file, InfoSpecs &specs)
 
    // from/to pairs for "type"
    if (metadata.has("type"))
-      for (const auto &item : metadata["type"].items())
+      for (const auto &item : metadata["type"].pairs())
          if (!isComment(item.first))
             specs.mapMetaType.insert(
                pair(item.first,item.second.get<json::string>())
             );
    // from/to pairs for "default"
    if (metadata.has("default"))
-      for (const auto &item : metadata["default"].items())
+      for (const auto &item : metadata["default"].pairs())
          if (!isComment(item.first))
             specs.mapMetaDefault.insert(
                pair(item.first,item.second.get<json::string>())
@@ -749,17 +751,17 @@ void printSingletons(const std::string &file)
    for (const auto &item : jfile) {
       if (beginsin(item.first, "//"))
          continue;
-      if (!item.second.has<json::object>())
+      if (!item.second.holds<json::object>())
          continue;
       const json::object &rhs = item.second.get<json::object>();
 
       if (!isClass(item))
          continue;
 
       const bool hasdata =
-         (rhs.has("string"  ) && !rhs["string"  ].is_null()) ||
-         (rhs.has("vector"  ) && !rhs["vector"  ].is_null()) ||
-         (rhs.has("bodyText") && !rhs["bodyText"].is_null());
+         (rhs.has("string"  ) && !rhs["string"  ].holds<json::null>()) ||
+         (rhs.has("vector"  ) && !rhs["vector"  ].holds<json::null>()) ||
+         (rhs.has("bodyText") && !rhs["bodyText"].holds<json::null>());
 
       const json::object metadata = getMetadataJSON(rhs);
       const json::object children = getChildrenJSON(rhs);
@@ -1114,9 +1116,9 @@ void getClass(
 
    // data-node information
    const bool
-      str  = classRHS.has("string"  ) && !classRHS["string"  ].is_null(),
-      vec  = classRHS.has("vector"  ) && !classRHS["vector"  ].is_null(),
-      body = classRHS.has("bodyText") && !classRHS["bodyText"].is_null();
+      str  = classRHS.has("string"  ) && !classRHS["string"  ].holds<json::null>(),
+      vec  = classRHS.has("vector"  ) && !classRHS["vector"  ].holds<json::null>(),
+      body = classRHS.has("bodyText") && !classRHS["bodyText"].holds<json::null>();
    assert(int(str) + int(vec) + int(body) <= 1); // no more than one
 
    per.isDataString = str;

simple-json/src/json-array.hpp

@@ -6,6 +6,7 @@
 
 class array : public std::vector<value> {
 public:
+   JSON_IO(array);
 
    // ------------------------
    // Construction
@@ -18,7 +19,7 @@ class array : public std::vector<value> {
    array(const vector &from) : vector(from) { }
    array(vector &&from) : vector(std::move(from)) { }
 
-   // constructor: from std::vector<T convertible to value>
+   // from std::vector<T convertible to value>
    template<class T, class = require<convertible<T,value>>>
    array(const std::vector<T> &from) :
       vector(from.begin(), from.end())
@@ -31,17 +32,14 @@ class array : public std::vector<value> {
    template<class T, class = require<assignable<vector, T &&>>>
    array &operator=(T &&from)
    {
-      vector::operator=(std::forward<T>(from));
-      return *this;
+      return vector::operator=(std::forward<T>(from)), *this;
    }
 
    // ------------------------
-   // read, write
+   // Other
    // ------------------------
 
-   template<class T = void, class U = void>
-   auto /* std::string */ read(std::istream &is, const int = as_literal::none)
-      -> decltype(number().read<T,U>(is,0)); // SFINAE: need number::read<T,U>
-
-   void write(std::ostream & = std::cout, const int = 0, const int = -1) const;
+   // values
+   const std::vector<value> &values() const { return *this; }
+   std::vector<value> &values() { return *this; }
 };

simple-json/src/json-boolean.hpp

@@ -8,6 +8,7 @@ class boolean {
    bool b;
 
 public:
+   JSON_IO(boolean);
 
    // ------------------------
    // Construction
@@ -26,14 +27,5 @@ class boolean {
 
    // to bool
    operator const bool &() const { return b; }
-   operator       bool &()       { return b; }
-
-   // ------------------------
-   // read, write
-   // ------------------------
-
-   template<class T = void, class U = void>
-   std::string read(std::istream &, const int = as_literal::none);
-
-   void write(std::ostream & = std::cout, const int = 0, const int = -1) const;
+   operator bool &() { return b; }
 };

simple-json/src/json-chars.hpp

@@ -3,22 +3,12 @@
 // chars
 // -----------------------------------------------------------------------------
 
-// Remark. <charconv> is supposed to have:
-//    enum class chars_format {
-//       scientific = ...,
-//       fixed = ...,
-//       hex = ...,
-//       general = fixed | scientific
-//    };
-// At the time of this writing, g++ appears to have it, but clang++ does not.
-
-template<class = JSON_FLOATING>
 class chars {
    std::string str;
 
    // SIZE here is overkill, but should be adequate
-   static inline const usize SIZE = 1000;
-   static inline char buf[SIZE];
+   static inline constexpr size_t SIZE = 100;
+   static inline char buffer[SIZE];
 
 public:
 
@@ -29,24 +19,47 @@ class chars {
    // default
    chars() { }
 
-   // from float, double, or long double
-   template<class T, class = require<floating<T> && allowed<T,number::variant>>>
+   // from any T in number::variant
+   template<class T, class = require<invar<T,number::variant>>>
    chars(
-      const T &from,
-      const std::chars_format format = std::chars_format::general
-   ) :
-      str(buf, std::to_chars(buf,buf+SIZE,from,format).ptr - buf)
-   { }
+      #ifdef JSON_CHARS
+         const T &from, const std::chars_format &format = json::format
+      #else
+         const T &from
+      #endif
+   ) {
+      std::to_chars_result res;
+
+      if constexpr (integral<T>)
+         res = same<T,unsigned char>
+             ? std::to_chars(buffer, buffer+SIZE, (unsigned short)from)
+             : same<T,  signed char>
+             ? std::to_chars(buffer, buffer+SIZE, (  signed short)from)
+             : std::to_chars(buffer, buffer+SIZE, from);
+      else {
+         #ifdef JSON_CHARS
+            res = std::to_chars(buffer, buffer+SIZE, from, format);
+         #else
+            assert(false);
+         #endif
+      }
+
+      if (res.ec == std::errc()) // std::errc() == default => no error
+         str = (*res.ptr = '\0', buffer);
+      else
+         error("Error returned by std::to_chars(). Message is:\n" +
+                std::make_error_code(res.ec).message() + '.');
+   }
 
    // ------------------------
    // Conversion
    // ------------------------
 
    // to std::string
    operator const std::string &() const { return str; }
-   operator       std::string &()       { return str; }
+   operator std::string &() { return str; }
 
-   // to literal
+   // to literal (whose construction from std::string is explicit)
    operator literal() const
    {
       return literal(str);