Store parsed token as string and allow conversion between various types (issues #64, #69, #90, #93)

.clang-format

@@ -0,0 +1,3 @@
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+
+BasedOnStyle: Google

.gitattributes

@@ -0,0 +1 @@
+*.sh text eol=lf

.travis.yml

@@ -3,8 +3,18 @@ compiler:
   - gcc
   - clang
 before_install:
+  - "/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16"
+  - sleep 3
+  - export DISPLAY=:1.0
+  - wget http://downloads.arduino.cc/arduino-1.6.5-linux64.tar.xz
+  - tar xf arduino-1.6.5-linux64.tar.xz
+  - sudo mv arduino-1.6.5 /usr/local/share/arduino
+  - sudo ln -s /usr/local/share/arduino/arduino /usr/local/bin/arduino
+  - sudo ln -s $PWD /usr/local/share/arduino/libraries/ArduinoJson
   - sudo pip install cpp-coveralls
 script:
   - cmake -DCOVERAGE=true . && make && make test
+  - arduino --verify --board arduino:avr:uno $PWD/examples/JsonParserExample/JsonParserExample.ino
+  - arduino --verify --board arduino:avr:uno $PWD/examples/JsonGeneratorExample/JsonGeneratorExample.ino
 after_success:
     - if [ "$CC" = "gcc" ]; then coveralls --exclude third-party --gcov-options '\-lp'; fi

CHANGELOG.md

@@ -4,9 +4,14 @@ ArduinoJson: change log
 v5.0 (currently in beta)
 ----
 
-* Added support of `String` class (issue #55, #56, #70, #77)
+* Added support of `String` class (issues #55, #56, #70, #77)
+* Added `JsonBuffer::strdup()` to make a copy of a string (issues #10, #57)
+* Implicitly call `strdup()` for `String` but not for `char*` (issues #84, #87)
 * Added support of non standard JSON input (issue #44)
-* Redesigned `JsonVariant` to leverage converting constructors instead of assignment operators
+* Added support of comments in JSON input (issue #88)
+* Added implicit cast between numerical types (issues #64, #69, #93)
+* Added ability to read number values as string (issue #90)
+* Redesigned `JsonVariant` to leverage converting constructors instead of assignment operators (issue #66)
 * Switched to new the library layout (requires Arduino 1.0.6 or above)
 
 **BREAKING CHANGES**:
@@ -21,6 +26,11 @@ The `String` class is **bad** because it uses dynamic memory allocation.
 Compared to static allocation, it compiles to a bigger, slower program, and is less predictable.
 You certainly don't want that in an embedded environment!
 
+v4.6
+----
+
+* Fixed segmentation fault in `DynamicJsonBuffer` when memory allocation fails (issue #92)
+
 v4.5
 ----
 

README.md

@@ -12,7 +12,7 @@ It has been written with Arduino in mind, but it isn't linked to Arduino librari
 Features
 --------
 
-* JSON decoding
+* JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
 * Elegant API, very easy to use 
 * Efficient (no malloc, nor copy)
@@ -80,4 +80,4 @@ From GitHub user `zacsketches`:
 
 ---
 
-Found this library useful? [Help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:
+Found this library useful? [Help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:

include/ArduinoJson/Arduino/Print.hpp

@@ -11,7 +11,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-// This class reproduces Arduino's Print
+// This class reproduces Arduino's Print class
 class Print {
  public:
   virtual ~Print() {}

include/ArduinoJson/Arduino/String.hpp

@@ -10,7 +10,20 @@
 
 #include <string>
 
-typedef std::string String;
+// This class reproduces Arduino's String class
+class String : public std::string {
+ public:
+  String(const char *cstr = "") : std::string(cstr) {}
+  String(const String &str) : std::string(str) {}
+  explicit String(char c);
+  explicit String(unsigned char);
+  explicit String(int);
+  explicit String(unsigned int);
+  explicit String(long);
+  explicit String(unsigned long);
+  explicit String(float, unsigned char decimalPlaces = 2);
+  explicit String(double, unsigned char decimalPlaces = 2);
+};
 
 #else
 

include/ArduinoJson/DynamicJsonBuffer.hpp

@@ -6,41 +6,12 @@
 
 #pragma once
 
-#include "JsonBuffer.hpp"
-
-#include <stdlib.h>
+#include "Internals/BlockJsonBuffer.hpp"
 
 namespace ArduinoJson {
-
-// Forward declaration
-namespace Internals {
-struct DynamicJsonBufferBlock;
-}
-
 // Implements a JsonBuffer with dynamic memory allocation.
 // You are strongly encouraged to consider using StaticJsonBuffer which is much
 // more suitable for embedded systems.
-class DynamicJsonBuffer : public JsonBuffer {
- public:
-  DynamicJsonBuffer();
-  ~DynamicJsonBuffer();
-
-  size_t size() const;
-
- protected:
-  virtual void* alloc(size_t bytes);
-
- private:
-  typedef Internals::DynamicJsonBufferBlock Block;
-
-  static const size_t FIRST_BLOCK_CAPACITY = 32;
-
-  static Block* createBlock(size_t capacity);
-
-  inline bool canAllocInHead(size_t bytes) const;
-  inline void* allocInHead(size_t bytes);
-  inline void addNewBlock();
-
-  Block* _head;
-};
+typedef Internals::BlockJsonBuffer<Internals::DefaultAllocator>
+    DynamicJsonBuffer;
 }

include/ArduinoJson/Internals/BlockJsonBuffer.hpp

@@ -0,0 +1,93 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+
+#include <stdlib.h>
+
+namespace ArduinoJson {
+namespace Internals {
+class DefaultAllocator {
+ public:
+  void* allocate(size_t size) { return malloc(size); }
+  void deallocate(void* pointer) { free(pointer); }
+};
+
+template <typename TAllocator>
+class BlockJsonBuffer : public JsonBuffer {
+  struct Block;
+  struct EmptyBlock {
+    Block* next;
+    size_t capacity;
+    size_t size;
+  };
+  struct Block : EmptyBlock {
+    uint8_t data[1];
+  };
+
+ public:
+  BlockJsonBuffer() : _head(NULL) {}
+
+  ~BlockJsonBuffer() {
+    Block* currentBlock = _head;
+
+    while (currentBlock != NULL) {
+      Block* nextBlock = currentBlock->next;
+      _allocator.deallocate(currentBlock);
+      currentBlock = nextBlock;
+    }
+  }
+
+  size_t size() const {
+    size_t total = 0;
+    for (const Block* b = _head; b; b = b->next) total += b->size;
+    return total;
+  }
+
+ protected:
+  virtual void* alloc(size_t bytes) {
+    return canAllocInHead(bytes) ? allocInHead(bytes) : allocInNewBlock(bytes);
+  }
+
+ private:
+  static const size_t FIRST_BLOCK_CAPACITY = 32;
+
+  bool canAllocInHead(size_t bytes) const {
+    return _head != NULL && _head->size + bytes <= _head->capacity;
+  }
+
+  void* allocInHead(size_t bytes) {
+    void* p = _head->data + _head->size;
+    _head->size += bytes;
+    return p;
+  }
+
+  void* allocInNewBlock(size_t bytes) {
+    size_t capacity = FIRST_BLOCK_CAPACITY;
+    if (_head != NULL) capacity = _head->capacity * 2;
+    if (bytes > capacity) capacity = bytes;
+    if (!addNewBlock(capacity)) return NULL;
+    return allocInHead(bytes);
+  }
+
+  bool addNewBlock(size_t capacity) {
+    size_t size = sizeof(EmptyBlock) + capacity;
+    Block* block = static_cast<Block*>(_allocator.allocate(size));
+    if (block == NULL) return false;
+    block->capacity = capacity;
+    block->size = 0;
+    block->next = _head;
+    _head = block;
+    return true;
+  }
+
+  Block* _head;
+  TAllocator _allocator;
+};
+}
+}

include/ArduinoJson/Internals/Comments.hpp

@@ -0,0 +1,13 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+const char *skipSpacesAndComments(const char *ptr);
+}
+}

include/ArduinoJson/Internals/DynamicStringBuilder.hpp

@@ -0,0 +1,29 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+#include "../Arduino/String.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A Print implementation that allows to write in a String
+class DynamicStringBuilder : public Print {
+ public:
+  DynamicStringBuilder(String &str) : _str(str) {}
+
+  virtual size_t write(uint8_t c) {
+    _str += c;
+    return 1;
+  }
+
+ private:
+  String &_str;
+};
+}
+}

include/ArduinoJson/Internals/JsonParser.hpp

@@ -28,16 +28,12 @@ class JsonParser {
 
  private:
   bool skip(char charToSkip);
-  bool skip(const char *wordToSkip);
 
   const char *parseString();
   bool parseAnythingTo(JsonVariant *destination);
   FORCE_INLINE bool parseAnythingToUnsafe(JsonVariant *destination);
 
   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);
 

include/ArduinoJson/Internals/JsonPrintable.hpp

@@ -10,7 +10,8 @@
 #include "IndentedPrint.hpp"
 #include "JsonWriter.hpp"
 #include "Prettyfier.hpp"
-#include "StringBuilder.hpp"
+#include "StaticStringBuilder.hpp"
+#include "DynamicStringBuilder.hpp"
 
 #ifdef ARDUINOJSON_ENABLE_STD_STREAM
 #include "StreamPrintAdapter.hpp"
@@ -33,15 +34,20 @@ class JsonPrintable {
   }
 
 #ifdef ARDUINOJSON_ENABLE_STD_STREAM
-  std::ostream& printTo(std::ostream &os) const {
+  std::ostream &printTo(std::ostream &os) const {
     StreamPrintAdapter adapter(os);
     printTo(adapter);
     return os;
   }
-#endif 
+#endif
 
   size_t printTo(char *buffer, size_t bufferSize) const {
-    StringBuilder sb(buffer, bufferSize);
+    StaticStringBuilder sb(buffer, bufferSize);
+    return printTo(sb);
+  }
+
+  size_t printTo(String &str) const {
+    DynamicStringBuilder sb(str);
     return printTo(sb);
   }
 
@@ -51,7 +57,7 @@ class JsonPrintable {
   }
 
   size_t prettyPrintTo(char *buffer, size_t bufferSize) const {
-    StringBuilder sb(buffer, bufferSize);
+    StaticStringBuilder sb(buffer, bufferSize);
     return prettyPrintTo(sb);
   }
 
@@ -60,6 +66,11 @@ class JsonPrintable {
     return prettyPrintTo(indentedPrint);
   }
 
+  size_t prettyPrintTo(String &str) const {
+    DynamicStringBuilder sb(str);
+    return prettyPrintTo(sb);
+  }
+
   size_t measureLength() const {
     DummyPrint dp;
     return printTo(dp);
@@ -75,11 +86,10 @@ class JsonPrintable {
 };
 
 #ifdef ARDUINOJSON_ENABLE_STD_STREAM
-template<typename T>
-inline std::ostream& operator<<(std::ostream& os, const JsonPrintable<T>& v) {
+template <typename T>
+inline std::ostream &operator<<(std::ostream &os, const JsonPrintable<T> &v) {
   return v.printTo(os);
 }
 #endif
-
 }
 }

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -17,17 +17,11 @@ namespace Internals {
 // A union that defines the actual content of a JsonVariant.
 // The enum JsonVariantType determines which member is in use.
 union JsonVariantContent {
-  bool asBoolean;
   double asDouble;       // asDouble is also used for float
-  long asLong;           // asLong is also used for char, short and int
+  long asLong;           // asLong is also used for bool, char, short and int
   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

@@ -1,101 +0,0 @@
-// 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 String JsonVariantContent::as<String>() 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

@@ -16,11 +16,12 @@ namespace Internals {
 // The value determines which member of JsonVariantContent is used.
 enum JsonVariantType {
   JSON_UNDEFINED,  // the JsonVariant has not been initialized
+  JSON_UNPARSED,   // the JsonVariant contains an unparsed string
+  JSON_STRING,     // the JsonVariant stores a const char*
+  JSON_BOOLEAN,    // the JsonVariant stores a bool
+  JSON_LONG,       // the JsonVariant stores a long
   JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
   JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject
-  JSON_BOOLEAN,    // the JsonVariant stores a bool
-  JSON_STRING,     // the JsonVariant stores a const char*
-  JSON_LONG,       // the JsonVariant stores a long
 
   // The following values are reserved for double values
   // Multiple values are used for double, depending on the number of decimal

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -37,10 +37,8 @@ class JsonWriter {
   void writeColon() { write(':'); }
   void writeComma() { write(','); }
 
-  void writeBoolean(bool value) {
-    write(value ? "true" : "false");
-  }
-  
+  void writeBoolean(bool value) { write(value ? "true" : "false"); }
+
   void writeString(const char *value) {
     if (!value) {
       write("null");
@@ -67,6 +65,8 @@ class JsonWriter {
     _length += _sink.print(value, decimals);
   }
 
+  void writeRaw(const char *s) { return write(s); }
+
  protected:
   void write(char c) { _length += _sink.write(c); }
   void write(const char *s) { _length += _sink.print(s); }

include/ArduinoJson/Internals/StaticStringBuilder.hpp

@@ -12,9 +12,9 @@ namespace ArduinoJson {
 namespace Internals {
 
 // A Print implementation that allows to write in a char[]
-class StringBuilder : public Print {
+class StaticStringBuilder : public Print {
  public:
-  StringBuilder(char *buf, int size)
+  StaticStringBuilder(char *buf, int size)
       : buffer(buf), capacity(size - 1), length(0) {
     buffer[0] = '\0';
   }

include/ArduinoJson/Internals/Unparsed.hpp

@@ -0,0 +1,20 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+class Unparsed {
+ public:
+  explicit Unparsed(const char* str) : _str(str) {}
+  operator const char*() const { return _str; }
+
+ private:
+  const char* _str;
+};
+}
+}

include/ArduinoJson/JsonArray.hpp

@@ -42,16 +42,46 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
       : Internals::List<JsonVariant>(buffer) {}
 
   // Gets the value at the specified index
-  FORCE_INLINE const JsonArraySubscript operator[](size_t index) const;
+  FORCE_INLINE JsonVariant operator[](size_t index) const;
 
   // Gets or sets the value at specified index
   FORCE_INLINE JsonArraySubscript operator[](size_t index);
 
   // Adds the specified value at the end of the array.
-  FORCE_INLINE bool add(const JsonVariant value);
+  FORCE_INLINE bool add(bool value);
+  FORCE_INLINE bool add(float value, uint8_t decimals = 2);
+  FORCE_INLINE bool add(double value, uint8_t decimals = 2);
+  FORCE_INLINE bool add(signed char value);
+  FORCE_INLINE bool add(signed long value);
+  FORCE_INLINE bool add(signed int value);
+  FORCE_INLINE bool add(signed short value);
+  FORCE_INLINE bool add(unsigned char value);
+  FORCE_INLINE bool add(unsigned long value);
+  FORCE_INLINE bool add(unsigned int value);
+  FORCE_INLINE bool add(unsigned short value);
+  FORCE_INLINE bool add(const char *value);
+  FORCE_INLINE bool add(const String &value);
+  FORCE_INLINE bool add(JsonArray &array);
+  FORCE_INLINE bool add(JsonObject &object);
+  FORCE_INLINE bool add(const JsonVariant &object);
 
   // Sets the value at specified index.
-  FORCE_INLINE void set(size_t index, const JsonVariant value);
+  FORCE_INLINE void set(size_t index, bool value);
+  FORCE_INLINE void set(size_t index, float value, uint8_t decimals = 2);
+  FORCE_INLINE void set(size_t index, double value, uint8_t decimals = 2);
+  FORCE_INLINE void set(size_t index, signed char value);
+  FORCE_INLINE void set(size_t index, signed long value);
+  FORCE_INLINE void set(size_t index, signed int value);
+  FORCE_INLINE void set(size_t index, signed short value);
+  FORCE_INLINE void set(size_t index, unsigned char value);
+  FORCE_INLINE void set(size_t index, unsigned long value);
+  FORCE_INLINE void set(size_t index, unsigned int value);
+  FORCE_INLINE void set(size_t index, unsigned short value);
+  FORCE_INLINE void set(size_t index, const char *value);
+  FORCE_INLINE void set(size_t index, const String &value);
+  FORCE_INLINE void set(size_t index, JsonArray &array);
+  FORCE_INLINE void set(size_t index, JsonObject &object);
+  FORCE_INLINE void set(size_t index, const JsonVariant &object);
 
   // Gets the value at the specified index.
   FORCE_INLINE JsonVariant get(size_t index) const;
@@ -86,6 +116,15 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  private:
   node_type *getNodeAt(size_t index) const;
 
+  template <typename TValue>
+  void setNodeAt(size_t index, TValue value);
+
+  template <typename TValue>
+  bool addNode(TValue);
+
+  template <typename T>
+  FORCE_INLINE void setNodeValue(node_type *, T value);
+
   // The instance returned by JsonArray::invalid()
   static JsonArray _invalid;
 };

include/ArduinoJson/JsonArray.ipp

@@ -15,14 +15,159 @@ inline JsonArraySubscript JsonArray::operator[](size_t index) {
   return JsonArraySubscript(*this, index);
 }
 
-inline const JsonArraySubscript JsonArray::operator[](size_t index) const {
-  return JsonArraySubscript(*const_cast<JsonArray *>(this), index);
+inline JsonVariant JsonArray::operator[](size_t index) const {
+  return get(index);
 }
 
-inline bool JsonArray::add(const JsonVariant value) {
+inline bool JsonArray::add(bool value) { return addNode<bool>(value); }
+
+inline bool JsonArray::add(float value, uint8_t decimals) {
+  return addNode<const JsonVariant &>(JsonVariant(value, decimals));
+}
+
+inline bool JsonArray::add(double value, uint8_t decimals) {
+  return addNode<const JsonVariant &>(JsonVariant(value, decimals));
+}
+
+inline bool JsonArray::add(signed char value) {
+  return addNode<signed char>(value);
+}
+
+inline bool JsonArray::add(signed long value) {
+  return addNode<signed long>(value);
+}
+
+inline bool JsonArray::add(signed int value) {
+  return addNode<signed int>(value);
+}
+
+inline bool JsonArray::add(signed short value) {
+  return addNode<signed short>(value);
+}
+
+inline bool JsonArray::add(unsigned char value) {
+  return addNode<unsigned char>(value);
+}
+
+inline bool JsonArray::add(unsigned long value) {
+  return addNode<unsigned long>(value);
+}
+
+inline bool JsonArray::add(unsigned int value) {
+  return addNode<unsigned int>(value);
+}
+
+inline bool JsonArray::add(unsigned short value) {
+  return addNode<unsigned short>(value);
+}
+
+inline bool JsonArray::add(const char *value) {
+  return addNode<const char *>(value);
+}
+
+inline bool JsonArray::add(const String &value) {
+  return addNode<const String &>(value);
+}
+
+inline bool JsonArray::add(JsonArray &array) {
+  return addNode<JsonArray &>(array);
+}
+
+inline bool JsonArray::add(JsonObject &object) {
+  return addNode<JsonObject &>(object);
+}
+
+inline bool JsonArray::add(const JsonVariant &object) {
+  return addNode<const JsonVariant &>(object);
+}
+
+template <typename TValue>
+inline bool JsonArray::addNode(TValue value) {
   node_type *node = addNewNode();
-  if (node) node->content = value;
-  return node != NULL;
+  if (node == NULL) return false;
+  setNodeValue<TValue>(node, value);
+  return true;
+}
+
+inline void JsonArray::set(size_t index, bool value) {
+  return setNodeAt<bool>(index, value);
+}
+
+inline void JsonArray::set(size_t index, float value, uint8_t decimals) {
+  return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
+}
+
+inline void JsonArray::set(size_t index, double value, uint8_t decimals) {
+  return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
+}
+
+inline void JsonArray::set(size_t index, signed char value) {
+  return setNodeAt<signed char>(index, value);
+}
+
+inline void JsonArray::set(size_t index, signed long value) {
+  return setNodeAt<signed long>(index, value);
+}
+
+inline void JsonArray::set(size_t index, signed int value) {
+  return setNodeAt<signed int>(index, value);
+}
+
+inline void JsonArray::set(size_t index, signed short value) {
+  return setNodeAt<signed short>(index, value);
+}
+
+inline void JsonArray::set(size_t index, unsigned char value) {
+  return setNodeAt<unsigned char>(index, value);
+}
+
+inline void JsonArray::set(size_t index, unsigned long value) {
+  return setNodeAt<unsigned long>(index, value);
+}
+
+inline void JsonArray::set(size_t index, unsigned int value) {
+  return setNodeAt<unsigned int>(index, value);
+}
+
+inline void JsonArray::set(size_t index, unsigned short value) {
+  return setNodeAt<unsigned short>(index, value);
+}
+
+inline void JsonArray::set(size_t index, const char *value) {
+  return setNodeAt<const char *>(index, value);
+}
+
+inline void JsonArray::set(size_t index, const String &value) {
+  return setNodeAt<const String &>(index, value);
+}
+
+inline void JsonArray::set(size_t index, JsonArray &array) {
+  return setNodeAt<JsonArray &>(index, array);
+}
+
+inline void JsonArray::set(size_t index, JsonObject &object) {
+  return setNodeAt<JsonObject &>(index, object);
+}
+
+inline void JsonArray::set(size_t index, const JsonVariant &object) {
+  return setNodeAt<const JsonVariant &>(index, object);
+}
+
+template <typename TValue>
+inline void JsonArray::setNodeAt(size_t index, TValue value) {
+  node_type *node = getNodeAt(index);
+  if (node == NULL) return;
+  setNodeValue<TValue>(node, value);
+}
+
+template <typename TValue>
+inline void JsonArray::setNodeValue(node_type *node, TValue value) {
+  node->content = value;
+}
+
+template <>
+inline void JsonArray::setNodeValue(node_type *node, const String &value) {
+  node->content = _buffer->strdup(value);
 }
 
 inline JsonVariant JsonArray::get(size_t index) const {
@@ -42,11 +187,6 @@ inline T JsonArray::is(size_t index) const {
   return node ? node->content.is<T>() : false;
 }
 
-inline void JsonArray::set(size_t index, const JsonVariant value) {
-  node_type *node = getNodeAt(index);
-  if (node) node->content = value;
-}
-
 template <typename TImplem>
 inline const JsonArraySubscript JsonVariantBase<TImplem>::operator[](
     int index) const {
@@ -62,4 +202,16 @@ template <>
 inline JsonArray const &JsonVariant::invalid<JsonArray const &>() {
   return JsonArray::invalid();
 }
+
+template <>
+inline JsonArray &JsonVariant::as<JsonArray &>() const {
+  if (_type == Internals::JSON_ARRAY) return *_content.asArray;
+  return JsonArray::invalid();
+}
+
+template <>
+inline const JsonArray &JsonVariant::as<const JsonArray &>() const {
+  if (_type == Internals::JSON_ARRAY) return *_content.asArray;
+  return JsonArray::invalid();
+}
 }

include/ArduinoJson/JsonArraySubscript.hpp

@@ -6,18 +6,15 @@
 
 #pragma once
 
-#include "JsonVariantBase.hpp"
+#include "JsonSubscriptBase.hpp"
 
 namespace ArduinoJson {
-class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
+class JsonArraySubscript : public JsonSubscriptBase<JsonArraySubscript> {
  public:
   FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
       : _array(array), _index(index) {}
 
-  FORCE_INLINE JsonArraySubscript& operator=(const JsonVariant& value) {
-    _array.set(_index, value);
-    return *this;
-  }
+  using JsonSubscriptBase::operator=;
 
   FORCE_INLINE JsonArraySubscript& operator=(const JsonArraySubscript& other) {
     // to prevent Visual Studio warning C4512: assignment operator could not be
@@ -40,19 +37,25 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
     return _array.is<T>(_index);
   }
 
-  void writeTo(Internals::JsonWriter &writer) const {
+  void writeTo(Internals::JsonWriter& writer) const {
     _array.get(_index).writeTo(writer);
   }
 
+  template <typename TValue>
+  void set(TValue value) {
+    _array.set(_index, value);
+  }
+
  private:
   JsonArray& _array;
   const size_t _index;
 };
 
 #ifdef ARDUINOJSON_ENABLE_STD_STREAM
-inline std::ostream& operator<<(std::ostream& os, const JsonArraySubscript& source) {
+inline std::ostream& operator<<(std::ostream& os,
+                                const JsonArraySubscript& source) {
   return source.printTo(os);
 }
 #endif
 
-} // namespace ArduinoJson
+}  // namespace ArduinoJson

include/ArduinoJson/JsonBuffer.hpp

@@ -8,8 +8,10 @@
 
 #include <stddef.h>  // for size_t
 #include <stdint.h>  // for uint8_t
+#include <string.h>
 
 #include "Arduino/String.hpp"
+#include "JsonVariant.hpp"
 
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wnon-virtual-dtor"
@@ -59,7 +61,7 @@ class JsonBuffer {
 
   // Same as above with a String class
   JsonArray &parseArray(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
-    return parseArray(const_cast<char *>(json.c_str()), nesting);
+    return parseArray(strdup(json), nesting);
   }
 
   // Allocates and populate a JsonObject from a JSON string.
@@ -75,11 +77,15 @@ class JsonBuffer {
   JsonObject &parseObject(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
 
   // Same as above with a String class
-  JsonObject &parseObject(const String &json,
-                          uint8_t nestingLimit = DEFAULT_LIMIT) {
-    return parseObject(const_cast<char *>(json.c_str()), nestingLimit);
+  JsonObject &parseObject(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parseObject(strdup(json), nesting);
   }
 
+  // Duplicate a string
+  char *strdup(const char *src) { return strdup(src, strlen(src)); }
+  char *strdup(const String &src) { return strdup(src.c_str(), src.length()); }
+  char *strdup(const char *, size_t);
+
   // Allocates n bytes in the JsonBuffer.
   // Return a pointer to the allocated memory or NULL if allocation fails.
   virtual void *alloc(size_t size) = 0;

include/ArduinoJson/JsonObject.hpp

@@ -23,7 +23,6 @@ namespace ArduinoJson {
 // Forward declarations
 class JsonArray;
 class JsonBuffer;
-class JsonObjectSubscript;
 
 // A dictionary of JsonVariant indexed by string (char*)
 //
@@ -43,13 +42,45 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
       : Internals::List<JsonPair>(buffer) {}
 
   // Gets or sets the value associated with the specified key.
-  FORCE_INLINE JsonObjectSubscript operator[](JsonObjectKey key);
+  FORCE_INLINE JsonObjectSubscript<const char*> operator[](const char* key);
+  FORCE_INLINE JsonObjectSubscript<const String&> operator[](const String& key);
 
   // Gets the value associated with the specified key.
-  FORCE_INLINE const JsonObjectSubscript operator[](JsonObjectKey key) const;
+  FORCE_INLINE JsonVariant operator[](JsonObjectKey key) const;
 
   // Sets the specified key with the specified value.
-  FORCE_INLINE bool set(JsonObjectKey key, JsonVariant value);
+  FORCE_INLINE bool set(const char* key, bool value);
+  FORCE_INLINE bool set(const char* key, float value, uint8_t decimals = 2);
+  FORCE_INLINE bool set(const char* key, double value, uint8_t decimals = 2);
+  FORCE_INLINE bool set(const char* key, signed char value);
+  FORCE_INLINE bool set(const char* key, signed long value);
+  FORCE_INLINE bool set(const char* key, signed int value);
+  FORCE_INLINE bool set(const char* key, signed short value);
+  FORCE_INLINE bool set(const char* key, unsigned char value);
+  FORCE_INLINE bool set(const char* key, unsigned long value);
+  FORCE_INLINE bool set(const char* key, unsigned int value);
+  FORCE_INLINE bool set(const char* key, unsigned short value);
+  FORCE_INLINE bool set(const char* key, const char* value);
+  FORCE_INLINE bool set(const char* key, const String& value);
+  FORCE_INLINE bool set(const char* key, JsonArray& array);
+  FORCE_INLINE bool set(const char* key, JsonObject& object);
+  FORCE_INLINE bool set(const char* key, const JsonVariant& value);
+  FORCE_INLINE bool set(const String& key, bool value);
+  FORCE_INLINE bool set(const String& key, float value, uint8_t decimals = 2);
+  FORCE_INLINE bool set(const String& key, double value, uint8_t decimals = 2);
+  FORCE_INLINE bool set(const String& key, signed char value);
+  FORCE_INLINE bool set(const String& key, signed long value);
+  FORCE_INLINE bool set(const String& key, signed int value);
+  FORCE_INLINE bool set(const String& key, signed short value);
+  FORCE_INLINE bool set(const String& key, unsigned char value);
+  FORCE_INLINE bool set(const String& key, unsigned long value);
+  FORCE_INLINE bool set(const String& key, unsigned int value);
+  FORCE_INLINE bool set(const String& key, unsigned short value);
+  FORCE_INLINE bool set(const String& key, const char* value);
+  FORCE_INLINE bool set(const String& key, const String& value);
+  FORCE_INLINE bool set(const String& key, JsonArray& array);
+  FORCE_INLINE bool set(const String& key, JsonObject& object);
+  FORCE_INLINE bool set(const String& key, const JsonVariant& value);
 
   // Gets the value associated with the specified key.
   FORCE_INLINE JsonVariant get(JsonObjectKey) const;
@@ -64,11 +95,13 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
 
   // Creates and adds a JsonArray.
   // This is a shortcut for JsonBuffer::createArray() and JsonObject::add().
-  JsonArray& createNestedArray(JsonObjectKey key);
+  FORCE_INLINE JsonArray& createNestedArray(const char* key);
+  FORCE_INLINE JsonArray& createNestedArray(const String& key);
 
   // Creates and adds a JsonObject.
   // This is a shortcut for JsonBuffer::createObject() and JsonObject::add().
-  JsonObject& createNestedObject(JsonObjectKey key);
+  FORCE_INLINE JsonObject& createNestedObject(const char* key);
+  FORCE_INLINE JsonObject& createNestedObject(const String& key);
 
   // Tells weither the specified key is present and associated with a value.
   FORCE_INLINE bool containsKey(JsonObjectKey key) const;
@@ -90,6 +123,21 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
 
   node_type* getOrCreateNodeAt(JsonObjectKey key);
 
+  template <typename TKey, typename TValue>
+  FORCE_INLINE bool setNodeAt(TKey key, TValue value);
+
+  template <typename TKey>
+  JsonArray& createArrayAt(TKey key);
+
+  template <typename TKey>
+  JsonObject& createObjectAt(TKey key);
+
+  template <typename T>
+  FORCE_INLINE void setNodeKey(node_type*, T key);
+
+  template <typename T>
+  FORCE_INLINE void setNodeValue(node_type*, T value);
+
   // The instance returned by JsonObject::invalid()
   static JsonObject _invalid;
 };

include/ArduinoJson/JsonObject.ipp

@@ -28,41 +28,183 @@ inline bool JsonObject::is(JsonObjectKey key) const {
   return node ? node->content.value.is<T>() : false;
 }
 
-inline JsonObjectSubscript JsonObject::operator[](JsonObjectKey key) {
-  return JsonObjectSubscript(*this, key);
+inline JsonObjectSubscript<const char *> JsonObject::operator[](
+    const char *key) {
+  return JsonObjectSubscript<const char *>(*this, key);
 }
 
-inline const JsonObjectSubscript JsonObject::operator[](
-    JsonObjectKey key) const {
-  return JsonObjectSubscript(*const_cast<JsonObject *>(this), key);
+inline JsonObjectSubscript<const String &> JsonObject::operator[](
+    const String &key) {
+  return JsonObjectSubscript<const String &>(*this, key);
+}
+
+inline JsonVariant JsonObject::operator[](JsonObjectKey key) const {
+  return get(key);
 }
 
 inline bool JsonObject::containsKey(JsonObjectKey key) const {
   return getNodeAt(key) != NULL;
 }
 
+inline JsonArray &JsonObject::createNestedArray(const char *key) {
+  return createArrayAt<const char *>(key);
+}
+
+inline JsonArray &JsonObject::createNestedArray(const String &key) {
+  return createArrayAt<const String &>(key);
+}
+
+inline JsonObject &JsonObject::createNestedObject(const char *key) {
+  return createObjectAt<const char *>(key);
+}
+
+inline JsonObject &JsonObject::createNestedObject(const String &key) {
+  return createObjectAt<const String &>(key);
+}
+
 inline void JsonObject::remove(JsonObjectKey key) {
   removeNode(getNodeAt(key));
 }
 
-inline bool JsonObject::set(JsonObjectKey key, const JsonVariant value) {
+inline bool JsonObject::set(const char *key, bool value) {
+  return setNodeAt<const char *, bool>(key, value);
+}
+inline bool JsonObject::set(const char *key, float value, uint8_t decimals) {
+  return setNodeAt<const char *, const JsonVariant &>(
+      key, JsonVariant(value, decimals));
+}
+inline bool JsonObject::set(const char *key, double value, uint8_t decimals) {
+  return setNodeAt<const char *, const JsonVariant &>(
+      key, JsonVariant(value, decimals));
+}
+inline bool JsonObject::set(const char *key, signed char value) {
+  return setNodeAt<const char *, signed char>(key, value);
+}
+inline bool JsonObject::set(const char *key, signed long value) {
+  return setNodeAt<const char *, signed long>(key, value);
+}
+inline bool JsonObject::set(const char *key, signed int value) {
+  return setNodeAt<const char *, signed int>(key, value);
+}
+inline bool JsonObject::set(const char *key, signed short value) {
+  return setNodeAt<const char *, signed short>(key, value);
+}
+inline bool JsonObject::set(const char *key, unsigned char value) {
+  return setNodeAt<const char *, unsigned char>(key, value);
+}
+inline bool JsonObject::set(const char *key, unsigned long value) {
+  return setNodeAt<const char *, unsigned long>(key, value);
+}
+inline bool JsonObject::set(const char *key, unsigned int value) {
+  return setNodeAt<const char *, unsigned int>(key, value);
+}
+inline bool JsonObject::set(const char *key, unsigned short value) {
+  return setNodeAt<const char *, unsigned short>(key, value);
+}
+inline bool JsonObject::set(const char *key, const char *value) {
+  return setNodeAt<const char *, const char *>(key, value);
+}
+inline bool JsonObject::set(const char *key, const String &value) {
+  return setNodeAt<const char *, const String &>(key, value);
+}
+inline bool JsonObject::set(const char *key, JsonArray &array) {
+  return setNodeAt<const char *, JsonArray &>(key, array);
+}
+inline bool JsonObject::set(const char *key, JsonObject &object) {
+  return setNodeAt<const char *, JsonObject &>(key, object);
+}
+inline bool JsonObject::set(const char *key, const JsonVariant &value) {
+  return setNodeAt<const char *, const JsonVariant &>(key, value);
+}
+inline bool JsonObject::set(const String &key, bool value) {
+  return setNodeAt<const String &, bool>(key, value);
+}
+inline bool JsonObject::set(const String &key, float value, uint8_t decimals) {
+  return setNodeAt<const String &, const JsonVariant &>(
+      key, JsonVariant(value, decimals));
+}
+inline bool JsonObject::set(const String &key, double value, uint8_t decimals) {
+  return setNodeAt<const String &, const JsonVariant &>(
+      key, JsonVariant(value, decimals));
+}
+inline bool JsonObject::set(const String &key, signed char value) {
+  return setNodeAt<const String &, signed char>(key, value);
+}
+inline bool JsonObject::set(const String &key, signed long value) {
+  return setNodeAt<const String &, signed long>(key, value);
+}
+inline bool JsonObject::set(const String &key, signed int value) {
+  return setNodeAt<const String &, signed int>(key, value);
+}
+inline bool JsonObject::set(const String &key, signed short value) {
+  return setNodeAt<const String &, signed short>(key, value);
+}
+inline bool JsonObject::set(const String &key, unsigned char value) {
+  return setNodeAt<const String &, unsigned char>(key, value);
+}
+inline bool JsonObject::set(const String &key, unsigned long value) {
+  return setNodeAt<const String &, unsigned long>(key, value);
+}
+inline bool JsonObject::set(const String &key, unsigned int value) {
+  return setNodeAt<const String &, unsigned int>(key, value);
+}
+inline bool JsonObject::set(const String &key, unsigned short value) {
+  return setNodeAt<const String &, unsigned short>(key, value);
+}
+inline bool JsonObject::set(const String &key, const char *value) {
+  return setNodeAt<const String &, const char *>(key, value);
+}
+inline bool JsonObject::set(const String &key, const String &value) {
+  return setNodeAt<const String &, const String &>(key, value);
+}
+inline bool JsonObject::set(const String &key, JsonArray &array) {
+  return setNodeAt<const String &, JsonArray &>(key, array);
+}
+inline bool JsonObject::set(const String &key, JsonObject &object) {
+  return setNodeAt<const String &, JsonObject &>(key, object);
+}
+inline bool JsonObject::set(const String &key, const JsonVariant &value) {
+  return setNodeAt<const String &, const JsonVariant &>(key, value);
+}
+
+template <typename TKey, typename TValue>
+inline bool JsonObject::setNodeAt(TKey key, TValue value) {
   node_type *node = getOrCreateNodeAt(key);
   if (!node) return false;
-
-  node->content.key = key;
-  node->content.value = value;
+  setNodeKey<TKey>(node, key);
+  setNodeValue<TValue>(node, value);
   return true;
 }
 
+template <>
+inline void JsonObject::setNodeKey(node_type *node, const char *key) {
+  node->content.key = key;
+}
+
+template <>
+inline void JsonObject::setNodeKey(node_type *node, const String &key) {
+  node->content.key = _buffer->strdup(key);
+}
+
+template <typename TValue>
+inline void JsonObject::setNodeValue(node_type *node, TValue value) {
+  node->content.value = value;
+}
+
+template <>
+inline void JsonObject::setNodeValue(node_type *node, const String &value) {
+  node->content.value = _buffer->strdup(value);
+}
+
 template <typename TImplem>
-inline const JsonObjectSubscript JsonVariantBase<TImplem>::operator[](
-    const char *key) const {
+inline const JsonObjectSubscript<const char *> JsonVariantBase<TImplem>::
+operator[](const char *key) const {
   return asObject()[key];
 }
 
 template <typename TImplem>
-inline const JsonObjectSubscript JsonVariantBase<TImplem>::operator[](
-    const String &key) const {
+inline const JsonObjectSubscript<const String &> JsonVariantBase<TImplem>::
+operator[](const String &key) const {
   return asObject()[key];
 }
 
@@ -75,4 +217,16 @@ template <>
 inline JsonObject &JsonVariant::invalid<JsonObject &>() {
   return JsonObject::invalid();
 }
+
+template <>
+inline JsonObject &JsonVariant::as<JsonObject &>() const {
+  if (_type == Internals::JSON_OBJECT) return *_content.asObject;
+  return JsonObject::invalid();
+}
+
+template <>
+inline const JsonObject &JsonVariant::as<const JsonObject &>() const {
+  if (_type == Internals::JSON_OBJECT) return *_content.asObject;
+  return JsonObject::invalid();
+}
 }

include/ArduinoJson/JsonObjectSubscript.hpp

@@ -6,52 +6,64 @@
 
 #pragma once
 
-#include "JsonVariantBase.hpp"
+#include "JsonSubscriptBase.hpp"
 
 namespace ArduinoJson {
-class JsonObjectSubscript : public JsonVariantBase<JsonObjectSubscript> {
+
+template <typename TKey>
+class JsonObjectSubscript
+    : public JsonSubscriptBase<JsonObjectSubscript<TKey> > {
  public:
-  FORCE_INLINE JsonObjectSubscript(JsonObject& object, JsonObjectKey key)
+  FORCE_INLINE JsonObjectSubscript(JsonObject& object, TKey key)
       : _object(object), _key(key) {}
 
-  FORCE_INLINE JsonObjectSubscript& operator=(const JsonVariant& value) {
-    _object.set(_key, value);
-    return *this;
-  }
+  using JsonSubscriptBase<JsonObjectSubscript<TKey> >::operator=;
 
-  FORCE_INLINE JsonObjectSubscript& operator=(
-      const JsonObjectSubscript& other) {
+  FORCE_INLINE JsonObjectSubscript<TKey>& operator=(
+      const JsonObjectSubscript<TKey>& other) {
     // to prevent Visual Studio warning C4512: assignment operator could not be
     // generated
-    _object.set(_key, other._object.get(other._key));
-    return *this;
+    return set(other.get());
   }
 
   FORCE_INLINE bool success() const { return _object.containsKey(_key); }
 
   FORCE_INLINE operator JsonVariant() const { return _object.get(_key); }
 
-  template <typename T>
-  FORCE_INLINE T as() const {
-    return _object.get<T>(_key);
+  template <typename TValue>
+  FORCE_INLINE TValue as() const {
+    return _object.get<TValue>(_key);
   }
 
-  template <typename T>
-  FORCE_INLINE T is() const {
-    return _object.is<T>(_key);
+  template <typename TValue>
+  FORCE_INLINE TValue is() const {
+    return _object.is<TValue>(_key);
   }
 
-  void writeTo(Internals::JsonWriter &writer) const {
+  template <typename TValue>
+  FORCE_INLINE bool set(TValue value) {
+    return _object.set(_key, value);
+  }
+
+  FORCE_INLINE JsonVariant get() { return _object.get(_key); }
+
+  void writeTo(Internals::JsonWriter& writer) const {
     _object.get(_key).writeTo(writer);
   }
 
  private:
   JsonObject& _object;
-  JsonObjectKey _key;
+  TKey _key;
 };
 
 #ifdef ARDUINOJSON_ENABLE_STD_STREAM
-inline std::ostream& operator<<(std::ostream& os, const JsonObjectSubscript& source) {
+inline std::ostream& operator<<(
+    std::ostream& os, const JsonObjectSubscript<const String&>& source) {
+  return source.printTo(os);
+}
+
+inline std::ostream& operator<<(
+    std::ostream& os, const JsonObjectSubscript<const char*>& source) {
   return source.printTo(os);
 }
 #endif

include/ArduinoJson/JsonSubscriptBase.hpp

@@ -0,0 +1,82 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "JsonVariantBase.hpp"
+
+namespace ArduinoJson {
+
+template <typename TImpl>
+class JsonSubscriptBase : public JsonVariantBase<TImpl> {
+ public:
+  FORCE_INLINE TImpl& operator=(bool value) { return assign<bool>(value); }
+
+  FORCE_INLINE TImpl& operator=(float value) { return assign<float>(value); }
+
+  FORCE_INLINE TImpl& operator=(double value) { return assign<double>(value); }
+
+  FORCE_INLINE TImpl& operator=(signed char value) {
+    return assign<signed char>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(signed long value) {
+    return assign<signed long>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(signed int value) {
+    return assign<signed int>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(signed short value) {
+    return assign<signed short>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(unsigned char value) {
+    return assign<unsigned char>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(unsigned long value) {
+    return assign<unsigned long>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(unsigned int value) {
+    return assign<unsigned int>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(unsigned short value) {
+    return assign<unsigned short>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(const char* value) {
+    return assign<const char*>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(const String& value) {
+    return assign<const String&>(value);
+  }
+
+  FORCE_INLINE TImpl& operator=(JsonArray& array) {
+    return assign<JsonArray&>(array);
+  }
+
+  FORCE_INLINE TImpl& operator=(JsonObject& object) {
+    return assign<JsonObject&>(object);
+  }
+
+  FORCE_INLINE TImpl& operator=(JsonVariant value) {
+    return assign<JsonVariant>(value);
+  }
+
+ private:
+  template <typename TValue>
+  FORCE_INLINE TImpl& assign(TValue value) {
+    TImpl* impl = static_cast<TImpl*>(this);
+    impl->template set<TValue>(value);
+    return *impl;
+  }
+};
+}

include/ArduinoJson/JsonVariant.hpp

@@ -9,10 +9,10 @@
 #include <stddef.h>
 #include <stdint.h>  // for uint8_t
 
-#include "Arduino/String.hpp"
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/JsonVariantContent.hpp"
 #include "Internals/JsonVariantType.hpp"
+#include "Internals/Unparsed.hpp"
 #include "JsonVariantBase.hpp"
 
 namespace ArduinoJson {
@@ -55,7 +55,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
 
   // Create a JsonVariant containing a string.
   FORCE_INLINE JsonVariant(const char *value);
-  FORCE_INLINE JsonVariant(const String &value);
+
+  // Create a JsonVariant containing an unparsed string
+  FORCE_INLINE JsonVariant(Internals::Unparsed value);
 
   // Create a JsonVariant containing a reference to an array.
   FORCE_INLINE JsonVariant(JsonArray &array);
@@ -66,12 +68,12 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   // Get the variant as the specified type.
   // See cast operators for details.
   template <typename T>
-  FORCE_INLINE T as() const;
+  T as() const;
 
   // Tells weither the variant has the specified type.
   // Returns true if the variant has type type T, false otherwise.
   template <typename T>
-  FORCE_INLINE bool is() const;
+  bool is() const;
 
   // Serialize the variant to a JsonWriter
   void writeTo(Internals::JsonWriter &writer) const;

include/ArduinoJson/JsonVariant.ipp

@@ -12,7 +12,7 @@ namespace ArduinoJson {
 
 inline JsonVariant::JsonVariant(bool value) {
   _type = Internals::JSON_BOOLEAN;
-  _content.asBoolean = value;
+  _content.asLong = value;
 }
 
 inline JsonVariant::JsonVariant(const char *value) {
@@ -20,9 +20,9 @@ inline JsonVariant::JsonVariant(const char *value) {
   _content.asString = value;
 }
 
-inline JsonVariant::JsonVariant(const String &value) {
-  _type = Internals::JSON_STRING;
-  _content.asString = value.c_str();
+inline JsonVariant::JsonVariant(Internals::Unparsed value) {
+  _type = Internals::JSON_UNPARSED;
+  _content.asString = value;
 }
 
 inline JsonVariant::JsonVariant(double value, uint8_t decimals) {
@@ -87,9 +87,61 @@ inline JsonVariant::JsonVariant(unsigned short value) {
   _content.asLong = value;
 }
 
-template <typename T>
-inline T JsonVariant::as() const {
-  return is<T>() ? _content.as<T>() : invalid<T>();
+template <>
+double JsonVariant::as<double>() const;
+
+template <>
+long JsonVariant::as<long>() const;
+
+template <>
+String JsonVariant::as<String>() const;
+
+template <>
+const char *JsonVariant::as<const char *>() const;
+
+template <>
+inline bool JsonVariant::as<bool>() const {
+  return as<long>();
+}
+
+template <>
+inline signed char JsonVariant::as<signed char>() const {
+  return static_cast<signed char>(as<long>());
+}
+
+template <>
+inline unsigned char JsonVariant::as<unsigned char>() const {
+  return static_cast<unsigned char>(as<long>());
+}
+
+template <>
+inline signed short JsonVariant::as<signed short>() const {
+  return static_cast<signed short>(as<long>());
+}
+
+template <>
+inline unsigned short JsonVariant::as<unsigned short>() const {
+  return static_cast<unsigned short>(as<long>());
+}
+
+template <>
+inline signed int JsonVariant::as<signed int>() const {
+  return static_cast<signed int>(as<long>());
+}
+
+template <>
+inline unsigned int JsonVariant::as<unsigned int>() const {
+  return static_cast<unsigned int>(as<long>());
+}
+
+template <>
+inline unsigned long JsonVariant::as<unsigned long>() const {
+  return static_cast<unsigned long>(as<long>());
+}
+
+template <>
+inline float JsonVariant::as<float>() const {
+  return static_cast<float>(as<double>());
 }
 
 template <typename T>
@@ -102,6 +154,12 @@ inline bool JsonVariant::is() const {
   return false;
 }
 
+template <>  // in .cpp
+bool JsonVariant::is<signed long>() const;
+
+template <>  // in .cpp
+bool JsonVariant::is<double>() const;
+
 template <>
 inline bool JsonVariant::is<bool>() const {
   return _type == Internals::JSON_BOOLEAN;
@@ -112,19 +170,9 @@ inline bool JsonVariant::is<char const *>() const {
   return _type == Internals::JSON_STRING;
 }
 
-template <>
-inline bool JsonVariant::is<String>() const {
-  return _type == Internals::JSON_STRING;
-}
-
-template <>
-inline bool JsonVariant::is<double>() const {
-  return _type >= Internals::JSON_DOUBLE_0_DECIMALS;
-}
-
 template <>
 inline bool JsonVariant::is<float>() const {
-  return _type >= Internals::JSON_DOUBLE_0_DECIMALS;
+  return is<double>();
 }
 
 template <>
@@ -149,48 +197,43 @@ inline bool JsonVariant::is<JsonObject const &>() const {
 
 template <>
 inline bool JsonVariant::is<signed char>() const {
-  return _type == Internals::JSON_LONG;
+  return is<signed long>();
 }
 
 template <>
 inline bool JsonVariant::is<signed int>() const {
-  return _type == Internals::JSON_LONG;
-}
-
-template <>
-inline bool JsonVariant::is<signed long>() const {
-  return _type == Internals::JSON_LONG;
+  return is<signed long>();
 }
 
 template <>
 inline bool JsonVariant::is<signed short>() const {
-  return _type == Internals::JSON_LONG;
+  return is<signed long>();
 }
 
 template <>
 inline bool JsonVariant::is<unsigned char>() const {
-  return _type == Internals::JSON_LONG;
+  return is<signed long>();
 }
 
 template <>
 inline bool JsonVariant::is<unsigned int>() const {
-  return _type == Internals::JSON_LONG;
+  return is<signed long>();
 }
 
 template <>
 inline bool JsonVariant::is<unsigned long>() const {
-  return _type == Internals::JSON_LONG;
+  return is<signed long>();
 }
 
 template <>
 inline bool JsonVariant::is<unsigned short>() const {
-  return _type == Internals::JSON_LONG;
+  return is<signed long>();
 }
 
 #ifdef ARDUINOJSON_ENABLE_STD_STREAM
-inline std::ostream& operator<<(std::ostream& os, const JsonVariant& source) {
+inline std::ostream &operator<<(std::ostream &os, const JsonVariant &source) {
   return source.printTo(os);
 }
 #endif
 
-} // namespace ArduinoJson
+}  // namespace ArduinoJson

include/ArduinoJson/JsonVariantBase.hpp

@@ -13,6 +13,7 @@ namespace ArduinoJson {
 
 // Forward declarations.
 class JsonArraySubscript;
+template <typename TKey>
 class JsonObjectSubscript;
 
 template <typename TImpl>
@@ -76,8 +77,10 @@ class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
   // Returns the value associated with the specified key if the variant is
   // an object.
   // Return JsonVariant::invalid() if the variant is not an object.
-  FORCE_INLINE const JsonObjectSubscript operator[](const char *key) const;
-  FORCE_INLINE const JsonObjectSubscript operator[](const String &key) const;
+  FORCE_INLINE const JsonObjectSubscript<const char *> operator[](
+      const char *key) const;
+  FORCE_INLINE const JsonObjectSubscript<const String &> operator[](
+      const String &key) const;
 
   // Serialize the variant to a JsonWriter
   void writeTo(Internals::JsonWriter &writer) const;

scripts/build-arduino-package.sh

@@ -1,22 +1,21 @@
-#!/bin/bash
-
-ZIP="C:\Program Files\7-Zip\7z.exe"
-TAG=$(git describe)
-OUTPUT="ArduinoJson-$TAG.zip"
-
-cd ../..
-
-# remove existing file
-rm -f $OUTPUT
-
-# create zip
-"$ZIP" a $OUTPUT \
-	ArduinoJson/CHANGELOG.md \
-	ArduinoJson/examples \
-	ArduinoJson/include \
-	ArduinoJson/keywords.txt \
-	ArduinoJson/library.properties \
-	ArduinoJson/LICENSE.md \
-	ArduinoJson/README.md \
-	ArduinoJson/src	\
-	-x!ArduinoJson/src/CMakeLists.txt
+#!/bin/bash
+
+TAG=$(git describe)
+OUTPUT="ArduinoJson-$TAG.zip"
+
+cd $(dirname $0)/../..
+
+# remove existing file
+rm -f $OUTPUT
+
+# create zip
+7z a $OUTPUT \
+	ArduinoJson/CHANGELOG.md \
+	ArduinoJson/examples \
+	ArduinoJson/include \
+	ArduinoJson/keywords.txt \
+	ArduinoJson/library.properties \
+	ArduinoJson/LICENSE.md \
+	ArduinoJson/README.md \
+	ArduinoJson/src	\
+	-x!ArduinoJson/src/CMakeLists.txt

src/Arduino/Print.cpp

@@ -11,6 +11,12 @@
 #include <math.h>   // for isnan() and isinf()
 #include <stdio.h>  // for sprintf()
 
+// only for GCC 4.9+
+#if defined(__GNUC__) && \
+    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
+#pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
 size_t Print::print(const char s[]) {
   size_t n = 0;
   while (*s) {

src/Arduino/String.cpp

@@ -0,0 +1,31 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#ifndef ARDUINO
+
+#include "../../include/ArduinoJson/Arduino/String.hpp"
+
+#include <stdio.h>  // for sprintf()
+
+String::String(double value, unsigned char digits) {
+  char tmp[32];
+  sprintf(tmp, "%.*f", digits, value);
+  *this = tmp;
+}
+
+String::String(int value) {
+  char tmp[32];
+  sprintf(tmp, "%d", value);
+  *this = tmp;
+}
+
+String::String(long value) {
+  char tmp[32];
+  sprintf(tmp, "%ld", value);
+  *this = tmp;
+}
+
+#endif

src/DynamicJsonBuffer.cpp

@@ -1,79 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#include "../include/ArduinoJson/DynamicJsonBuffer.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-struct DynamicJsonBufferBlockWithoutData {
-  DynamicJsonBufferBlock* next;
-  size_t capacity;
-  size_t size;
-};
-
-
-struct DynamicJsonBufferBlock : DynamicJsonBufferBlockWithoutData {
-  uint8_t data[1];
-};
-}
-}
-
-using namespace ArduinoJson;
-using namespace ArduinoJson::Internals;
-
-DynamicJsonBuffer::DynamicJsonBuffer() {
-  _head = createBlock(FIRST_BLOCK_CAPACITY);
-}
-
-DynamicJsonBuffer::~DynamicJsonBuffer() {
-  Block* currentBlock = _head;
-
-  while (currentBlock != NULL) {
-    Block* nextBlock = currentBlock->next;
-    free(currentBlock);
-    currentBlock = nextBlock;
-  }
-}
-
-size_t DynamicJsonBuffer::size() const {
-  size_t total = 0;
-
-  for (const Block* b = _head; b != NULL; b = b->next) {
-    total += b->size;
-  }
-
-  return total;
-}
-
-void* DynamicJsonBuffer::alloc(size_t bytes) {
-  if (!canAllocInHead(bytes)) addNewBlock();
-  return allocInHead(bytes);
-}
-
-bool DynamicJsonBuffer::canAllocInHead(size_t bytes) const {
-  return _head->size + bytes <= _head->capacity;
-}
-
-void* DynamicJsonBuffer::allocInHead(size_t bytes) {
-  void* p = _head->data + _head->size;
-  _head->size += bytes;
-  return p;
-}
-
-void DynamicJsonBuffer::addNewBlock() {
-  Block* block = createBlock(_head->capacity * 2);
-  block->next = _head;
-  _head = block;
-}
-
-DynamicJsonBuffer::Block* DynamicJsonBuffer::createBlock(size_t capacity) {
-  size_t blkSize = sizeof(DynamicJsonBufferBlockWithoutData) + capacity;
-  Block* block = static_cast<Block*>(malloc(blkSize));
-  block->capacity = capacity;
-  block->size = 0;
-  block->next = NULL;
-  return block;
-}

src/Internals/Comments.cpp

@@ -0,0 +1,51 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/Comments.hpp"
+
+inline static const char *skipCStyleComment(const char *ptr) {
+  ptr += 2;
+  for (;;) {
+    if (ptr[0] == '\0') return ptr;
+    if (ptr[0] == '*' && ptr[1] == '/') return ptr + 2;
+    ptr++;
+  }
+}
+
+inline static const char *skipCppStyleComment(const char *ptr) {
+  ptr += 2;
+  for (;;) {
+    if (ptr[0] == '\0' || ptr[0] == '\n') return ptr;
+    ptr++;
+  }
+}
+
+const char *ArduinoJson::Internals::skipSpacesAndComments(const char *ptr) {
+  for (;;) {
+    switch (ptr[0]) {
+      case ' ':
+      case '\t':
+      case '\r':
+      case '\n':
+        ptr++;
+        continue;
+      case '/':
+        switch (ptr[1]) {
+          case '*':
+            ptr = skipCStyleComment(ptr);
+            break;
+          case '/':
+            ptr = skipCppStyleComment(ptr);
+            break;
+          default:
+            return ptr;
+        }
+        break;
+      default:
+        return ptr;
+    }
+  }
+}

src/Internals/JsonParser.cpp

@@ -6,9 +6,7 @@
 
 #include "../../include/ArduinoJson/Internals/JsonParser.hpp"
 
-#include <stdlib.h>  // for strtol, strtod
-#include <ctype.h>
-
+#include "../../include/ArduinoJson/Internals/Comments.hpp"
 #include "../../include/ArduinoJson/Internals/Encoding.hpp"
 #include "../../include/ArduinoJson/JsonArray.hpp"
 #include "../../include/ArduinoJson/JsonBuffer.hpp"
@@ -17,27 +15,11 @@
 using namespace ArduinoJson;
 using namespace ArduinoJson::Internals;
 
-static const char *skipSpaces(const char *ptr) {
-  while (isspace(*ptr)) ptr++;
-  return ptr;
-}
-
 bool JsonParser::skip(char charToSkip) {
-  register const char *ptr = skipSpaces(_readPtr);
+  register const char *ptr = skipSpacesAndComments(_readPtr);
   if (*ptr != charToSkip) return false;
   ptr++;
-  _readPtr = skipSpaces(ptr);
-  return true;
-}
-
-bool JsonParser::skip(const char *wordToSkip) {
-  register const char *ptr = _readPtr;
-  while (*wordToSkip && *ptr == *wordToSkip) {
-    wordToSkip++;
-    ptr++;
-  }
-  if (*wordToSkip != '\0') return false;
-  _readPtr = ptr;
+  _readPtr = skipSpacesAndComments(ptr);
   return true;
 }
 
@@ -50,7 +32,7 @@ bool JsonParser::parseAnythingTo(JsonVariant *destination) {
 }
 
 inline bool JsonParser::parseAnythingToUnsafe(JsonVariant *destination) {
-  _readPtr = skipSpaces(_readPtr);
+  _readPtr = skipSpacesAndComments(_readPtr);
 
   switch (*_readPtr) {
     case '[':
@@ -59,27 +41,6 @@ inline bool JsonParser::parseAnythingToUnsafe(JsonVariant *destination) {
     case '{':
       return parseObjectTo(destination);
 
-    case 't':
-    case 'f':
-      return parseBooleanTo(destination);
-
-    case '-':
-    case '.':
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-      return parseNumberTo(destination);
-
-    case 'n':
-      return parseNullTo(destination);
-
     default:
       return parseStringTo(destination);
   }
@@ -170,51 +131,16 @@ bool JsonParser::parseObjectTo(JsonVariant *destination) {
   return true;
 }
 
-bool JsonParser::parseBooleanTo(JsonVariant *destination) {
-  if (skip("true")) {
-    *destination = true;
-    return true;
-  } else if (skip("false")) {
-    *destination = false;
-    return true;
-  } else {
-    return false;
-  }
+static inline bool isInRange(char c, char min, char max) {
+  return min <= c && c <= max;
 }
 
-bool JsonParser::parseNumberTo(JsonVariant *destination) {
-  char *endOfLong;
-  long longValue = strtol(_readPtr, &endOfLong, 10);
-  char stopChar = *endOfLong;
-
-  // Could it be a floating point value?
-  bool couldBeFloat = stopChar == '.' || stopChar == 'e' || stopChar == 'E';
-
-  if (couldBeFloat) {
-    // Yes => parse it as a double
-    double doubleValue = strtod(_readPtr, const_cast<char **>(&_readPtr));
-    // Count the decimal digits
-    uint8_t decimals = static_cast<uint8_t>(_readPtr - endOfLong - 1);
-    // Set the variant as a double
-    *destination = JsonVariant(doubleValue, decimals);
-  } else {
-    // No => set the variant as a long
-    _readPtr = endOfLong;
-    *destination = longValue;
-  }
-  return true;
+static inline bool isLetterOrNumber(char c) {
+  return isInRange(c, '0', '9') || isInRange(c, 'a', 'z') ||
+         isInRange(c, 'A', 'Z') || c == '-' || c == '.';
 }
 
-bool JsonParser::parseNullTo(JsonVariant *destination) {
-  const char *NULL_STRING = NULL;
-  if (!skip("null")) return false;
-  *destination = NULL_STRING;
-  return true;
-}
-
-static bool isStopChar(char c) {
-  return c == '\0' || c == ':' || c == '}' || c == ']' || c == ',';
-}
+static inline bool isQuote(char c) { return c == '\'' || c == '\"'; }
 
 const char *JsonParser::parseString() {
   const char *readPtr = _readPtr;
@@ -222,7 +148,7 @@ const char *JsonParser::parseString() {
 
   char c = *readPtr;
 
-  if (c == '\'' || c == '\"') {
+  if (isQuote(c)) {  // quotes
     char stopChar = c;
     for (;;) {
       c = *++readPtr;
@@ -241,9 +167,9 @@ const char *JsonParser::parseString() {
 
       *writePtr++ = c;
     }
-  } else {
+  } else {  // no quotes
     for (;;) {
-      if (isStopChar(c)) break;
+      if (!isLetterOrNumber(c)) break;
       *writePtr++ = c;
       c = *++readPtr;
     }
@@ -262,7 +188,13 @@ const char *JsonParser::parseString() {
 }
 
 bool JsonParser::parseStringTo(JsonVariant *destination) {
+  bool hasQuotes = isQuote(_readPtr[0]);
   const char *value = parseString();
-  *destination = value;
-  return value != NULL;
+  if (value == NULL) return false;
+  if (hasQuotes) {
+    *destination = value;
+  } else {
+    *destination = Unparsed(value);
+  }
+  return true;
 }

src/Internals/StaticStringBuilder.cpp

@@ -4,11 +4,11 @@
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
 
-#include "../../include/ArduinoJson/Internals/StringBuilder.hpp"
+#include "../../include/ArduinoJson/Internals/StaticStringBuilder.hpp"
 
 using namespace ArduinoJson::Internals;
 
-size_t StringBuilder::write(uint8_t c) {
+size_t StaticStringBuilder::write(uint8_t c) {
   if (length >= capacity) return 0;
 
   buffer[length++] = c;

src/JsonBuffer.cpp

@@ -32,3 +32,10 @@ JsonObject &JsonBuffer::parseObject(char *json, uint8_t nestingLimit) {
   JsonParser parser(this, json, nestingLimit);
   return parser.parseObject();
 }
+
+char *JsonBuffer::strdup(const char *source, size_t length) {
+  size_t size = length + 1;
+  char *dest = static_cast<char *>(alloc(size));
+  if (dest != NULL) memcpy(dest, source, size);
+  return dest;
+}

src/JsonObject.cpp

@@ -8,7 +8,7 @@
 
 #include <string.h>  // for strcmp
 
-#include "../include/ArduinoJson/Internals/StringBuilder.hpp"
+#include "../include/ArduinoJson/Internals/StaticStringBuilder.hpp"
 #include "../include/ArduinoJson/JsonArray.hpp"
 #include "../include/ArduinoJson/JsonBuffer.hpp"
 
@@ -25,19 +25,25 @@ JsonObject::node_type *JsonObject::getOrCreateNodeAt(JsonObjectKey key) {
   return newNode;
 }
 
-JsonArray &JsonObject::createNestedArray(JsonObjectKey key) {
+template <typename TKey>
+JsonArray &JsonObject::createArrayAt(TKey key) {
   if (!_buffer) return JsonArray::invalid();
   JsonArray &array = _buffer->createArray();
-  set(key, array);
+  setNodeAt<TKey, const JsonVariant &>(key, array);
   return array;
 }
+template JsonArray &JsonObject::createArrayAt<const char *>(const char *);
+template JsonArray &JsonObject::createArrayAt<const String &>(const String &);
 
-JsonObject &JsonObject::createNestedObject(JsonObjectKey key) {
+template <typename TKey>
+JsonObject &JsonObject::createObjectAt(TKey key) {
   if (!_buffer) return JsonObject::invalid();
-  JsonObject &object = _buffer->createObject();
-  set(key, object);
-  return object;
+  JsonObject &array = _buffer->createObject();
+  setNodeAt<TKey, const JsonVariant &>(key, array);
+  return array;
 }
+template JsonObject &JsonObject::createObjectAt<const char *>(const char *);
+template JsonObject &JsonObject::createObjectAt<const String &>(const String &);
 
 JsonObject::node_type *JsonObject::getNodeAt(JsonObjectKey key) const {
   for (node_type *node = _firstNode; node; node = node->next) {

src/JsonVariant.cpp

@@ -9,22 +9,111 @@
 #include "../include/ArduinoJson/JsonArray.hpp"
 #include "../include/ArduinoJson/JsonObject.hpp"
 
-using namespace ArduinoJson;
+#include <errno.h>   // for errno
+#include <stdlib.h>  // for strtol, strtod
+
 using namespace ArduinoJson::Internals;
 
-void JsonVariant::writeTo(JsonWriter &writer) const {
-  if (is<const JsonArray &>())
-    as<const JsonArray &>().writeTo(writer);
-  else if (is<const JsonObject &>())
-    as<const JsonObject &>().writeTo(writer);
-  else if (is<const char *>())
-    writer.writeString(as<const char *>());
-  else if (is<long>())
-    writer.writeLong(as<long>());
-  else if (is<bool>())
-    writer.writeBoolean(as<bool>());
-  else if (is<double>()) {
+namespace ArduinoJson {
+
+template <>
+const char *JsonVariant::as<const char *>() const {
+  if (_type == JSON_UNPARSED && _content.asString &&
+      !strcmp("null", _content.asString))
+    return NULL;
+  if (_type == JSON_STRING || _type == JSON_UNPARSED) return _content.asString;
+  return NULL;
+}
+
+template <>
+double JsonVariant::as<double>() const {
+  if (_type >= JSON_DOUBLE_0_DECIMALS) return _content.asDouble;
+
+  if (_type == JSON_LONG || _type == JSON_BOOLEAN)
+    return static_cast<double>(_content.asLong);
+
+  if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString)
+    return strtod(_content.asString, NULL);
+
+  return 0.0;
+}
+
+template <>
+long JsonVariant::as<long>() const {
+  if (_type == JSON_LONG || _type == JSON_BOOLEAN) return _content.asLong;
+
+  if (_type >= JSON_DOUBLE_0_DECIMALS)
+    return static_cast<long>(_content.asDouble);
+
+  if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString) {
+    if (!strcmp("true", _content.asString)) return 1;
+    return strtol(_content.asString, NULL, 10);
+  }
+
+  return 0L;
+}
+
+template <>
+String JsonVariant::as<String>() const {
+  if ((_type == JSON_STRING || _type == JSON_UNPARSED) &&
+      _content.asString != NULL)
+    return String(_content.asString);
+
+  if (_type == JSON_LONG || _type == JSON_BOOLEAN)
+    return String(_content.asLong);
+
+  if (_type >= JSON_DOUBLE_0_DECIMALS) {
     uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
-    writer.writeDouble(as<double>(), decimals);
+    return String(_content.asDouble, decimals);
+  }
+
+  String s;
+  printTo(s);
+  return s;
+}
+
+template <>
+bool JsonVariant::is<signed long>() const {
+  if (_type == JSON_LONG) return true;
+
+  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
+
+  char *end;
+  errno = 0;
+  strtol(_content.asString, &end, 10);
+
+  return *end == '\0' && errno == 0;
+}
+
+template <>
+bool JsonVariant::is<double>() const {
+  if (_type >= JSON_DOUBLE_0_DECIMALS) return true;
+
+  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
+
+  char *end;
+  errno = 0;
+  strtod(_content.asString, &end);
+
+  return *end == '\0' && errno == 0 && !is<long>();
+}
+
+void JsonVariant::writeTo(JsonWriter &writer) const {
+  if (_type == JSON_ARRAY) _content.asArray->writeTo(writer);
+
+  if (_type == JSON_OBJECT) _content.asObject->writeTo(writer);
+
+  if (_type == JSON_STRING) writer.writeString(_content.asString);
+
+  if (_type == JSON_UNPARSED) writer.writeRaw(_content.asString);
+
+  if (_type == JSON_LONG) writer.writeLong(_content.asLong);
+
+  if (_type == JSON_BOOLEAN) writer.writeBoolean(_content.asLong);
+
+  if (_type >= JSON_DOUBLE_0_DECIMALS) {
+    uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
+    writer.writeDouble(_content.asDouble, decimals);
   }
 }
+}

test/ArduinoString_Tests.cpp

@@ -7,103 +7,194 @@
 #include <gtest/gtest.h>
 #include <ArduinoJson.h>
 
-TEST(ArduinoStringTests, JsonBuffer_ParseArray) {
-  DynamicJsonBuffer jsonBuffer;
-  String json("[1,2]");
-  JsonArray &array = jsonBuffer.parseArray(json);
+class ArduinoStringTests : public ::testing::Test {
+ protected:
+  static void eraseString(String &str) {
+    char *p = const_cast<char *>(str.c_str());
+    while (*p) *p++ = '*';
+  }
+
+  DynamicJsonBuffer _jsonBuffer;
+};
+
+TEST_F(ArduinoStringTests, JsonBuffer_ParseArray) {
+  String json("[\"hello\"]");
+  JsonArray &array = _jsonBuffer.parseArray(json);
+  eraseString(json);
   ASSERT_TRUE(array.success());
+  ASSERT_STREQ("hello", array[0]);
 }
 
-TEST(ArduinoStringTests, JsonBuffer_ParseObject) {
-  DynamicJsonBuffer jsonBuffer;
-  String json("{\"a\":1,\"b\":2}");
-  JsonObject &object = jsonBuffer.parseObject(json);
+TEST_F(ArduinoStringTests, JsonBuffer_ParseObject) {
+  String json("{\"hello\":\"world\"}");
+  JsonObject &object = _jsonBuffer.parseObject(json);
+  eraseString(json);
   ASSERT_TRUE(object.success());
+  ASSERT_STREQ("world", object["hello"]);
 }
 
-TEST(ArduinoStringTests, JsonVariant) {
-  String input = "Hello world!";
-  JsonVariant variant(input);
-  ASSERT_TRUE(variant.is<String>());
-  String output = variant.as<String>();
-  ASSERT_EQ(input, output);
-}
-
-TEST(ArduinoStringTests, JsonObject_Subscript) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_Subscript) {
   char json[] = "{\"key\":\"value\"}";
-  JsonObject &object = jsonBuffer.parseObject(json);
+  JsonObject &object = _jsonBuffer.parseObject(json);
   ASSERT_STREQ("value", object[String("key")]);
 }
 
-TEST(ArduinoStringTests, JsonObject_ConstSubscript) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_ConstSubscript) {
   char json[] = "{\"key\":\"value\"}";
-  const JsonObject &object = jsonBuffer.parseObject(json);
+  const JsonObject &object = _jsonBuffer.parseObject(json);
   ASSERT_STREQ("value", object[String("key")]);
 }
 
-TEST(ArduinoStringTests, JsonObject_Set) {
-  DynamicJsonBuffer jsonBuffer;
-  JsonObject &object = jsonBuffer.createObject();
-  String key = "key";
-  object.set(key, "value");
-  ASSERT_STREQ("value", object["key"]);
+TEST_F(ArduinoStringTests, JsonObject_SetKey) {
+  JsonObject &object = _jsonBuffer.createObject();
+  String key("hello");
+  object.set(key, "world");
+  eraseString(key);
+  ASSERT_STREQ("world", object["hello"]);
 }
 
-TEST(ArduinoStringTests, JsonObject_Get) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_SetValue) {
+  JsonObject &object = _jsonBuffer.createObject();
+  String value("world");
+  object.set("hello", value);
+  eraseString(value);
+  ASSERT_STREQ("world", object["hello"]);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_SetKeyValue) {
+  JsonObject &object = _jsonBuffer.createObject();
+  String key("hello");
+  String value("world");
+  object.set(key, value);
+  eraseString(key);
+  eraseString(value);
+  ASSERT_STREQ("world", object["hello"]);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_Get) {
   char json[] = "{\"key\":\"value\"}";
-  const JsonObject &object = jsonBuffer.parseObject(json);
+  const JsonObject &object = _jsonBuffer.parseObject(json);
   ASSERT_STREQ("value", object.get(String("key")));
 }
 
-TEST(ArduinoStringTests, JsonObject_GetT) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_GetT) {
   char json[] = "{\"key\":\"value\"}";
-  const JsonObject &object = jsonBuffer.parseObject(json);
+  const JsonObject &object = _jsonBuffer.parseObject(json);
   ASSERT_STREQ("value", object.get<const char *>(String("key")));
 }
 
-TEST(ArduinoStringTests, JsonObject_IsT) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_IsT) {
   char json[] = "{\"key\":\"value\"}";
-  const JsonObject &object = jsonBuffer.parseObject(json);
+  const JsonObject &object = _jsonBuffer.parseObject(json);
   ASSERT_TRUE(object.is<const char *>(String("key")));
 }
 
-TEST(ArduinoStringTests, JsonObject_CreateNestedObject) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_CreateNestedObject) {
   String key = "key";
   char json[64];
-  JsonObject &object = jsonBuffer.createObject();
+  JsonObject &object = _jsonBuffer.createObject();
   object.createNestedObject(key);
+  eraseString(key);
   object.printTo(json, sizeof(json));
   ASSERT_STREQ("{\"key\":{}}", json);
 }
 
-TEST(ArduinoStringTests, JsonObject_CreateNestedArray) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_CreateNestedArray) {
   String key = "key";
   char json[64];
-  JsonObject &object = jsonBuffer.createObject();
+  JsonObject &object = _jsonBuffer.createObject();
   object.createNestedArray(key);
+  eraseString(key);
   object.printTo(json, sizeof(json));
   ASSERT_STREQ("{\"key\":[]}", json);
 }
 
-TEST(ArduinoStringTests, JsonObject_ContainsKey) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_ContainsKey) {
   char json[] = "{\"key\":\"value\"}";
-  const JsonObject &object = jsonBuffer.parseObject(json);
+  const JsonObject &object = _jsonBuffer.parseObject(json);
   ASSERT_TRUE(object.containsKey(String("key")));
 }
 
-TEST(ArduinoStringTests, JsonObject_Remove) {
-  DynamicJsonBuffer jsonBuffer;
+TEST_F(ArduinoStringTests, JsonObject_Remove) {
   char json[] = "{\"key\":\"value\"}";
-  JsonObject &object = jsonBuffer.parseObject(json);
+  JsonObject &object = _jsonBuffer.parseObject(json);
   ASSERT_EQ(1, object.size());
   object.remove(String("key"));
   ASSERT_EQ(0, object.size());
-}
+}
+
+TEST_F(ArduinoStringTests, JsonObjectSubscript_SetKey) {
+  JsonObject &object = _jsonBuffer.createObject();
+  String key("hello");
+  object[key] = "world";
+  eraseString(key);
+  ASSERT_STREQ("world", object["hello"]);
+}
+
+TEST_F(ArduinoStringTests, JsonObjectSubscript_SetValue) {
+  JsonObject &object = _jsonBuffer.createObject();
+  String value("world");
+  object["hello"] = value;
+  eraseString(value);
+  ASSERT_STREQ("world", object["hello"]);
+}
+
+TEST_F(ArduinoStringTests, JsonArray_Add) {
+  JsonArray &array = _jsonBuffer.createArray();
+  String value("hello");
+  array.add(value);
+  eraseString(value);
+  ASSERT_STREQ("hello", array[0]);
+}
+
+TEST_F(ArduinoStringTests, JsonArray_Set) {
+  JsonArray &array = _jsonBuffer.createArray();
+  String value("world");
+  array.add("hello");
+  array.set(0, value);
+  eraseString(value);
+  ASSERT_STREQ("world", array[0]);
+}
+
+TEST_F(ArduinoStringTests, JsonArraySubscript) {
+  JsonArray &array = _jsonBuffer.createArray();
+  String value("world");
+  array.add("hello");
+  array[0] = value;
+  eraseString(value);
+  ASSERT_STREQ("world", array[0]);
+}
+
+TEST_F(ArduinoStringTests, JsonArray_PrintTo) {
+  JsonArray &array = _jsonBuffer.createArray();
+  array.add(4);
+  array.add(2);
+  String json;
+  array.printTo(json);
+  ASSERT_EQ(String("[4,2]"), json);
+}
+
+TEST_F(ArduinoStringTests, JsonArray_PrettyPrintTo) {
+  JsonArray &array = _jsonBuffer.createArray();
+  array.add(4);
+  array.add(2);
+  String json;
+  array.prettyPrintTo(json);
+  ASSERT_EQ(String("[\r\n  4,\r\n  2\r\n]"), json);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_PrintTo) {
+  JsonObject &object = _jsonBuffer.createObject();
+  object["key"] = "value";
+  String json;
+  object.printTo(json);
+  ASSERT_EQ(String("{\"key\":\"value\"}"), json);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_PrettyPrintTo) {
+  JsonObject &object = _jsonBuffer.createObject();
+  object["key"] = "value";
+  String json;
+  object.prettyPrintTo(json);
+  ASSERT_EQ(String("{\r\n  \"key\": \"value\"\r\n}"), json);
+}

test/DynamicJsonBuffer_NoMemory_Tests.cpp

@@ -0,0 +1,37 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class DynamicJsonBuffer_NoMemory_Tests : public ::testing::Test {
+  class NoMemoryAllocator {
+   public:
+    void* allocate(size_t) { return NULL; }
+    void deallocate(void*) {}
+  };
+
+ protected:
+  Internals::BlockJsonBuffer<NoMemoryAllocator> _jsonBuffer;
+};
+
+TEST_F(DynamicJsonBuffer_NoMemory_Tests, CreateArray) {
+  ASSERT_FALSE(_jsonBuffer.createArray().success());
+}
+
+TEST_F(DynamicJsonBuffer_NoMemory_Tests, CreateObject) {
+  ASSERT_FALSE(_jsonBuffer.createObject().success());
+}
+
+TEST_F(DynamicJsonBuffer_NoMemory_Tests, ParseArray) {
+  char json[] = "[]";
+  ASSERT_FALSE(_jsonBuffer.parseArray(json).success());
+}
+
+TEST_F(DynamicJsonBuffer_NoMemory_Tests, ParseObject) {
+  char json[] = "{}";
+  ASSERT_FALSE(_jsonBuffer.parseObject(json).success());
+}

test/Issue90.cpp

@@ -0,0 +1,28 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <limits.h>  // for LONG_MAX
+#define ARDUINOJSON_ENABLE_STD_STREAM
+#include <ArduinoJson.h>
+
+#define SUITE Issue90
+
+using namespace ArduinoJson::Internals;
+
+static const char* superLong =
+    "12345678901234567890123456789012345678901234567890123456789012345678901234"
+    "5678901234567890123456789012345678901234567890123456789012345678901234567";
+
+static const JsonVariant variant = Unparsed(superLong);
+
+TEST(SUITE, IsNotALong) { ASSERT_FALSE(variant.is<long>()); }
+
+TEST(SUITE, AsLong) { ASSERT_EQ(LONG_MAX, variant.as<long>()); }
+
+TEST(SUITE, IsAString) { ASSERT_FALSE(variant.is<const char*>()); }
+
+TEST(SUITE, AsString) { ASSERT_STREQ(superLong, variant.as<const char*>()); }

test/JsonObject_Container_Tests.cpp

@@ -59,7 +59,7 @@ TEST_F(JsonObject_Container_Tests,
 
 TEST_F(JsonObject_Container_Tests, CanStoreIntegers) {
   _object["hello"] = 123;
-  _object["world"] = 456;
+  _object.set("world", 456);
 
   EXPECT_EQ(123, _object["hello"].as<int>());
   EXPECT_EQ(456, _object["world"].as<int>());
@@ -67,7 +67,7 @@ TEST_F(JsonObject_Container_Tests, CanStoreIntegers) {
 
 TEST_F(JsonObject_Container_Tests, CanStoreDoubles) {
   _object["hello"] = 123.45;
-  _object["world"] = 456.78;
+  _object.set("world", 456.78);
 
   EXPECT_EQ(123.45, _object["hello"].as<double>());
   EXPECT_EQ(456.78, _object["world"].as<double>());
@@ -75,7 +75,7 @@ TEST_F(JsonObject_Container_Tests, CanStoreDoubles) {
 
 TEST_F(JsonObject_Container_Tests, CanStoreBooleans) {
   _object["hello"] = true;
-  _object["world"] = false;
+  _object.set("world", false);
 
   EXPECT_TRUE(_object["hello"].as<bool>());
   EXPECT_FALSE(_object["world"].as<bool>());
@@ -83,32 +83,32 @@ TEST_F(JsonObject_Container_Tests, CanStoreBooleans) {
 
 TEST_F(JsonObject_Container_Tests, CanStoreStrings) {
   _object["hello"] = "h3110";
-  _object["world"] = "w0r1d";
+  _object.set("world", "w0r1d");
 
   EXPECT_STREQ("h3110", _object["hello"].as<const char*>());
   EXPECT_STREQ("w0r1d", _object["world"].as<const char*>());
 }
 
-TEST_F(JsonObject_Container_Tests, CanStoreInnerArrays) {
-  JsonArray& innerarray1 = _jsonBuffer.createArray();
-  JsonArray& innerarray2 = _jsonBuffer.createArray();
+TEST_F(JsonObject_Container_Tests, CanStoreArrays) {
+  JsonArray& array1 = _jsonBuffer.createArray();
+  JsonArray& array2 = _jsonBuffer.createArray();
 
-  _object["hello"] = innerarray1;
-  _object["world"] = innerarray2;
+  _object["hello"] = array1;
+  _object.set("world", array2);
 
-  EXPECT_EQ(&innerarray1, &_object["hello"].asArray());
-  EXPECT_EQ(&innerarray2, &_object["world"].asArray());
+  EXPECT_EQ(&array1, &_object["hello"].asArray());
+  EXPECT_EQ(&array2, &_object["world"].asArray());
 }
 
-TEST_F(JsonObject_Container_Tests, CanStoreInnerObjects) {
-  JsonObject& innerObject1 = _jsonBuffer.createObject();
-  JsonObject& innerObject2 = _jsonBuffer.createObject();
+TEST_F(JsonObject_Container_Tests, CanStoreObjects) {
+  JsonObject& object1 = _jsonBuffer.createObject();
+  JsonObject& object2 = _jsonBuffer.createObject();
 
-  _object["hello"] = innerObject1;
-  _object["world"] = innerObject2;
+  _object["hello"] = object1;
+  _object.set("world", object2);
 
-  EXPECT_EQ(&innerObject1, &_object["hello"].asObject());
-  EXPECT_EQ(&innerObject2, &_object["world"].asObject());
+  EXPECT_EQ(&object1, &_object["hello"].asObject());
+  EXPECT_EQ(&object2, &_object["world"].asObject());
 }
 
 TEST_F(JsonObject_Container_Tests, ContainsKeyReturnsFalseForNonExistingKey) {

test/JsonObject_PrintTo_Tests.cpp

@@ -11,131 +11,105 @@ using namespace ArduinoJson::Internals;
 
 class JsonObject_PrintTo_Tests : public testing::Test {
  public:
-  JsonObject_PrintTo_Tests() : object(json.createObject()) {}
+  JsonObject_PrintTo_Tests() : _object(_jsonBuffer.createObject()) {}
 
  protected:
   void outputMustBe(const char *expected) {
     char actual[256];
-    size_t actualLen = object.printTo(actual, sizeof(actual));
-    size_t measuredLen = object.measureLength();
+    size_t actualLen = _object.printTo(actual, sizeof(actual));
+    size_t measuredLen = _object.measureLength();
 
     EXPECT_STREQ(expected, actual);
     EXPECT_EQ(strlen(expected), actualLen);
     EXPECT_EQ(strlen(expected), measuredLen);
   }
 
-  StaticJsonBuffer<JSON_OBJECT_SIZE(2)> json;
-  JsonObject &object;
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject &_object;
 };
 
 TEST_F(JsonObject_PrintTo_Tests, EmptyObject) { outputMustBe("{}"); }
 
-TEST_F(JsonObject_PrintTo_Tests, OneString) {
-  object["key"] = "value";
-
-  outputMustBe("{\"key\":\"value\"}");
-}
-
 TEST_F(JsonObject_PrintTo_Tests, TwoStrings) {
-  object["key1"] = "value1";
-  object["key2"] = "value2";
+  _object["key1"] = "value1";
+  _object.set("key2", "value2");
 
   outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
 }
 
 TEST_F(JsonObject_PrintTo_Tests, RemoveFirst) {
-  object["key1"] = "value1";
-  object["key2"] = "value2";
-  object.remove("key1");
+  _object["key1"] = "value1";
+  _object["key2"] = "value2";
+  _object.remove("key1");
 
   outputMustBe("{\"key2\":\"value2\"}");
 }
 
 TEST_F(JsonObject_PrintTo_Tests, RemoveLast) {
-  object["key1"] = "value1";
-  object["key2"] = "value2";
-  object.remove("key2");
+  _object["key1"] = "value1";
+  _object["key2"] = "value2";
+  _object.remove("key2");
 
   outputMustBe("{\"key1\":\"value1\"}");
 }
 
 TEST_F(JsonObject_PrintTo_Tests, RemoveUnexistingKey) {
-  object["key1"] = "value1";
-  object["key2"] = "value2";
-  object.remove("key3");
+  _object["key1"] = "value1";
+  _object["key2"] = "value2";
+  _object.remove("key3");
 
   outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
 }
 
 TEST_F(JsonObject_PrintTo_Tests, ReplaceExistingKey) {
-  object["key"] = "value1";
-  object["key"] = "value2";
+  _object["key"] = "value1";
+  _object["key"] = "value2";
 
   outputMustBe("{\"key\":\"value2\"}");
 }
 
-TEST_F(JsonObject_PrintTo_Tests, OneStringOverCapacity) {
-  object["key1"] = "value1";
-  object["key2"] = "value2";
-  object["key3"] = "value3";
-
-  outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+TEST_F(JsonObject_PrintTo_Tests, TwoIntegers) {
+  _object["a"] = 1;
+  _object.set("b", 2);
+  outputMustBe("{\"a\":1,\"b\":2}");
 }
 
-TEST_F(JsonObject_PrintTo_Tests, OneInteger) {
-  object["key"] = 1;
-  outputMustBe("{\"key\":1}");
+TEST_F(JsonObject_PrintTo_Tests, TwoDoublesFourDigits) {
+  _object["a"] = double_with_n_digits(3.14159265358979323846, 4);
+  _object.set("b", 2.71828182845904523536, 4);
+  outputMustBe("{\"a\":3.1416,\"b\":2.7183}");
 }
 
-TEST_F(JsonObject_PrintTo_Tests, OneDoubleFourDigits) {
-  object["key"] = double_with_n_digits(3.14159265358979323846, 4);
-  outputMustBe("{\"key\":3.1416}");
+TEST_F(JsonObject_PrintTo_Tests, TwoDoubleDefaultDigits) {
+  _object["a"] = 3.14159265358979323846;
+  _object.set("b", 2.71828182845904523536);
+  outputMustBe("{\"a\":3.14,\"b\":2.72}");
 }
 
-TEST_F(JsonObject_PrintTo_Tests, OneDoubleDefaultDigits) {
-  object["key"] = 3.14159265358979323846;
-  outputMustBe("{\"key\":3.14}");
+TEST_F(JsonObject_PrintTo_Tests, TwoNull) {
+  _object["a"] = static_cast<char *>(0);
+  _object.set("b", static_cast<char *>(0));
+  outputMustBe("{\"a\":null,\"b\":null}");
 }
 
-TEST_F(JsonObject_PrintTo_Tests, OneNull) {
-  object["key"] = static_cast<char *>(0);
-  outputMustBe("{\"key\":null}");
+TEST_F(JsonObject_PrintTo_Tests, TwoBooleans) {
+  _object["a"] = true;
+  _object.set("b", false);
+  outputMustBe("{\"a\":true,\"b\":false}");
 }
 
-TEST_F(JsonObject_PrintTo_Tests, OneTrue) {
-  object["key"] = true;
-  outputMustBe("{\"key\":true}");
+TEST_F(JsonObject_PrintTo_Tests, ThreeNestedArrays) {
+  _object.createNestedArray("a");
+  _object["b"] = _jsonBuffer.createArray();
+  _object.set("c", _jsonBuffer.createArray());
+
+  outputMustBe("{\"a\":[],\"b\":[],\"c\":[]}");
 }
 
-TEST_F(JsonObject_PrintTo_Tests, OneFalse) {
-  object["key"] = false;
-  outputMustBe("{\"key\":false}");
-}
-
-TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedArrayViaProxy) {
-  JsonArray &nestedArray = json.createArray();
-
-  object["key"] = nestedArray;
-
-  outputMustBe("{\"key\":[]}");
-}
-
-TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedObjectViaProxy) {
-  JsonObject &nestedArray = json.createObject();
-
-  object["key"] = nestedArray;
-
-  outputMustBe("{\"key\":{}}");
-}
-
-TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedObject) {
-  object.createNestedObject("key");
-
-  outputMustBe("{\"key\":{}}");
-}
-
-TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedArray) {
-  object.createNestedArray("key");
-
-  outputMustBe("{\"key\":[]}");
+TEST_F(JsonObject_PrintTo_Tests, ThreeNestedObjects) {
+  _object.createNestedObject("a");
+  _object["b"] = _jsonBuffer.createObject();
+  _object.set("c", _jsonBuffer.createObject());
+
+  outputMustBe("{\"a\":{},\"b\":{},\"c\":{}}");
 }

test/JsonParser_Array_Tests.cpp

@@ -144,28 +144,26 @@ TEST_F(JsonParser_Array_Tests, TwoNulls) {
   secondElementMustBe(nullCharPtr);
 }
 
-TEST_F(JsonParser_Array_Tests, IncompleteNull) {
-  whenInputIs("[nul!]");
-  parseMustFail();
+TEST_F(JsonParser_Array_Tests, TwoStringsDoubleQuotes) {
+  whenInputIs("[ \"hello\" , \"world\" ]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe("hello");
+  secondElementMustBe("world");
 }
 
-TEST_F(JsonParser_Array_Tests, IncompleteTrue) {
-  whenInputIs("[tru!]");
-  parseMustFail();
+TEST_F(JsonParser_Array_Tests, TwoStringsSingleQuotes) {
+  whenInputIs("[ 'hello' , 'world' ]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe("hello");
+  secondElementMustBe("world");
 }
 
-TEST_F(JsonParser_Array_Tests, IncompleteFalse) {
-  whenInputIs("[fals!]");
-  parseMustFail();
-}
-
-TEST_F(JsonParser_Array_Tests, MixedTrueFalse) {
-  whenInputIs("[trufalse]");
-  parseMustFail();
-}
-
-TEST_F(JsonParser_Array_Tests, TwoStrings) {
-  whenInputIs("[\"hello\",\"world\"]");
+TEST_F(JsonParser_Array_Tests, TwoStringsNoQuotes) {
+  whenInputIs("[ hello , world ]");
 
   parseMustSucceed();
   sizeMustBe(2);
@@ -224,3 +222,118 @@ TEST_F(JsonParser_Array_Tests, StringWithUnterminatedEscapeSequence) {
   whenInputIs("\"\\\0\"", 4);
   parseMustFail();
 }
+
+TEST_F(JsonParser_Array_Tests, CCommentBeforeOpeningBracket) {
+  whenInputIs("/*COMMENT*/[\"hello\"]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CCommentAfterOpeningBracket) {
+  whenInputIs("[/*COMMENT*/\"hello\"]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CCommentBeforeClosingBracket) {
+  whenInputIs("[\"hello\"/*COMMENT*/]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CCommentAfterClosingBracket) {
+  whenInputIs("[\"hello\"]/*COMMENT*/");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CCommentBeforeComma) {
+  whenInputIs("[\"hello\"/*COMMENT*/,\"world\"]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe("hello");
+  secondElementMustBe("world");
+}
+
+TEST_F(JsonParser_Array_Tests, CCommentAfterComma) {
+  whenInputIs("[\"hello\",/*COMMENT*/\"world\"]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe("hello");
+  secondElementMustBe("world");
+}
+
+TEST_F(JsonParser_Array_Tests, CppCommentBeforeOpeningBracket) {
+  whenInputIs("//COMMENT\n[\"hello\"]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CppCommentAfterOpeningBracket) {
+  whenInputIs("[//COMMENT\n\"hello\"]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CppCommentBeforeClosingBracket) {
+  whenInputIs("[\"hello\"//COMMENT\n]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CppCommentAfterClosingBracket) {
+  whenInputIs("[\"hello\"]//COMMENT\n");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe("hello");
+}
+
+TEST_F(JsonParser_Array_Tests, CppCommentBeforeComma) {
+  whenInputIs("[\"hello\"//COMMENT\n,\"world\"]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe("hello");
+  secondElementMustBe("world");
+}
+
+TEST_F(JsonParser_Array_Tests, CppCommentAfterComma) {
+  whenInputIs("[\"hello\",//COMMENT\n\"world\"]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe("hello");
+  secondElementMustBe("world");
+}
+
+TEST_F(JsonParser_Array_Tests, InvalidCppComment) {
+  whenInputIs("[/COMMENT\n]");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, InvalidComment) {
+  whenInputIs("[/*/\n]");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, UnfinishedCComment) {
+  whenInputIs("[/*COMMENT]");
+  parseMustFail();
+}

test/JsonVariant_As_Tests.cpp

@@ -0,0 +1,177 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#define ARDUINOJSON_ENABLE_STD_STREAM
+#include <ArduinoJson.h>
+
+static const char* null = 0;
+
+TEST(JsonVariant_As_Tests, DoubleAsBool) {
+  JsonVariant variant = 4.2;
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsCstr) {
+  JsonVariant variant = 4.2;
+  ASSERT_FALSE(variant.as<const char*>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsString) {
+  JsonVariant variant = 4.2;
+  ASSERT_EQ(String("4.20"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsLong) {
+  JsonVariant variant = 4.2;
+  ASSERT_EQ(4L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleZeroAsBool) {
+  JsonVariant variant = 0.0;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleZeroAsLong) {
+  JsonVariant variant = 0.0;
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsBool) {
+  JsonVariant variant = false;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsDouble) {
+  JsonVariant variant = false;
+  ASSERT_EQ(0.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsLong) {
+  JsonVariant variant = false;
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsString) {
+  JsonVariant variant = false;
+  ASSERT_EQ(String("0"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsBool) {
+  JsonVariant variant = true;
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsDouble) {
+  JsonVariant variant = true;
+  ASSERT_EQ(1.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsLong) {
+  JsonVariant variant = true;
+  ASSERT_EQ(1L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsString) {
+  JsonVariant variant = true;
+  ASSERT_EQ(String("1"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, LongAsBool) {
+  JsonVariant variant = 42L;
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, LongZeroAsBool) {
+  JsonVariant variant = 0L;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, LongAsDouble) {
+  JsonVariant variant = 42L;
+  ASSERT_EQ(42.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, LongAsString) {
+  JsonVariant variant = 42L;
+  ASSERT_EQ(String("42"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, LongZeroAsDouble) {
+  JsonVariant variant = 0L;
+  ASSERT_EQ(0.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsBool) {
+  JsonVariant variant = null;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsDouble) {
+  JsonVariant variant = null;
+  ASSERT_EQ(0.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsLong) {
+  JsonVariant variant = null;
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsString) {
+  JsonVariant variant = null;
+  ASSERT_EQ(String("null"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, NumberStringAsBool) {
+  JsonVariant variant = "42";
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, NumberStringAsLong) {
+  JsonVariant variant = "42";
+  ASSERT_EQ(42L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, RandomStringAsBool) {
+  JsonVariant variant = "hello";
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, RandomStringAsLong) {
+  JsonVariant variant = "hello";
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, TrueStringAsBool) {
+  JsonVariant variant = "true";
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, TrueStringAsLong) {
+  JsonVariant variant = "true";
+  ASSERT_EQ(1L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, ObjectAsString) {
+  DynamicJsonBuffer buffer;
+
+  JsonObject& obj = buffer.createObject();
+  obj["key"] = "value";
+
+  JsonVariant variant = obj;
+  ASSERT_EQ(String("{\"key\":\"value\"}"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, ArrayAsString) {
+  DynamicJsonBuffer buffer;
+
+  JsonArray& arr = buffer.createArray();
+  arr.add(4);
+  arr.add(2);
+
+  JsonVariant variant = arr;
+  ASSERT_EQ(String("[4,2]"), variant.as<String>());
+}

test/JsonVariant_Is_Tests.cpp

@@ -0,0 +1,92 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#define ARDUINOJSON_ENABLE_STD_STREAM
+#include <ArduinoJson.h>
+
+#define SUITE JsonVariant_Is_Tests
+
+using namespace ArduinoJson::Internals;
+
+template <typename TTo, typename TFrom>
+void assertIsNot(TFrom value) {
+  JsonVariant variant = value;
+  ASSERT_FALSE(variant.is<TTo>());
+}
+
+template <typename TTo>
+void assertIsNot(JsonArray& value) {
+  JsonVariant variant = value;
+  ASSERT_FALSE(variant.is<TTo>());
+}
+
+template <typename TTo, typename TFrom>
+void assertIs(TFrom value) {
+  JsonVariant variant = value;
+  ASSERT_TRUE(variant.is<TTo>());
+}
+
+template <typename TTo>
+void assertIs(JsonArray& value) {
+  JsonVariant variant = value;
+  ASSERT_TRUE(variant.is<TTo>());
+}
+
+TEST(SUITE, ArrayIsArry) { assertIs<JsonArray&>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsBool) { assertIsNot<bool>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsDouble) { assertIsNot<double>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsFloat) { assertIsNot<float>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsInt) { assertIsNot<int>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsLong) { assertIsNot<long>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsString) { assertIsNot<const char*>(JsonArray::invalid()); }
+
+TEST(SUITE, BoolIsArray) { assertIsNot<JsonArray&>(true); }
+TEST(SUITE, BoolIsBool) { assertIs<bool>(true); }
+TEST(SUITE, BoolIsDouble) { assertIsNot<double>(true); }
+TEST(SUITE, BoolIsFloat) { assertIsNot<float>(true); }
+TEST(SUITE, BoolIsInt) { assertIsNot<int>(true); }
+TEST(SUITE, BoolIsLong) { assertIsNot<long>(true); }
+TEST(SUITE, BoolIsString) { assertIsNot<const char*>(true); }
+
+TEST(SUITE, DoubleIsArray) { assertIsNot<JsonArray&>(4.2); }
+TEST(SUITE, DoubleIsBool) { assertIsNot<bool>(4.2); }
+TEST(SUITE, DoubleIsDouble) { assertIs<double>(4.2); }
+TEST(SUITE, DoubleIsFloat) { assertIs<float>(4.2); }
+TEST(SUITE, DoubleIsInt) { assertIsNot<int>(4.2); }
+TEST(SUITE, DoubleIsLong) { assertIsNot<long>(4.2); }
+TEST(SUITE, DoubleIsString) { assertIsNot<const char*>(4.2); }
+
+TEST(SUITE, LongIsArray) { assertIsNot<JsonArray&>(42L); }
+TEST(SUITE, LongIsBool) { assertIsNot<bool>(42L); }
+TEST(SUITE, LongIsDouble) { assertIsNot<double>(42L); }
+TEST(SUITE, LongIsFloat) { assertIsNot<float>(42L); }
+TEST(SUITE, LongIsInt) { assertIs<int>(42L); }
+TEST(SUITE, LongIsLong) { assertIs<long>(42L); }
+TEST(SUITE, LongIsString) { assertIsNot<const char*>(42L); }
+
+TEST(SUITE, StringIsArray) { assertIsNot<JsonArray&>("42"); }
+TEST(SUITE, StringIsBool) { assertIsNot<bool>("42"); }
+TEST(SUITE, StringIsDouble) { assertIsNot<double>("42"); }
+TEST(SUITE, StringIsFloat) { assertIsNot<float>("42"); }
+TEST(SUITE, StringIsInt) { assertIsNot<int>("42"); }
+TEST(SUITE, StringIsLong) { assertIsNot<long>("42"); }
+TEST(SUITE, StringIsString) { assertIs<const char*>("42"); }
+
+TEST(SUITE, UnparsedIntIsArra) { assertIsNot<JsonArray&>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(Unparsed("42")); }
+
+TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(Unparsed("4.2")); }

test/JsonWriter_WriteString_Tests.cpp

@@ -7,14 +7,14 @@
 #include <gtest/gtest.h>
 
 #include <ArduinoJson/Internals/JsonWriter.hpp>
-#include <ArduinoJson/Internals/StringBuilder.hpp>
+#include <ArduinoJson/Internals/StaticStringBuilder.hpp>
 
 using namespace ArduinoJson::Internals;
 
 class JsonWriter_WriteString_Tests : public testing::Test {
  protected:
   void whenInputIs(const char *input) {
-    StringBuilder sb(buffer, sizeof(buffer));
+    StaticStringBuilder sb(buffer, sizeof(buffer));
     JsonWriter writer(sb);
     writer.writeString(input);
     returnValue = writer.bytesWritten();

test/StaticJsonBuffer_CreateObject_Tests.cpp

@@ -8,44 +8,49 @@
 #include <ArduinoJson.h>
 
 TEST(StaticJsonBuffer_CreateObject_Tests, GrowsWithObject) {
-  StaticJsonBuffer<JSON_OBJECT_SIZE(3)> json;
+  StaticJsonBuffer<JSON_OBJECT_SIZE(3)> buffer;
 
-  JsonObject &obj = json.createObject();
-  ASSERT_EQ(JSON_OBJECT_SIZE(0), json.size());
+  JsonObject &obj = buffer.createObject();
+  ASSERT_EQ(JSON_OBJECT_SIZE(0), buffer.size());
 
   obj["hello"];
-  ASSERT_EQ(JSON_OBJECT_SIZE(0), json.size());
+  ASSERT_EQ(JSON_OBJECT_SIZE(0), buffer.size());
 
   obj["hello"] = 1;
-  ASSERT_EQ(JSON_OBJECT_SIZE(1), json.size());
+  ASSERT_EQ(JSON_OBJECT_SIZE(1), buffer.size());
 
   obj["world"] = 2;
-  ASSERT_EQ(JSON_OBJECT_SIZE(2), json.size());
+  ASSERT_EQ(JSON_OBJECT_SIZE(2), buffer.size());
 
   obj["world"] = 3;  // <- same key, should not grow
-  ASSERT_EQ(JSON_OBJECT_SIZE(2), json.size());
+  ASSERT_EQ(JSON_OBJECT_SIZE(2), buffer.size());
 }
 
 TEST(StaticJsonBuffer_CreateObject_Tests, SucceedWhenBigEnough) {
-  StaticJsonBuffer<JSON_OBJECT_SIZE(0)> json;
+  StaticJsonBuffer<JSON_OBJECT_SIZE(0)> buffer;
 
-  JsonObject &object = json.createObject();
+  JsonObject &object = buffer.createObject();
   ASSERT_TRUE(object.success());
 }
 
 TEST(StaticJsonBuffer_CreateObject_Tests, FailsWhenTooSmall) {
-  StaticJsonBuffer<JSON_OBJECT_SIZE(0) - 1> json;
+  StaticJsonBuffer<JSON_OBJECT_SIZE(0) - 1> buffer;
 
-  JsonObject &object = json.createObject();
+  JsonObject &object = buffer.createObject();
   ASSERT_FALSE(object.success());
 }
 
 TEST(StaticJsonBuffer_CreateObject_Tests, ObjectDoesntGrowWhenFull) {
-  StaticJsonBuffer<JSON_OBJECT_SIZE(1)> json;
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1)> buffer;
 
-  JsonObject &obj = json.createObject();
+  JsonObject &obj = buffer.createObject();
   obj["hello"] = 1;
   obj["world"] = 2;
 
-  ASSERT_EQ(JSON_OBJECT_SIZE(1), json.size());
+  ASSERT_EQ(JSON_OBJECT_SIZE(1), buffer.size());
+  ASSERT_EQ(1, obj.size());
+
+  char json[64];
+  obj.printTo(json, sizeof(json));
+  ASSERT_STREQ("{\"hello\":1}", json);
 }

test/StringBuilderTests.cpp

@@ -5,14 +5,14 @@
 // https://github.com/bblanchon/ArduinoJson
 
 #include <gtest/gtest.h>
-#include <ArduinoJson/Internals/StringBuilder.hpp>
+#include <ArduinoJson/Internals/StaticStringBuilder.hpp>
 
 using namespace ArduinoJson::Internals;
 
 class StringBuilderTests : public testing::Test {
  protected:
   virtual void SetUp() {
-    _stringBuilder = new StringBuilder(_buffer, sizeof(_buffer));
+    _stringBuilder = new StaticStringBuilder(_buffer, sizeof(_buffer));
   }
 
   virtual void TearDown() { delete _stringBuilder; }