Some JSON-related updates.

Author: staleyLANL

simple-json/src/json-array.hpp

@@ -15,24 +15,24 @@ class array : public std::vector<value> {
    // inherited
    using vector::vector;
 
-   // from instance of base class
-   array(const vector &from) : vector(from) { }
-   array(vector &&from) : vector(std::move(from)) { }
+   // from std::vector<value> (instance of base class)
+   array(const vector &base) : vector(base) { }
+   array(vector &&base) : vector(std::move(base)) { }
 
    // 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())
+   array(const std::vector<T> &vec) :
+      vector(vec.begin(), vec.end())
    { }
 
    // ------------------------
    // Assignment
    // ------------------------
 
-   template<class T, class = require<assignable<vector, T &&>>>
-   array &operator=(T &&from)
+   template<class FROM, class = require<assignable<vector, FROM &&>>>
+   array &operator=(FROM &&from)
    {
-      return vector::operator=(std::forward<T>(from)), *this;
+      return vector::operator=(std::forward<FROM>(from)), *this;
    }
 
    // ------------------------

simple-json/src/json-atom.hpp

@@ -0,0 +1,138 @@
+
+// -----------------------------------------------------------------------------
+// atom
+// -----------------------------------------------------------------------------
+
+#if defined(JSON_RAW)
+
+// ------------------------
+// Raw pointer version
+// ------------------------
+
+template<class T>
+class atom {
+   static inline constexpr bool plain = sizeof(T) <= sizeof(std::shared_ptr<T>);
+   std::conditional_t<plain, T, T *> val;
+
+public:
+
+   // construction: default
+   atom()
+   {
+      if constexpr ( plain) val = T();
+      if constexpr (!plain) val = new T();
+   }
+
+   // construction: from T (exactly)
+   template<class FROM, class = require<same<FROM,T>>>
+   atom(const FROM &from)
+   {
+      if constexpr ( plain) val = from;
+      if constexpr (!plain) val = new T(from);
+   }
+
+   // construction: copy
+   atom(const atom &other)
+   {
+      if constexpr ( plain) val = other.val;
+      if constexpr (!plain) val = new T(*other.val);
+   }
+
+   // construction: move
+   atom(atom &&other)
+   {
+      val = std::move(other.val);
+      if constexpr (!plain)
+         other.val = nullptr;
+   }
+
+   // assignment: copy
+   atom &operator=(const atom &other)
+   {
+      if constexpr ( plain) return  val =  other.val, *this;
+      if constexpr (!plain) return *val = *other.val, *this;
+   }
+
+   // assignment: move
+   atom &operator=(atom &&other)
+   {
+      val = std::move(other.val);
+      if constexpr ( plain) return *this;
+      if constexpr (!plain) return other.val = nullptr, *this;
+   }
+
+   // assignment: general
+   template<class FROM, class = require<assignable<T &, FROM &&>>>
+   atom &operator=(FROM &&from)
+   {
+      if constexpr ( plain) return  val = std::move(from), *this;
+      if constexpr (!plain) return *val = std::move(from), *this;
+   }
+
+   // conversion: to T
+   operator const T &() const
+   { if constexpr (plain) return val; else return *val; }
+   operator T &()
+   { if constexpr (plain) return val; else return *val; }
+
+   // destructor
+  ~atom()
+   {
+      if constexpr (!plain)
+         delete val;
+   }
+};
+
+// ------------------------
+// Shared pointer version
+// ------------------------
+
+#elif defined(JSON_SHARED)
+
+template<class T>
+class atom {
+   static inline constexpr bool plain = sizeof(T) <= sizeof(std::shared_ptr<T>);
+   std::conditional_t<plain, T, std::shared_ptr<T>> val;
+
+public:
+
+   // construction: default
+   atom()
+   {
+      if constexpr ( plain) val = T();
+      if constexpr (!plain) val = std::make_shared<T>();
+   }
+
+   // construction: from T (exactly)
+   template<class FROM, class = require<same<FROM,T>>>
+   atom(const FROM &from)
+   {
+      if constexpr ( plain) val = from;
+      if constexpr (!plain) val = std::make_shared<T>(from);
+   }
+
+   // conversion: to T
+   operator const T &() const
+   { if constexpr (plain) return val; else return *val; }
+   operator T &()
+   { if constexpr (plain) return val; else return *val; }
+
+   // assignment
+   template<class FROM, class = require<assignable<T &, FROM &&>>>
+   atom &operator=(FROM &&from)
+   {
+      if constexpr ( plain) return  val = std::move(from), *this;
+      if constexpr (!plain) return *val = std::move(from), *this;
+   }
+};
+
+// ------------------------
+// atom<T> == T
+// ------------------------
+
+#else
+
+template<class T>
+using atom = T;
+
+#endif

simple-json/src/json-boolean.hpp

@@ -18,8 +18,8 @@ class boolean {
    boolean() : b(false) { }
 
    // from bool (exactly)
-   template<class T, class = require<same<T,bool>>>
-   boolean(const T &from) : b(from) { }
+   template<class BOOL, class = require<same<BOOL,bool>>>
+   boolean(const BOOL &from) : b(from) { }
 
    // ------------------------
    // Conversion

simple-json/src/json-chars.hpp

@@ -30,17 +30,23 @@ class chars {
    ) {
       std::to_chars_result res;
 
-      if constexpr (integral<T>)
+      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 {
+      } else {
          #ifdef JSON_CHARS
             res = std::to_chars(buffer, buffer+SIZE, from, format);
          #else
-            assert(false);
+            error("Cannot construct a json::chars from a floating point "
+                  "value unless\nJSON_CHARS is #defined. This further "
+                  "requires that std::to_chars()\nbe available for "
+                  "floating points. (It isn't for some compilers.)");
+            // error() throws; this return just suppresses warnings from
+            // some compilers about res being uninitialized below.
+            return;
          #endif
       }
 

simple-json/src/json-detail-post.hpp

@@ -12,7 +12,7 @@ struct variant2tuple<std::variant<As...>> { using type = std::tuple<As...>; };
 // Re: printing
 // -----------------------------------------------------------------------------
 
-// name: general
+// name: specific cases
 #define JSON_NAME(type) \
    inline std::string name(const type &) { return #type; }
 
@@ -39,6 +39,17 @@ JSON_NAME(literal)
 
 #undef JSON_NAME
 
+// name: for atom
+// Remark: If preprocessor directives are such that atom<T> == T, then name(),
+// as defined below, without the class = require<> SFINAE, would be infinitely
+// recursive. It presumably wouldn't be called, because, above, we define each
+// case we intend to use. To be exceedingly proper, though, we have the SFINAE.
+template<class T, class = require<!same<atom<T>,T>>>
+std::string name(const atom<T> &)
+{
+   return name(T());
+}
+
 // name: for number
 inline std::string name(const number &n)
 {
@@ -48,7 +59,7 @@ inline std::string name(const number &n)
    );
 }
 
-// detail::print, for array and object
+// print, for array and object
 template<class ACTION, class T>
 void print(
    const T &obj, std::ostream &os,
@@ -62,7 +73,7 @@ void print(
    os << std::setw(0) << str + ch + (colors ? json::color::reset : "");
 }
 
-// detail::print, for other types
+// print, for other types
 template<class ACTION, class T>
 void print(
    const T &obj, std::ostream &os, const std::string &content,
@@ -147,7 +158,7 @@ inline void expect(
 // nocasecmp
 // Case-insensitive std::string comparison.
 // The old C language strcasecmp() is nonstandard. A modern, true caseless
-// std::string comparison would depend on, e.g., locale; but the following
+// std::string comparison would depend on, e.g., locale, but the following
 // should suffice for our purposes.
 inline bool nocasecmp(const std::string &one, const std::string &two)
 {
@@ -207,4 +218,102 @@ literal many(
    return literal(flags & literal::self ? text+suffix : "");
 } // many
 
+
+// -----------------------------------------------------------------------------
+// Support for reading string escapes of the form \u####
+// -----------------------------------------------------------------------------
+
+// ------------------------
+// Constants, functions
+// ------------------------
+
+// Ranges for surrogates.
+// Remark: each of [himin..himax] and [lomin..lomax]
+// has 1024 values inclusive. Also, lomin == himax+1.
+inline constexpr int himin = 0xD800; // 0b 11011 000 00000000
+inline constexpr int himax = 0xDBFF; // 0b 11011 011 11111111
+inline constexpr int lomin = 0xDC00; // 0b 11011 100 00000000
+inline constexpr int lomax = 0xDFFF; // 0b 11011 111 11111111
+inline constexpr unsigned tweak =
+   unsigned(himin << 10) + unsigned(lomin) - 0x10000u;
+
+// High/low surrogate?
+inline bool hi(const int p) { return himin <= p && p <= himax; }
+inline bool lo(const int p) { return lomin <= p && p <= lomax; }
+
+// ------------------------
+// codepoint
+// ------------------------
+
+// \uabcd ==> (a << 12) + (b << 8) + (c << 4) + (d << 0)
+inline int codepoint(
+   const std::string &context, std::istream &is,
+   std::string &token // representation of hex number, for diagnostic printing
+) {
+   int ret = 0, ch;
+   token = "\\u";
+   for (const unsigned shift : { 12u, 8u, 4u, 0u }) {
+      if ((ch = is.get()) == EOF)
+         error(context +
+              "Expected 4-character hex code; reached EOF instead.", &is);
+      else if ('0' <= ch && ch <= '9') ret += int((unsigned(ch)-48u) << shift);
+      else if ('A' <= ch && ch <= 'F') ret += int((unsigned(ch)-55u) << shift);
+      else if ('a' <= ch && ch <= 'f') ret += int((unsigned(ch)-87u) << shift);
+      else
+         error(context +
+              "Invalid hex digit found while reading \\u####.", &is);
+      token += ch;
+   }
+   return ret;
+}
+
+// ------------------------
+// unicode
+// ------------------------
+
+inline void unicode(
+   const std::string &context, std::istream &is,
+   std::string &str
+) {
+   std::string one, two;
+   int first = codepoint(context,is,one), second;
+
+   static const std::string
+      hi_before_lo = "A high surrogate must precede the low surrogate",
+      lo_follow_hi = "A low surrogate must follow the high surrogate";
+
+   if (lo(first))
+      error(context + hi_before_lo + " " + one + ".\n" +
+           "There was no such high surrogate.", &is);
+   if (hi(first)) {
+      if (is.get() != '\\' || is.get() != 'u')
+         error(context + lo_follow_hi + " " + one + ".\n" +
+              "There is no such low surrogate.", &is);
+      if (!lo(second = codepoint(context,is,two)))
+         error(context + lo_follow_hi + " " + one + ".\n" +
+               two + " is not a low surrogate.", &is);
+      first = (unsigned(first) << 10u) + unsigned(second) - tweak;
+   }
+
+   if (first <= 127) {
+      // 0bbbbbbb (ASCII case)
+      str += int(first);
+   } else if (first <= 2047) {
+      // 110bbbbb 10bbbbbb
+      str += int(0b11000000u | ((unsigned(first) >>  6u)              ));
+      str += int(0b10000000u | ((unsigned(first)       ) & 0b00111111u));
+   } else if (first <= 65535) {
+      // 1110bbbb 10bbbbbb 10bbbbbb
+      str += int(0b11100000u | ((unsigned(first) >> 12u)              ));
+      str += int(0b10000000u | ((unsigned(first) >>  6u) & 0b00111111u));
+      str += int(0b10000000u | ((unsigned(first)       ) & 0b00111111u));
+   } else {
+      // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
+      str += int(0b11110000u | ((unsigned(first) >> 18u)              ));
+      str += int(0b10000000u | ((unsigned(first) >> 12u) & 0b00111111u));
+      str += int(0b10000000u | ((unsigned(first) >>  6u) & 0b00111111u));
+      str += int(0b10000000u | ((unsigned(first)       ) & 0b00111111u));
+   }
+}
+
 } // namespace detail