Redesigned JsonVariant to leverage converting constructors instead of assignment operators

include/ArduinoJson/Internals/ForceInline.hpp

@@ -0,0 +1,13 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#ifdef _MSC_VER
+#define JSON_FORCE_INLINE __forceinline
+#else
+#define JSON_FORCE_INLINE __attribute__((always_inline))
+#endif

include/ArduinoJson/Internals/JsonParser.hpp

@@ -28,11 +28,17 @@ class JsonParser {
   bool skip(const char *wordToSkip);
   void skipSpaces();
 
-  void parseAnythingTo(JsonVariant &destination);
-  inline void parseBooleanTo(JsonVariant &destination);
-  inline void parseNullTo(JsonVariant &destination);
-  inline void parseNumberTo(JsonVariant &destination);
-  inline const char *parseString();
+  bool parseAnythingTo(JsonVariant *destination);
+  JSON_FORCE_INLINE bool parseAnythingToUnsafe(JsonVariant *destination);
+
+  const char *parseString();
+
+  inline bool parseArrayTo(JsonVariant *destination);
+  inline bool parseBooleanTo(JsonVariant *destination);
+  inline bool parseNullTo(JsonVariant *destination);
+  inline bool parseNumberTo(JsonVariant *destination);
+  inline bool parseObjectTo(JsonVariant *destination);
+  inline bool parseStringTo(JsonVariant *destination);
 
   JsonBuffer *_buffer;
   char *_ptr;

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -23,6 +23,11 @@ union JsonVariantContent {
   const char* asString;  // asString can be null
   JsonArray* asArray;    // asArray cannot be null
   JsonObject* asObject;  // asObject cannot be null
+
+  template <typename T>
+  T as() const;
 };
 }
 }
+
+#include "JsonVariantContent.ipp"

include/ArduinoJson/Internals/JsonVariantContent.ipp

@@ -0,0 +1,96 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+
+// Forward declarations
+class JsonArray;
+class JsonObject;
+
+namespace Internals {
+template <>
+inline bool JsonVariantContent::as<bool>() const {
+  return asBoolean;
+}
+
+template <>
+inline char const* JsonVariantContent::as<char const*>() const {
+  return asString;
+}
+
+template <>
+inline double JsonVariantContent::as<double>() const {
+  return asDouble;
+}
+
+template <>
+inline float JsonVariantContent::as<float>() const {
+  return static_cast<float>(asDouble);
+}
+
+template <>
+inline JsonArray& JsonVariantContent::as<JsonArray&>() const {
+  return *asArray;
+}
+
+template <>
+inline const JsonArray& JsonVariantContent::as<JsonArray const&>() const {
+  return *asArray;
+}
+
+template <>
+inline JsonObject& JsonVariantContent::as<JsonObject&>() const {
+  return *asObject;
+}
+
+template <>
+inline const JsonObject& JsonVariantContent::as<JsonObject const&>() const {
+  return *asObject;
+}
+
+template <>
+inline signed char JsonVariantContent::as<signed char>() const {
+  return static_cast<signed char>(asLong);
+}
+
+template <>
+inline signed int JsonVariantContent::as<signed int>() const {
+  return static_cast<signed int>(asLong);
+}
+
+template <>
+inline signed long JsonVariantContent::as<signed long>() const {
+  return static_cast<signed long>(asLong);
+}
+
+template <>
+inline signed short JsonVariantContent::as<signed short>() const {
+  return static_cast<signed short>(asLong);
+}
+
+template <>
+inline unsigned char JsonVariantContent::as<unsigned char>() const {
+  return static_cast<unsigned char>(asLong);
+}
+
+template <>
+inline unsigned int JsonVariantContent::as<unsigned int>() const {
+  return static_cast<unsigned int>(asLong);
+}
+
+template <>
+inline unsigned long JsonVariantContent::as<unsigned long>() const {
+  return static_cast<unsigned long>(asLong);
+}
+
+template <>
+inline unsigned short JsonVariantContent::as<unsigned short>() const {
+  return static_cast<unsigned short>(asLong);
+}
+}
+}

include/ArduinoJson/Internals/JsonVariantType.hpp

@@ -7,12 +7,14 @@
 #pragma once
 
 namespace ArduinoJson {
+class JsonArray;
+class JsonObject;
+
 namespace Internals {
 
 // Enumerated type to know the current type of a JsonVariant.
 // The value determines which member of JsonVariantContent is used.
 enum JsonVariantType {
-  JSON_INVALID,    // a special state for JsonVariant::invalid()
   JSON_UNDEFINED,  // the JsonVariant has not been initialized
   JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
   JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject

include/ArduinoJson/Internals/List.hpp

@@ -39,7 +39,7 @@ class List {
 
   // Returns the numbers of elements in the list.
   // For a JsonObject, it would return the number of key-value pairs
-  int size() const;
+  size_t size() const;
 
   iterator begin() { return iterator(_firstNode); }
   iterator end() { return iterator(NULL); }
@@ -48,19 +48,20 @@ class List {
   const_iterator end() const { return const_iterator(NULL); }
 
  protected:
-  node_type *createNode() {
+  node_type *addNewNode() {
     if (!_buffer) return NULL;
-    return new (_buffer) node_type();
-  }
 
-  void addNode(node_type *nodeToAdd) {
+    node_type *newNode = new (_buffer) node_type();
+
     if (_firstNode) {
       node_type *lastNode = _firstNode;
       while (lastNode->next) lastNode = lastNode->next;
-      lastNode->next = nodeToAdd;
+      lastNode->next = newNode;
     } else {
-      _firstNode = nodeToAdd;
+      _firstNode = newNode;
     }
+
+    return newNode;
   }
 
   void removeNode(node_type *nodeToRemove);

include/ArduinoJson/Internals/Prettyfier.hpp

@@ -31,7 +31,7 @@ class Prettyfier : public Print {
 
   size_t handleBlockClose(uint8_t);
   size_t handleBlockOpen(uint8_t);
-  size_t handleColumn();
+  size_t handleColon();
   size_t handleComma();
   size_t handleQuoteOpen();
   size_t handleNormalChar(uint8_t);