Set version to 5.13.4

Removed spurious files in the Particle library
Moved size measurements to github.com/bblanchon/ArduinoJson-size
2018-12-04 11:36:16 +01:00 · 2018-12-04 11:19:22 +01:00 · 2018-12-04 10:50:45 +01:00 · 2018-10-06 17:50:41 +02:00 · 2018-10-06 17:42:01 +02:00 · 2018-10-06 17:24:54 +02:00
290 changed files with 5446 additions and 8295 deletions
--- a/.gitignore
+++ b/.gitignore
@ -9,4 +9,3 @@
 /fuzzing/*_fuzzer
 /fuzzing/*_fuzzer.options
 /fuzzing/*_fuzzer_seed_corpus.zip
-.vs/
--- a/.travis.yml
+++ b/.travis.yml
@ -2,6 +2,12 @@ sudo: false
 language: cpp
 matrix:
  include:
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.4']
+      env: SCRIPT=cmake GCC=4.4
    - compiler: gcc
      addons:
        apt:
@ -31,7 +37,7 @@ matrix:
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-5']
-      env: SCRIPT=cmake GCC=5 # SANITIZE=undefined 
+      env: SCRIPT=cmake GCC=5
    - compiler: gcc
      addons:
        apt:
@ -97,15 +103,23 @@ matrix:
    - compiler: gcc
      env: SCRIPT=coverage
    - os: osx
-      osx_image: xcode6.4
+      osx_image: xcode7.3
      compiler: clang
      env: SCRIPT=cmake
    - os: osx
-      osx_image: xcode7.3
+      osx_image: xcode8.3
+      compiler: clang
+      env: SCRIPT=cmake
+    - os: osx
+      osx_image: xcode9.4
+      compiler: clang
+      env: SCRIPT=cmake
+    - os: osx
+      osx_image: xcode10
      compiler: clang
      env: SCRIPT=cmake SANITIZE=address
    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
-    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:samd:mkr1000
+    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:avr:uno
    - env: SCRIPT=platformio BOARD=uno
    - env: SCRIPT=platformio BOARD=esp01
    - compiler: clang
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,141 +1,17 @@
 ArduinoJson: change log
 =======================

-v6.2.2-beta
-----------
+v5.13.4
+-------

-* Fixed `invalid application of 'sizeof' to incomplete type '__FlashStringHelper'` (issue #783)
-* Fixed `char[]` not duplicated when passed to `JsonVariant::operator[]`
+* Removed spurious files in the Particle library

-v6.2.1-beta
-----------
+v5.13.3
+-------

-* Fixed `JsonObject` not inserting keys of type `String` (issue #782)
-
-v6.2.0-beta
-----------
-
-* Disabled lazy number deserialization (issue #772)
 * Improved float serialization when `-fsingle-precision-constant` is used
-* Renamed function `RawJson()` to `serialized()`
-* `serializeMsgPack()` now supports values marked with `serialized()`
-
-> ### BREAKING CHANGES
->
-> #### Non quoted strings
->
-> Non quoted strings are now forbidden in values, but they are still allowed in keys.
-> For example, `{key:"value"}` is accepted, but `{key:value}` is not.
->
-> #### Preformatted values
->
-> Old code:
->
-> ```c++
-> object["values"] = RawJson("[1,2,3,4]");
-> ```
-> 
-> New code:
-> 
-> ```c++
-> object["values"] = serialized("[1,2,3,4]");
-> ```
-
-v6.1.0-beta
-----------
-
-* Return `JsonArray` and `JsonObject` by value instead of reference (issue #309)
-* Replaced `success()` with `isNull()`
-
-> ### BREAKING CHANGES
-> 
-> Old code:
->
-> ```c++
-> JsonObject& obj = doc.to<JsonObject>();
-> JsonArray& arr = obj.createNestedArray("key");
-> if (!arr.success()) {
->   Serial.println("Not enough memory");
->   return;
-> }
-> ```
-> 
-> New code:
-> 
-> ```c++
-> JsonObject obj = doc.to<JsonObject>();
-> JsonArray arr = obj.createNestedArray("key");
-> if (arr.isNull()) {
->   Serial.println("Not enough memory");
->   return;
-> }
-> ```
-
-v6.0.1-beta
-----------
-
-* Fixed conflicts with `isnan()` and `isinf()` macros (issue #752)
-
-v6.0.0-beta
-----------
-
-* Added `DynamicJsonDocument` and `StaticJsonDocument`
-* Added `deserializeJson()`
-* Added `serializeJson()` and `serializeJsonPretty()`
-* Added `measureJson()` and `measureJsonPretty()`
-* Added `serializeMsgPack()`, `deserializeMsgPack()` and `measureMsgPack()` (issue #358)
-* Added example `MsgPackParser.ino` (issue #358)
-* Added support for non zero-terminated strings (issue #704)
-* Removed `JsonBuffer::parseArray()`, `parseObject()` and `parse()`
-* Removed `JsonBuffer::createArray()` and `createObject()`
-* Removed `printTo()` and `prettyPrintTo()`
-* Removed `measureLength()` and `measurePrettyLength()`
-* Removed all deprecated features
-
-> ### BREAKING CHANGES
-> 
-> #### Deserialization
-> 
-> Old code:
-> 
-> ```c++
-> DynamicJsonBuffer jb;
-> JsonObject& obj = jb.parseObject(json);
-> if (obj.success()) {
-> 
-> }
-> ```
-> 
-> New code:
-> 
-> ```c++
-> DynamicJsonDocument doc;
-> DeserializationError error = deserializeJson(doc, json);
-> if (error) {
-> 
-> }
-> JsonObject& obj = doc.as<JsonObject>();
-> ```
-> 
-> #### Serialization
-> 
-> Old code:
-> 
-> ```c++
-> DynamicJsonBuffer jb;
-> JsonObject& obj = jb.createObject();
-> obj["key"] = "value";
-> obj.printTo(Serial);
-> ```
-> 
-> New code:
-> 
-> ```c++
-> DynamicJsonDocument obj;
-> JsonObject& obj = doc.to<JsonObject>();
-> obj["key"] = "value";
-> serializeJson(doc, Serial);
-> ```
+* Fixed `JsonVariant::is<int>()` that returned true for empty strings
+* Fixed `JsonVariant::is<String>()` (closes #763)

 v5.13.2
 -------
@ -556,3 +432,52 @@ However, you should not see this as an invitation to use the `String` class.
 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
+----
+
+* Fixed buffer overflow when input contains a backslash followed by a terminator (issue #81)
+
+**Upgrading is recommended** since previous versions contain a potential security risk.
+
+Special thanks to [Giancarlo Canales Barreto](https://github.com/gcanalesb) for finding this nasty bug.
+
+v4.4
+----
+
+* Added `JsonArray::measureLength()` and `JsonObject::measureLength()` (issue #75)
+
+v4.3
+----
+
+* Added `JsonArray::removeAt()` to remove an element of an array (issue #58)
+* Fixed stack-overflow in `DynamicJsonBuffer` when parsing huge JSON files (issue #65)
+* Fixed wrong return value of `parseArray()` and `parseObject()` when allocation fails (issue #68)
+
+v4.2
+----
+
+* Switched back to old library layout (issues #39, #43 and #45)
+* Removed global new operator overload (issue #40, #45 and #46)
+* Added an example with EthernetServer
+
+v4.1
+----
+
+* Added DynamicJsonBuffer (issue #19)
+
+v4.0
+----
+
+* Unified parser and generator API (issue #23)
+* Updated library layout, now requires Arduino 1.0.6 or newer
+
+> ### BREAKING CHANGES :warning:
+>
+> API changed significantly since v3, see [Migrating code to the new API](https://arduinojson.org/doc/migration/).
+
--- a/README.md
+++ b/README.md
@ -2,7 +2,7 @@

 ---

-[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=6.x)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=6.x) [![Star this project](http://githubbadges.com/star.svg?user=bblanchon&repo=ArduinoJson&style=flat&color=fff&background=007ec6)](https://github.com/bblanchon/ArduinoJson)
+[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master) [![Star this project](http://githubbadges.com/star.svg?user=bblanchon&repo=ArduinoJson&style=flat&color=fff&background=007ec6)](https://github.com/bblanchon/ArduinoJson)

 ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).

@ -10,7 +10,6 @@ ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).

 * JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
-* MessagePack
 * Elegant API, easy to use
 * Fixed memory allocation (zero malloc)
 * No data duplication (zero copy)
@ -60,10 +59,10 @@ Here is a program that parses a JSON document with ArduinoJson.
 ```c++
 char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";

-DynamicJsonDocument doc;
-deserializeJson(doc, json);
+StaticJsonBuffer<200> jsonBuffer;
+
+JsonObject& root = jsonBuffer.parseObject(json);

-JsonObjectRef root = doc.as<JsonObject>();
 const char* sensor = root["sensor"];
 long time          = root["time"];
 double latitude    = root["data"][0];
@ -77,17 +76,17 @@ See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_
 Here is a program that generates a JSON document with ArduinoJson:

 ```c++
-DynamicJsonDocument doc;
+StaticJsonBuffer<200> jsonBuffer;

-JsonObject root = doc.to<JsonObject>();
+JsonObject& root = jsonBuffer.createObject();
 root["sensor"] = "gps";
 root["time"] = 1351824120;

-JsonArray data = root.createNestedArray("data");
+JsonArray& data = root.createNestedArray("data");
 data.add(48.756080);
 data.add(2.302038);

-serializeJson(doc, Serial);
+root.printTo(Serial);
 // This prints:
 // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 ```
@ -108,4 +107,4 @@ The documentation is available on [arduinojson.org](https://arduinojson.org/?utm
 Do you like this library? Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)!

 What? You don't like it but you *love* it?
-We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time!
+We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time!
--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,4 +1,4 @@
-version: 6.0.1.{build}
+version: 5.13.4.{build}
 environment:
  matrix:
  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
--- a/examples/JsonConfigFile/JsonConfigFile.ino
+++ b/examples/JsonConfigFile/JsonConfigFile.ino
@ -29,19 +29,17 @@ void loadConfiguration(const char *filename, Config &config) {
  // Open file for reading
  File file = SD.open(filename);

-  // Allocate the document on the stack.
-  // Don't forget to change the capacity to match your requirements.
+  // Allocate the memory pool on the stack.
+  // Don't forget to change the capacity to match your JSON document.
  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<512> doc;
+  StaticJsonBuffer<512> jsonBuffer;

-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, file);
-  if (error)
+  // Parse the root object
+  JsonObject &root = jsonBuffer.parseObject(file);
+
+  if (!root.success())
    Serial.println(F("Failed to read file, using default configuration"));

-  // Get the root object in the document
-  JsonObject root = doc.as<JsonObject>();
-
  // Copy values from the JsonObject to the Config
  config.port = root["port"] | 2731;
  strlcpy(config.hostname,                   // <- destination
@ -64,20 +62,20 @@ void saveConfiguration(const char *filename, const Config &config) {
    return;
  }

-  // Allocate the document on the stack.
-  // Don't forget to change the capacity to match your requirements.
-  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<256> doc;
+  // Allocate the memory pool on the stack
+  // Don't forget to change the capacity to match your JSON document.
+  // Use https://arduinojson.org/assistant/ to compute the capacity.
+  StaticJsonBuffer<256> jsonBuffer;

-  // Make our document contain an object
-  JsonObject root = doc.to<JsonObject>();
+  // Parse the root object
+  JsonObject &root = jsonBuffer.createObject();

-  // Set the values in the object
+  // Set the values
  root["hostname"] = config.hostname;
  root["port"] = config.port;

  // Serialize JSON to file
-  if (serializeJson(doc, file) == 0) {
+  if (root.printTo(file) == 0) {
    Serial.println(F("Failed to write to file"));
  }

@ -132,4 +130,15 @@ void loop() {
  // not used in this example
 }

-// Visit https://arduinojson.org/v6/example/config/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization or deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a case study of a project that has
+// a complex configuration with nested members.
+// Contrary to this example, the project in the book uses the SPIFFS filesystem.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/examples/JsonGeneratorExample/JsonGeneratorExample.ino
+++ b/examples/JsonGeneratorExample/JsonGeneratorExample.ino
@ -11,20 +11,24 @@ void setup() {
  Serial.begin(9600);
  while (!Serial) continue;

-  // Allocate the JSON document
+  // Memory pool for JSON object tree.
  //
-  // Inside the brackets, 200 is the RAM allocated to this document.
-  // Don't forget to change this value to match your requirement.
+  // Inside the brackets, 200 is the size of the pool in bytes.
+  // Don't forget to change this value to match your JSON document.
  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
+  StaticJsonBuffer<200> jsonBuffer;

-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
  //
-  // DynamicJsonDocument  doc(200);
+  // DynamicJsonBuffer  jsonBuffer(200);

-  // Make our document be an object
-  JsonObject root = doc.to<JsonObject>();
+  // Create the root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
+  JsonObject& root = jsonBuffer.createObject();

  // Add values in the object
  //
@ -33,19 +37,21 @@ void setup() {
  root["sensor"] = "gps";
  root["time"] = 1351824120;

-  // Add an array.
+  // Add a nested array.
  //
-  JsonArray data = root.createNestedArray("data");
+  // It's also possible to create the array separately and add it to the
+  // JsonObject but it's less efficient.
+  JsonArray& data = root.createNestedArray("data");
  data.add(48.756080);
  data.add(2.302038);

-  serializeJson(root, Serial);
+  root.printTo(Serial);
  // This prints:
  // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}

  Serial.println();

-  serializeJsonPretty(root, Serial);
+  root.prettyPrintTo(Serial);
  // This prints:
  // {
  //   "sensor": "gps",
@ -61,4 +67,15 @@ void loop() {
  // not used in this example
 }

-// Visit https://arduinojson.org/v6/example/generator/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like serializing directly to a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/examples/JsonHttpClient/JsonHttpClient.ino
+++ b/examples/JsonHttpClient/JsonHttpClient.ino
@ -70,21 +70,19 @@ void setup() {
    return;
  }

-  // Allocate the JSON document
+  // Allocate JsonBuffer
  // Use arduinojson.org/assistant to compute the capacity.
  const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
-  DynamicJsonDocument doc(capacity);
+  DynamicJsonBuffer jsonBuffer(capacity);

  // Parse JSON object
-  DeserializationError error = deserializeJson(doc, client);
-  if (error) {
-    Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.c_str());
+  JsonObject& root = jsonBuffer.parseObject(client);
+  if (!root.success()) {
+    Serial.println(F("Parsing failed!"));
    return;
  }

  // Extract values
-  JsonObject root = doc.as<JsonObject>();
  Serial.println(F("Response:"));
  Serial.println(root["sensor"].as<char*>());
  Serial.println(root["time"].as<char*>());
@ -99,4 +97,16 @@ void loop() {
  // not used in this example
 }

-// Visit https://arduinojson.org/v6/example/http-client/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization  problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization
+// showing how to parse the response from Yahoo Weather. In the last chapter,
+// it shows how to parse the huge documents from OpenWeatherMap
+// and Weather Underground.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/examples/JsonParserExample/JsonParserExample.ino
+++ b/examples/JsonParserExample/JsonParserExample.ino
@ -11,17 +11,17 @@ void setup() {
  Serial.begin(9600);
  while (!Serial) continue;

-  // Allocate the JSON document
+  // Memory pool for JSON object tree.
  //
-  // Inside the brackets, 200 is the size of the memory pool in bytes.
+  // Inside the brackets, 200 is the size of the pool in bytes.
  // Don't forget to change this value to match your JSON document.
  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
+  StaticJsonBuffer<200> jsonBuffer;

-  // StaticJsonDocument<N> allocates memory on the stack, it can be
-  // replaced by DynamicJsonObject which allocates in the heap.
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
  //
-  // DynamicJsonObject doc(200);
+  // DynamicJsonBuffer  jsonBuffer(200);

  // JSON input string.
  //
@ -31,19 +31,19 @@ void setup() {
  char json[] =
      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";

-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, json);
+  // Root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
+  JsonObject& root = jsonBuffer.parseObject(json);

  // Test if parsing succeeds.
-  if (error) {
-    Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.c_str());
+  if (!root.success()) {
+    Serial.println("parseObject() failed");
    return;
  }

-  // Get the root object in the document
-  JsonObject root = doc.as<JsonObject>();
-
  // Fetch values.
  //
  // Most of the time, you can rely on the implicit casts.
@ -64,4 +64,15 @@ void loop() {
  // not used in this example
 }

-// Visit https://arduinojson.org/v6/example/parser/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like deserializing directly from a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/examples/JsonServer/JsonServer.ino
+++ b/examples/JsonServer/JsonServer.ino
@ -51,15 +51,15 @@ void loop() {
  // Read the request (we ignore the content in this example)
  while (client.available()) client.read();

-  // Allocate the JSON document
+  // Allocate JsonBuffer
  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
+  StaticJsonBuffer<500> jsonBuffer;

-  // Make our document represent an object
-  JsonObject root = doc.to<JsonObject>();
+  // Create the root object
+  JsonObject& root = jsonBuffer.createObject();

  // Create the "analog" array
-  JsonArray analogValues = root.createNestedArray("analog");
+  JsonArray& analogValues = root.createNestedArray("analog");
  for (int pin = 0; pin < 6; pin++) {
    // Read the analog input
    int value = analogRead(pin);
@ -69,7 +69,7 @@ void loop() {
  }

  // Create the "digital" array
-  JsonArray digitalValues = root.createNestedArray("digital");
+  JsonArray& digitalValues = root.createNestedArray("digital");
  for (int pin = 0; pin < 14; pin++) {
    // Read the digital input
    int value = digitalRead(pin);
@ -79,7 +79,7 @@ void loop() {
  }

  Serial.print(F("Sending: "));
-  serializeJson(root, Serial);
+  root.printTo(Serial);
  Serial.println();

  // Write response headers
@ -89,10 +89,21 @@ void loop() {
  client.println();

  // Write JSON document
-  serializeJsonPretty(root, client);
+  root.prettyPrintTo(client);

  // Disconnect
  client.stop();
 }

-// Visit https://arduinojson.org/v6/example/http-server/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, then adds more features like serializing
+// directly to a file or an HTTP client.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/examples/JsonUdpBeacon/JsonUdpBeacon.ino
+++ b/examples/JsonUdpBeacon/JsonUdpBeacon.ino
@ -43,15 +43,15 @@ void setup() {
 }

 void loop() {
-  // Allocate the JSON document
+  // Allocate JsonBuffer
  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
+  StaticJsonBuffer<500> jsonBuffer;

-  // Make our document represent an object
-  JsonObject root = doc.to<JsonObject>();
+  // Create the root object
+  JsonObject& root = jsonBuffer.createObject();

  // Create the "analog" array
-  JsonArray analogValues = root.createNestedArray("analog");
+  JsonArray& analogValues = root.createNestedArray("analog");
  for (int pin = 0; pin < 6; pin++) {
    // Read the analog input
    int value = analogRead(pin);
@ -61,7 +61,7 @@ void loop() {
  }

  // Create the "digital" array
-  JsonArray digitalValues = root.createNestedArray("digital");
+  JsonArray& digitalValues = root.createNestedArray("digital");
  for (int pin = 0; pin < 14; pin++) {
    // Read the digital input
    int value = digitalRead(pin);
@ -75,11 +75,11 @@ void loop() {
  Serial.print(remoteIp);
  Serial.print(F(" on port "));
  Serial.println(remotePort);
-  serializeJson(root, Serial);
+  root.printTo(Serial);

  // Send UDP packet
  udp.beginPacket(remoteIp, remotePort);
-  serializeJson(root, udp);
+  root.printTo(udp);
  udp.println();
  udp.endPacket();

@ -87,4 +87,15 @@ void loop() {
  delay(10000);
 }

-// Visit https://arduinojson.org/v6/example/udp-beacon/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, then adds more features like serializing
+// directly to a file or any stream.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/examples/MsgPackParser/MsgPackParser.ino
+++ b/examples/MsgPackParser/MsgPackParser.ino
@ -1,80 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-//
-// This example shows how to deserialize a MessagePack document with
-// ArduinoJson.
-
-#include <ArduinoJson.h>
-
-void setup() {
-  // Initialize serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
-
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 200 is the size of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonObject which allocates in the heap.
-  //
-  // DynamicJsonObject doc(200);
-
-  // MessagePack input string.
-  //
-  // It's better to use a char[] as shown here.
-  // If you use a const char* or a String, ArduinoJson will
-  // have to make a copy of the input in the JsonBuffer.
-  uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,
-                     164, 116, 105, 109, 101, 206, 80,  147, 50,  248, 164, 100,
-                     97,  116, 97,  146, 203, 64,  72,  96,  199, 58,  188, 148,
-                     112, 203, 64,  2,   106, 146, 230, 33,  49,  169};
-  // This MessagePack document contains:
-  // {
-  //   "sensor": "gps",
-  //   "time": 1351824120,
-  //   "data": [48.75608, 2.302038]
-  // }
-
-  // doc of the object tree.
-  //
-  // It's a reference to the JsonObject, the actual bytes are inside the
-  // JsonBuffer with all the other nodes of the object tree.
-  // Memory is freed when jsonBuffer goes out of scope.
-  DeserializationError error = deserializeMsgPack(doc, input);
-
-  // Test if parsing succeeds.
-  if (error) {
-    Serial.print("deserializeMsgPack() failed: ");
-    Serial.println(error.c_str());
-    return;
-  }
-
-  // Get the root object in the document
-  JsonObject root = doc.as<JsonObject>();
-
-  // Fetch values.
-  //
-  // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do root["time"].as<long>();
-  const char* sensor = root["sensor"];
-  long time = root["time"];
-  double latitude = root["data"][0];
-  double longitude = root["data"][1];
-
-  // Print values.
-  Serial.println(sensor);
-  Serial.println(time);
-  Serial.println(latitude, 6);
-  Serial.println(longitude, 6);
-}
-
-void loop() {
-  // not used in this example
-}
-
-// Visit https://arduinojson.org/v6/example/msgpack-parser/ for more.
--- a/examples/ProgmemExample/ProgmemExample.ino
+++ b/examples/ProgmemExample/ProgmemExample.ino
@ -14,35 +14,34 @@
 void setup() {
 #ifdef PROGMEM  // <- check that Flash strings are supported

-  DynamicJsonDocument doc;
+  DynamicJsonBuffer jsonBuffer;

  // You can use a Flash String as your JSON input.
  // WARNING: the content of the Flash String will be duplicated in the
  // JsonBuffer.
-  deserializeJson(doc, F("{\"sensor\":\"gps\",\"time\":1351824120,"
-                         "\"data\":[48.756080,2.302038]}"));
-  JsonObject obj = doc.as<JsonObject>();
+  JsonObject& root =
+      jsonBuffer.parseObject(F("{\"sensor\":\"gps\",\"time\":1351824120,"
+                               "\"data\":[48.756080,2.302038]}"));

  // You can use a Flash String to get an element of a JsonObject
  // No duplication is done.
-  long time = obj[F("time")];
+  long time = root[F("time")];

  // You can use a Flash String to set an element of a JsonObject
  // WARNING: the content of the Flash String will be duplicated in the
  // JsonBuffer.
-  obj[F("time")] = time;
+  root[F("time")] = time;

  // You can set a Flash String to a JsonObject or JsonArray:
  // WARNING: the content of the Flash String will be duplicated in the
  // JsonBuffer.
-  obj["sensor"] = F("gps");
+  root["sensor"] = F("gps");

-  // It works with serialized() too:
-  obj["sensor"] = serialized(F("\"gps\""));
-  obj["sensor"] = serialized(F("\xA3gps"), 3);
+  // It works with RawJson too:
+  root["sensor"] = RawJson(F("\"gps\""));

  // You can compare the content of a JsonVariant to a Flash String
-  if (obj["sensor"] == F("gps")) {
+  if (root["sensor"] == F("gps")) {
    // ...
  }

@ -57,4 +56,15 @@ void loop() {
  // not used in this example
 }

-// Visit https://arduinojson.org/v6/example/progmem/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any memory
+// problem.
+//
+// The book "Mastering ArduinoJson" contains a quick C++ course that explains
+// how your microcontroller stores strings in memory. It also tells why you
+// should not abuse Flash strings with ArduinoJson.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/examples/StringExample/StringExample.ino
+++ b/examples/StringExample/StringExample.ino
@ -11,55 +11,64 @@
 #include <ArduinoJson.h>

 void setup() {
-  DynamicJsonDocument doc;
+  DynamicJsonBuffer jsonBuffer;

  // You can use a String as your JSON input.
  // WARNING: the content of the String will be duplicated in the JsonBuffer.
  String input =
      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-  deserializeJson(doc, input);
-  JsonObject obj = doc.as<JsonObject>();
+  JsonObject& root = jsonBuffer.parseObject(input);

  // You can use a String to get an element of a JsonObject
  // No duplication is done.
-  long time = obj[String("time")];
+  long time = root[String("time")];

  // You can use a String to set an element of a JsonObject
  // WARNING: the content of the String will be duplicated in the JsonBuffer.
-  obj[String("time")] = time;
+  root[String("time")] = time;

  // You can get a String from a JsonObject or JsonArray:
  // No duplication is done, at least not in the JsonBuffer.
-  String sensor = obj["sensor"];
+  String sensor = root["sensor"];

  // Unfortunately, the following doesn't work (issue #118):
-  // sensor = obj["sensor"]; // <-  error "ambiguous overload for 'operator='"
+  // sensor = root["sensor"]; // <-  error "ambiguous overload for 'operator='"
  // As a workaround, you need to replace by:
-  sensor = obj["sensor"].as<String>();
+  sensor = root["sensor"].as<String>();

  // You can set a String to a JsonObject or JsonArray:
  // WARNING: the content of the String will be duplicated in the JsonBuffer.
-  obj["sensor"] = sensor;
+  root["sensor"] = sensor;

-  // It works with serialized() too:
-  obj["sensor"] = serialized(sensor);
+  // It works with RawJson too:
+  root["sensor"] = RawJson(sensor);

  // You can also concatenate strings
  // WARNING: the content of the String will be duplicated in the JsonBuffer.
-  obj[String("sen") + "sor"] = String("gp") + "s";
+  root[String("sen") + "sor"] = String("gp") + "s";

  // You can compare the content of a JsonObject with a String
-  if (obj["sensor"] == sensor) {
+  if (root["sensor"] == sensor) {
    // ...
  }

  // Lastly, you can print the resulting JSON to a String
  String output;
-  serializeJson(doc, output);
+  root.printTo(output);
 }

 void loop() {
  // not used in this example
 }

-// Visit https://arduinojson.org/v6/example/string/ for more.
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any problem.
+//
+// The book "Mastering ArduinoJson" contains a quick C++ course that explains
+// how your microcontroller stores strings in memory. On several occasions, it
+// shows how you can avoid String in your program.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤
--- a/fuzzing/Makefile
+++ b/fuzzing/Makefile
@ -5,18 +5,15 @@ CXXFLAGS += -I../src
 all: \
 	$(OUT)/json_fuzzer \
 	$(OUT)/json_fuzzer_seed_corpus.zip \
-	$(OUT)/json_fuzzer.options \
-	$(OUT)/msgpack_fuzzer \
-	$(OUT)/msgpack_fuzzer_seed_corpus.zip \
-	$(OUT)/msgpack_fuzzer.options
+	$(OUT)/json_fuzzer.options

-$(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../src -type f)
+$(OUT)/json_fuzzer: fuzzer.cpp $(shell find ../src -type f)
 	$(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE)

-$(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/*
+$(OUT)/json_fuzzer_seed_corpus.zip: seed_corpus/*
 	zip -j $@ $?

-$(OUT)/%_fuzzer.options:
+$(OUT)/json_fuzzer.options:
 	@echo "[libfuzzer]" > $@
 	@echo "max_len = 256" >> $@
 	@echo "timeout = 10" >> $@
--- a/fuzzing/fuzzer.cpp
+++ b/fuzzing/fuzzer.cpp
@ -0,0 +1,26 @@
+#include <ArduinoJson.h>
+
+class memstream : public std::istream {
+  struct membuf : std::streambuf {
+    membuf(const uint8_t *p, size_t l) {
+      setg((char *)p, (char *)p, (char *)p + l);
+    }
+  };
+  membuf _buffer;
+
+ public:
+  memstream(const uint8_t *p, size_t l)
+      : std::istream(&_buffer), _buffer(p, l) {
+    rdbuf(&_buffer);
+  }
+};
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  DynamicJsonBuffer jsonBuffer;
+  memstream json(data, size);
+  JsonVariant variant = jsonBuffer.parse(json);
+  if (variant.success()) {
+    variant.as<std::string>();  // <- serialize to JSON
+  }
+  return 0;
+}
--- a/fuzzing/json_fuzzer.cpp
+++ b/fuzzing/json_fuzzer.cpp
@ -1,11 +0,0 @@
-#include <ArduinoJson.h>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  DynamicJsonDocument doc;
-  DeserializationError error = deserializeJson(doc, data, size);
-  if (!error) {
-    std::string json;
-    serializeJson(doc, json);
-  }
-  return 0;
-}
--- a/fuzzing/msgpack_corpus/.gitignore
+++ b/fuzzing/msgpack_corpus/.gitignore
@ -1,2 +0,0 @@
-*
-!.gitignore
--- a/fuzzing/msgpack_fuzzer.cpp
+++ b/fuzzing/msgpack_fuzzer.cpp
@ -1,11 +0,0 @@
-#include <ArduinoJson.h>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  DynamicJsonDocument doc;
-  DeserializationError error = deserializeMsgPack(doc, data, size);
-  if (!error) {
-    std::string json;
-    serializeMsgPack(doc, json);
-  }
-  return 0;
-}
--- a/fuzzing/msgpack_seed_corpus/array16
+++ b/fuzzing/msgpack_seed_corpus/array16
--- a/fuzzing/msgpack_seed_corpus/array32
+++ b/fuzzing/msgpack_seed_corpus/array32
--- a/fuzzing/msgpack_seed_corpus/false
+++ b/fuzzing/msgpack_seed_corpus/false
@ -1 +0,0 @@
-<EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/fixarray
+++ b/fuzzing/msgpack_seed_corpus/fixarray
@ -1 +0,0 @@
-<EFBFBD><EFBFBD>hello<EFBFBD>world
--- a/fuzzing/msgpack_seed_corpus/fixint_negative
+++ b/fuzzing/msgpack_seed_corpus/fixint_negative
@ -1 +0,0 @@
-<EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/fixint_positive
+++ b/fuzzing/msgpack_seed_corpus/fixint_positive
@ -1 +0,0 @@
-
--- a/fuzzing/msgpack_seed_corpus/fixmap
+++ b/fuzzing/msgpack_seed_corpus/fixmap
@ -1 +0,0 @@
-<EFBFBD><EFBFBD>one<01>two
--- a/fuzzing/msgpack_seed_corpus/fixstr
+++ b/fuzzing/msgpack_seed_corpus/fixstr
@ -1 +0,0 @@
-<EFBFBD>hello world
--- a/fuzzing/msgpack_seed_corpus/float32
+++ b/fuzzing/msgpack_seed_corpus/float32
@ -1 +0,0 @@
-<EFBFBD>@H<><48>
--- a/fuzzing/msgpack_seed_corpus/float64
+++ b/fuzzing/msgpack_seed_corpus/float64
@ -1 +0,0 @@
-<EFBFBD>@	!<21><><EFBFBD>o
--- a/fuzzing/msgpack_seed_corpus/int16
+++ b/fuzzing/msgpack_seed_corpus/int16
@ -1 +0,0 @@
-<EFBFBD><EFBFBD><EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/int32
+++ b/fuzzing/msgpack_seed_corpus/int32
@ -1 +0,0 @@
-Ҷi<EFBFBD>.
--- a/fuzzing/msgpack_seed_corpus/int64
+++ b/fuzzing/msgpack_seed_corpus/int64
@ -1 +0,0 @@
-<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/int8
+++ b/fuzzing/msgpack_seed_corpus/int8
@ -1 +0,0 @@
-<EFBFBD><EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/map16
+++ b/fuzzing/msgpack_seed_corpus/map16
--- a/fuzzing/msgpack_seed_corpus/map32
+++ b/fuzzing/msgpack_seed_corpus/map32
--- a/fuzzing/msgpack_seed_corpus/nil
+++ b/fuzzing/msgpack_seed_corpus/nil
@ -1 +0,0 @@
-<EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/str16
+++ b/fuzzing/msgpack_seed_corpus/str16
--- a/fuzzing/msgpack_seed_corpus/str32
+++ b/fuzzing/msgpack_seed_corpus/str32
--- a/fuzzing/msgpack_seed_corpus/str8
+++ b/fuzzing/msgpack_seed_corpus/str8
@ -1 +0,0 @@
-<EFBFBD>hello
--- a/fuzzing/msgpack_seed_corpus/true
+++ b/fuzzing/msgpack_seed_corpus/true
@ -1 +0,0 @@
-<EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/uint16
+++ b/fuzzing/msgpack_seed_corpus/uint16
@ -1 +0,0 @@
-<EFBFBD>09
--- a/fuzzing/msgpack_seed_corpus/uint32
+++ b/fuzzing/msgpack_seed_corpus/uint32
@ -1 +0,0 @@
-<EFBFBD>4Vx
--- a/fuzzing/msgpack_seed_corpus/uint64
+++ b/fuzzing/msgpack_seed_corpus/uint64
@ -1 +0,0 @@
-<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>
--- a/fuzzing/msgpack_seed_corpus/uint8
+++ b/fuzzing/msgpack_seed_corpus/uint8
@ -1 +0,0 @@
-<EFBFBD><EFBFBD>
--- a/fuzzing/json_corpus/.gitignore
+++ b/fuzzing/json_corpus/.gitignore
--- a/fuzzing/json_seed_corpus/Comments.json
+++ b/fuzzing/json_seed_corpus/Comments.json
--- a/fuzzing/json_seed_corpus/EmptyArray.json
+++ b/fuzzing/json_seed_corpus/EmptyArray.json
--- a/fuzzing/json_seed_corpus/EmptyObject.json
+++ b/fuzzing/json_seed_corpus/EmptyObject.json
--- a/fuzzing/json_seed_corpus/ExcessiveNesting.json
+++ b/fuzzing/json_seed_corpus/ExcessiveNesting.json
--- a/fuzzing/json_seed_corpus/Numbers.json
+++ b/fuzzing/json_seed_corpus/Numbers.json
--- a/fuzzing/json_seed_corpus/OpenWeatherMap.json
+++ b/fuzzing/json_seed_corpus/OpenWeatherMap.json
--- a/fuzzing/json_seed_corpus/Strings.json
+++ b/fuzzing/json_seed_corpus/Strings.json
--- a/fuzzing/json_seed_corpus/WeatherUnderground.json
+++ b/fuzzing/json_seed_corpus/WeatherUnderground.json
--- a/keywords.txt
+++ b/keywords.txt
@ -1,17 +1,15 @@
-add	KEYWORD2
-as	KEYWORD2
-createNestedArray	KEYWORD2
-createNestedObject	KEYWORD2
-deserializeJson	KEYWORD2
-deserializeMsgPack	KEYWORD2
-DynamicJsonDocument	KEYWORD1
-get	KEYWORD2
 JsonArray	KEYWORD1
 JsonObject	KEYWORD1
 JsonVariant	KEYWORD1
-serializeMsgPack	KEYWORD2
-serializeJson	KEYWORD2
-serializeJsonPretty	KEYWORD2
-set	KEYWORD2
-StaticJsonDocument	KEYWORD1
-to	KEYWORD2
+StaticJsonBuffer	KEYWORD1
+DynamicJsonBuffer	KEYWORD1
+add	KEYWORD2
+createArray	KEYWORD2
+createNestedArray	KEYWORD2
+createNestedObject	KEYWORD2
+createObject	KEYWORD2
+parseArray	KEYWORD2
+parseObject	KEYWORD2
+prettyPrintTo	KEYWORD2
+printTo	KEYWORD2
+success	KEYWORD2
--- a/library.json
+++ b/library.json
@ -7,7 +7,7 @@
    "type": "git",
    "url": "https://github.com/bblanchon/ArduinoJson.git"
  },
-  "version": "6.2.2-beta",
+  "version": "5.13.4",
  "authors": {
    "name": "Benoit Blanchon",
    "url": "https://blog.benoitblanchon.fr"
--- a/library.properties
+++ b/library.properties
@ -1,9 +1,9 @@
 name=ArduinoJson
-version=6.2.2-beta
+version=5.13.4
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.
-paragraph=ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation.
+paragraph=ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ fixed allocation, ✔ zero-copy, ✔ streams, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation.
 category=Data Processing
 url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties
 architectures=*
--- a/scripts/create-size-graph.sh
+++ b/scripts/create-size-graph.sh
@ -1,42 +0,0 @@
-#!/bin/bash
-
-set -eu
-
-OUTPUT="$(pwd)/sizes.csv"
-
-echo "Tag;Date;Parser;Generator" > $OUTPUT
-
-cd $(dirname $(dirname $0))
-
-git tag | while read TAG
-do 
-
-	git checkout -q tags/$TAG
-
-	DATE=$(git log -1 --date=short --pretty=format:%cd)
-	PARSER_SIZE=$(arduino --verify examples/JsonParserExample/JsonParserExample.ino 2>/dev/null  | grep -e 'Sketch uses' | sed 's/.*uses \([0-9]*\).\([0-9]\+\).*/\1\2/')
-	
-	if [ -e 'examples/JsonGeneratorExample/JsonGeneratorExample.ino' ]; then
-		GENERATOR_SIZE=$(arduino --verify examples/JsonGeneratorExample/JsonGeneratorExample.ino 2>/dev/null  | grep -e 'Sketch uses' | sed 's/.*uses \([0-9]*\).\([0-9]\+\).*/\1\2/')
-	else
-		GENERATOR_SIZE=""
-	fi
-
-	echo $TAG 
-	if [ ! -z "$PARSER_SIZE" ]
-	then
-		echo "JsonParserExample = $PARSER_SIZE bytes"
-	else
-		echo "JsonParserExample compilation failed."
-	fi
-
-	if [ ! -z "$GENERATOR_SIZE" ]
-	then
-		echo "JsonGeneratorExample = $GENERATOR_SIZE bytes"
-	else
-		echo "JsonGeneratorExample compilation failed."
-	fi
-
-	echo "$TAG;$DATE;$PARSER_SIZE;$GENERATOR_SIZE" >> $OUTPUT
-
-done
--- a/scripts/oss-fuzz/Vagrantfile
+++ b/scripts/oss-fuzz/Vagrantfile
@ -2,16 +2,11 @@
 Vagrant.configure(2) do |config|
  config.vm.box = "ubuntu/xenial64"

-  config.vm.synced_folder "../..", "/host/ArduinoJson"
+  config.vm.synced_folder "E:\\Git\\Arduino\\libraries\\ArduinoJson", "/host/ArduinoJson"
  config.vm.synced_folder "E:\\Git\\oss-fuzz", "/host/oss-fuzz"

  config.vm.network "forwarded_port", guest: 8001, host: 8001

-  config.vm.provider "virtualbox" do |v|
-    v.memory = 2048
-    v.cpus = 2
-  end
-
  config.vm.provision "shell", privileged: false, inline: <<-SHELL
    set -x

@ -23,6 +18,10 @@ Vagrant.configure(2) do |config|
    git clone https://github.com/google/fuzzer-test-suite.git FTS
    ./FTS/tutorial/install-deps.sh  # Get deps
    ./FTS/tutorial/install-clang.sh # Get fresh clang binaries
+    # Get libFuzzer sources and build it
+    svn co http://llvm.org/svn/llvm-project/llvm/trunk/lib/Fuzzer
+    Fuzzer/build.sh
+    sudo mv libFuzzer.a /usr/local/lib/

    echo "export PROJECT_NAME='arduinojson'" >> $HOME/.profile
    echo "export CC='clang'" >> $HOME/.profile
--- a/scripts/publish-particle-library.sh
+++ b/scripts/publish-particle-library.sh
@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+set -eu
+
+SOURCE_DIR="$(dirname "$0")/.."
+WORK_DIR=$(mktemp -d)
+trap 'rm -rf "$WORK_DIR"' EXIT
+
+cp "$SOURCE_DIR/README.md" "$WORK_DIR/README.md"
+cp "$SOURCE_DIR/CHANGELOG.md" "$WORK_DIR/CHANGELOG.md"
+cp "$SOURCE_DIR/library.properties" "$WORK_DIR/library.properties"
+cp "$SOURCE_DIR/LICENSE.md" "$WORK_DIR/LICENSE.txt"
+cp -r "$SOURCE_DIR/src" "$WORK_DIR/"
+cp -r "$SOURCE_DIR/examples" "$WORK_DIR/"
+
+cd "$WORK_DIR"
+particle library upload
+particle library publish
--- a/scripts/travis/arduino.sh
+++ b/scripts/travis/arduino.sh
@ -1,4 +1,4 @@
-#!/bin/bash -eux
+#!/bin/sh -eux

 /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
@ -6,13 +6,9 @@ export DISPLAY=:1.0

 mkdir -p /tmp/arduino
 curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tar.xz | tar xJ -C /tmp/arduino --strip 1 ||
-curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tgz | tar xz -C /tmp/arduino --strip 1
+curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tgz | tar xz -C /tmp/arduino --strip 1 
 export PATH=$PATH:/tmp/arduino/
-
-if [[ "$BOARD" =~ "arduino:samd:" ]]; then
-  arduino --install-boards arduino:samd
-fi
-
+  
 ln -s $PWD /tmp/arduino/libraries/ArduinoJson

 for EXAMPLE in $PWD/examples/*/*.ino; do
--- a/scripts/travis/fuzz.sh
+++ b/scripts/travis/fuzz.sh
@ -1,26 +1,20 @@
 #!/bin/bash -eux

 ROOT_DIR=$(dirname $0)/../../
-INCLUDE_DIR=${ROOT_DIR}/src/
-FUZZING_DIR=${ROOT_DIR}/fuzzing/
+INCLUDE_DIR=$ROOT_DIR/src/
+FUZZING_DIR=$ROOT_DIR/fuzzing/
+JSON_CORPUS_DIR=$FUZZING_DIR/my_corpus
+JSON_SEED_CORPUS_DIR=$FUZZING_DIR/seed_corpus
+
+CXX="clang++-$CLANG"
 CXXFLAGS="-g -fprofile-instr-generate -fcoverage-mapping -fsanitize=address,fuzzer"

-fuzz() {
-	NAME="$1"
-	FUZZER="${NAME}_fuzzer"
-	FUZZER_CPP="${FUZZING_DIR}/${NAME}_fuzzer.cpp"
-	CORPUS_DIR="${FUZZING_DIR}/${NAME}_corpus"
-	SEED_CORPUS_DIR="${FUZZING_DIR}/${NAME}_seed_corpus"
+$CXX $CXXFLAGS -o json_fuzzer -I$INCLUDE_DIR $FUZZING_DIR/fuzzer.cpp

-	clang++-${CLANG} ${CXXFLAGS} -o ${FUZZER} -I$INCLUDE_DIR ${FUZZER_CPP}
+export ASAN_OPTIONS="detect_leaks=0"
+export LLVM_PROFILE_FILE="json_fuzzer.profraw"
+./json_fuzzer "$JSON_CORPUS_DIR" "$JSON_SEED_CORPUS_DIR" -max_total_time=60

-	export ASAN_OPTIONS="detect_leaks=0"
-	export LLVM_PROFILE_FILE="${FUZZER}.profraw"
-	./${FUZZER} "$CORPUS_DIR" "$SEED_CORPUS_DIR" -max_total_time=30
+llvm-profdata-$CLANG merge -sparse json_fuzzer.profraw -o json_fuzzer.profdata

-	llvm-profdata-${CLANG} merge -sparse ${LLVM_PROFILE_FILE} -o ${FUZZER}.profdata
-	llvm-cov-${CLANG} report ./${FUZZER} -instr-profile=${FUZZER}.profdata
-}
-
-fuzz json
-fuzz msgpack
+llvm-cov-$CLANG report ./json_fuzzer -instr-profile=json_fuzzer.profdata
--- a/src/ArduinoJson.hpp
+++ b/src/ArduinoJson.hpp
@ -6,21 +6,14 @@

 #include "ArduinoJson/version.hpp"

-#include "ArduinoJson/DynamicJsonDocument.hpp"
-#include "ArduinoJson/StaticJsonDocument.hpp"
-
-#include "ArduinoJson/JsonObjectImpl.hpp"
-
+#include "ArduinoJson/DynamicJsonBuffer.hpp"
 #include "ArduinoJson/JsonArray.hpp"
 #include "ArduinoJson/JsonObject.hpp"
+#include "ArduinoJson/StaticJsonBuffer.hpp"

+#include "ArduinoJson/Deserialization/JsonParserImpl.hpp"
 #include "ArduinoJson/JsonArrayImpl.hpp"
-#include "ArduinoJson/JsonArraySubscript.hpp"
-#include "ArduinoJson/JsonObjectSubscript.hpp"
+#include "ArduinoJson/JsonBufferImpl.hpp"
+#include "ArduinoJson/JsonObjectImpl.hpp"
 #include "ArduinoJson/JsonVariantImpl.hpp"
-
-#include "ArduinoJson/Json/JsonDeserializer.hpp"
-#include "ArduinoJson/Json/JsonSerializer.hpp"
-#include "ArduinoJson/Json/PrettyJsonSerializer.hpp"
-#include "ArduinoJson/MsgPack/MsgPackDeserializer.hpp"
-#include "ArduinoJson/MsgPack/MsgPackSerializer.hpp"
+#include "ArduinoJson/Serialization/JsonSerializerImpl.hpp"
--- a/src/ArduinoJson/Configuration.hpp
+++ b/src/ArduinoJson/Configuration.hpp
@ -130,6 +130,11 @@
 #endif
 #endif

+// Enable deprecated functions by default
+#ifndef ARDUINOJSON_ENABLE_DEPRECATED
+#define ARDUINOJSON_ENABLE_DEPRECATED 1
+#endif
+
 // Control the exponentiation threshold for big numbers
 // CAUTION: cannot be more that 1e9 !!!!
 #ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
@ -144,13 +149,3 @@
 #if ARDUINOJSON_USE_LONG_LONG && ARDUINOJSON_USE_INT64
 #error ARDUINOJSON_USE_LONG_LONG and ARDUINOJSON_USE_INT64 cannot be set together
 #endif
-
-#ifndef ARDUINOJSON_LITTLE_ENDIAN
-#if defined(_MSC_VER) ||                                                      \
-    (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \
-    (defined(__LITTLE_ENDIAN__))
-#define ARDUINOJSON_LITTLE_ENDIAN 1
-#else
-#define ARDUINOJSON_LITTLE_ENDIAN 0
-#endif
-#endif
--- a/src/ArduinoJson/Json/EscapeSequence.hpp
+++ b/src/ArduinoJson/Json/EscapeSequence.hpp
@ -7,7 +7,7 @@
 namespace ArduinoJson {
 namespace Internals {

-class EscapeSequence {
+class Encoding {
 public:
  // Optimized for code size on a 8-bit AVR
  static char escapeChar(char c) {
@ -33,5 +33,5 @@ class EscapeSequence {
    return &"\"\"\\\\b\bf\fn\nr\rt\t"[excludeIdenticals ? 4 : 0];
  }
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Data/IsVariant.hpp
+++ b/src/ArduinoJson/Data/IsVariant.hpp
@ -1,17 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "../Polyfills/type_traits.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-
-class JsonVariantTag {};
-
-template <typename T>
-struct IsVariant : is_base_of<JsonVariantTag, T> {};
-}  // namespace Internals
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Memory/JsonBufferAllocated.hpp
+++ b/src/ArduinoJson/Memory/JsonBufferAllocated.hpp
@ -4,7 +4,7 @@

 #pragma once

-#include "JsonBuffer.hpp"
+#include "../JsonBuffer.hpp"

 namespace ArduinoJson {
 namespace Internals {
@ -18,5 +18,5 @@ class JsonBufferAllocated {

  void operator delete(void *, JsonBuffer *)throw();
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Data/JsonVariantAs.hpp
+++ b/src/ArduinoJson/Data/JsonVariantAs.hpp
@ -19,5 +19,24 @@ struct JsonVariantAs<char*> {
  typedef const char* type;
 };

-}  // namespace Internals
-}  // namespace ArduinoJson
+template <>
+struct JsonVariantAs<JsonArray> {
+  typedef JsonArray& type;
+};
+
+template <>
+struct JsonVariantAs<const JsonArray> {
+  typedef const JsonArray& type;
+};
+
+template <>
+struct JsonVariantAs<JsonObject> {
+  typedef JsonObject& type;
+};
+
+template <>
+struct JsonVariantAs<const JsonObject> {
+  typedef const JsonObject& type;
+};
+}
+}
--- a/src/ArduinoJson/Data/JsonVariantContent.hpp
+++ b/src/ArduinoJson/Data/JsonVariantContent.hpp
@ -8,23 +8,20 @@
 #include "JsonInteger.hpp"

 namespace ArduinoJson {
-namespace Internals {
-// Forward declarations
-struct JsonArrayData;
-struct JsonObjectData;

+// Forward declarations
+class JsonArray;
+class JsonObject;
+
+namespace Internals {
 // A union that defines the actual content of a JsonVariant.
 // The enum JsonVariantType determines which member is in use.
 union JsonVariantContent {
-  JsonFloat asFloat;         // used for double and float
-  JsonUInt asInteger;        // used for bool, char, short, int and longs
-  JsonArrayData* asArray;    // asArray cannot be null
-  JsonObjectData* asObject;  // asObject cannot be null
-  const char* asString;      // asString can be null
-  struct {
-    const char* data;
-    size_t size;
-  } asRaw;
+  JsonFloat asFloat;     // used for double and float
+  JsonUInt asInteger;    // used for bool, char, short, int and longs
+  const char* asString;  // asString can be null
+  JsonArray* asArray;    // asArray cannot be null
+  JsonObject* asObject;  // asObject cannot be null
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Data/JsonVariantType.hpp
+++ b/src/ArduinoJson/Data/JsonVariantType.hpp
@ -5,6 +5,8 @@
 #pragma once

 namespace ArduinoJson {
+class JsonArray;
+class JsonObject;

 namespace Internals {

@ -17,9 +19,9 @@ enum JsonVariantType {
  JSON_BOOLEAN,           // JsonVariant stores a bool
  JSON_POSITIVE_INTEGER,  // JsonVariant stores an JsonUInt
  JSON_NEGATIVE_INTEGER,  // JsonVariant stores an JsonUInt that must be negated
-  JSON_ARRAY,             // JsonVariant stores a pointer to a JsonArrayData
-  JSON_OBJECT,            // JsonVariant stores a pointer to a JsonObjectData
+  JSON_ARRAY,             // JsonVariant stores a pointer to a JsonArray
+  JSON_OBJECT,            // JsonVariant stores a pointer to a JsonObject
  JSON_FLOAT              // JsonVariant stores a JsonFloat
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Data/List.hpp
+++ b/src/ArduinoJson/Data/List.hpp
@ -4,7 +4,7 @@

 #pragma once

-#include "../Memory/JsonBuffer.hpp"
+#include "../JsonBuffer.hpp"
 #include "ListConstIterator.hpp"
 #include "ListIterator.hpp"

@ -13,7 +13,7 @@ namespace Internals {

 // A singly linked list of T.
 // The linked list is composed of ListNode<T>.
-// It is derived by JsonArrayData and JsonObjectData
+// It is derived by JsonArray and JsonObject
 template <typename T>
 class List {
 public:
@ -22,10 +22,23 @@ class List {
  typedef ListIterator<T> iterator;
  typedef ListConstIterator<T> const_iterator;

-  explicit List(JsonBuffer *buf) : _buffer(buf), _firstNode(NULL) {}
+  // Creates an empty List<T> attached to a JsonBuffer.
+  // The JsonBuffer allows to allocate new nodes.
+  // When buffer is NULL, the List is not able to grow and success() returns
+  // false. This is used to identify bad memory allocations and parsing
+  // failures.
+  explicit List(JsonBuffer *buffer) : _buffer(buffer), _firstNode(NULL) {}
+
+  // Returns true if the object is valid
+  // Would return false in the following situation:
+  // - the memory allocation failed (StaticJsonBuffer was too small)
+  // - the JSON parsing failed
+  bool success() const {
+    return _buffer != NULL;
+  }

  // Returns the numbers of elements in the list.
-  // For a JsonObjectData, it would return the number of key-value pairs
+  // For a JsonObject, it would return the number of key-value pairs
  size_t size() const {
    size_t nodeCount = 0;
    for (node_type *node = _firstNode; node; node = node->next) nodeCount++;
@ -71,18 +84,11 @@ class List {
    }
  }

-  JsonBuffer &buffer() const {
-    return *_buffer;
-  }
-  JsonBuffer *_buffer;  // TODO!!
-
 protected:
-  void clear() {
-    _firstNode = 0;
-  }
+  JsonBuffer *_buffer;

 private:
  node_type *_firstNode;
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Data/ListNode.hpp
+++ b/src/ArduinoJson/Data/ListNode.hpp
@ -6,7 +6,7 @@

 #include <stddef.h>  // for NULL

-#include "../Memory/JsonBufferAllocated.hpp"
+#include "JsonBufferAllocated.hpp"

 namespace ArduinoJson {
 namespace Internals {
@ -20,5 +20,5 @@ struct ListNode : public Internals::JsonBufferAllocated {
  ListNode<T> *next;
  T content;
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Data/NonCopyable.hpp
+++ b/src/ArduinoJson/Data/NonCopyable.hpp
@ -0,0 +1,23 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A type that cannot be copied
+class NonCopyable {
+ protected:
+  NonCopyable() {}
+
+ private:
+  // copy constructor is private
+  NonCopyable(const NonCopyable&);
+
+  // copy operator is private
+  NonCopyable& operator=(const NonCopyable&);
+};
+}
+}
--- a/src/ArduinoJson/Data/ReferenceType.hpp
+++ b/src/ArduinoJson/Data/ReferenceType.hpp
@ -0,0 +1,24 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A type that is meant to be used by reference only (JsonArray and JsonObject)
+class ReferenceType {
+ public:
+  bool operator==(const ReferenceType& other) const {
+    // two JsonArray are equal if they are the same instance
+    // (we don't compare the content)
+    return this == &other;
+  }
+
+  bool operator!=(const ReferenceType& other) const {
+    return this != &other;
+  }
+};
+}
+}
--- a/src/ArduinoJson/Data/ValueSaver.hpp
+++ b/src/ArduinoJson/Data/ValueSaver.hpp
@ -4,10 +4,10 @@

 #pragma once

+#include "../JsonBuffer.hpp"
 #include "../JsonVariant.hpp"
-#include "../Memory/JsonBuffer.hpp"
-#include "../Polyfills/type_traits.hpp"
-#include "../Strings/StringTypes.hpp"
+#include "../StringTraits/StringTraits.hpp"
+#include "../TypeTraits/EnableIf.hpp"

 namespace ArduinoJson {
 namespace Internals {
@ -21,33 +21,32 @@ struct ValueSaver {
  }
 };

-// We duplicate all strings except const char*
-template <typename TString>
+template <typename Source>
 struct ValueSaver<
-    TString, typename enable_if<IsString<TString>::value &&
-                                !is_same<const char*, TString>::value>::type> {
+    Source, typename EnableIf<StringTraits<Source>::should_duplicate>::type> {
  template <typename Destination>
-  static bool save(JsonBuffer* buffer, Destination& dest, TString source) {
-    const char* dup = makeString(source).save(buffer);
-    if (!dup) return false;
-    dest = dup;
+  static bool save(JsonBuffer* buffer, Destination& dest, Source source) {
+    if (!StringTraits<Source>::is_null(source)) {
+      typename StringTraits<Source>::duplicate_t dup =
+          StringTraits<Source>::duplicate(source, buffer);
+      if (!dup) return false;
+      dest = dup;
+    } else {
+      dest = reinterpret_cast<const char*>(0);
+    }
    return true;
  }
 };

-// We duplicate all SerializedValue<T> except SerializedValue<const char*>
-template <typename TString>
+// const char*, const signed char*, const unsigned char*
+template <typename Char>
 struct ValueSaver<
-    const SerializedValue<TString>&,
-    typename enable_if<!is_same<const char*, TString>::value>::type> {
+    Char*, typename EnableIf<!StringTraits<Char*>::should_duplicate>::type> {
  template <typename Destination>
-  static bool save(JsonBuffer* buffer, Destination& dest,
-                   const SerializedValue<TString>& source) {
-    const char* dup = makeString(source.data(), source.size()).save(buffer);
-    if (!dup) return false;
-    dest = SerializedValue<const char*>(dup, source.size());
+  static bool save(JsonBuffer*, Destination& dest, Char* source) {
+    dest = reinterpret_cast<const char*>(source);
    return true;
  }
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Deserialization/ArduinoStreamReader.hpp
+++ b/src/ArduinoJson/Deserialization/ArduinoStreamReader.hpp
@ -1,41 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
-
-#include <Stream.h>
-
-namespace ArduinoJson {
-namespace Internals {
-
-struct ArduinoStreamReader {
-  Stream& _stream;
-  char _current;
-  bool _ended;
-
- public:
-  explicit ArduinoStreamReader(Stream& stream)
-      : _stream(stream), _current(0), _ended(false) {}
-
-  char read() {
-    // don't use _stream.read() as it ignores the timeout
-    char c = 0;
-    _ended = _stream.readBytes(&c, 1) == 0;
-    return c;
-  }
-
-  bool ended() const {
-    return _ended;
-  }
-};
-
-inline ArduinoStreamReader makeReader(Stream& input) {
-  return ArduinoStreamReader(input);
-}
-}  // namespace Internals
-}  // namespace ArduinoJson
-
-#endif
--- a/src/ArduinoJson/Deserialization/CharPointerReader.hpp
+++ b/src/ArduinoJson/Deserialization/CharPointerReader.hpp
@ -1,64 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-namespace ArduinoJson {
-namespace Internals {
-
-template <typename TChar>
-class UnsafeCharPointerReader {
-  const TChar* _ptr;
-
- public:
-  explicit UnsafeCharPointerReader(const TChar* ptr)
-      : _ptr(ptr ? ptr : reinterpret_cast<const TChar*>("")) {}
-
-  char read() {
-    return static_cast<char>(*_ptr++);
-  }
-
-  bool ended() const {
-    // we cannot know
-    return false;
-  }
-};
-
-template <typename TChar>
-class SafeCharPointerReader {
-  const TChar* _ptr;
-  const TChar* _end;
-
- public:
-  explicit SafeCharPointerReader(const TChar* ptr, size_t len)
-      : _ptr(ptr ? ptr : reinterpret_cast<const TChar*>("")),
-        _end(_ptr + len) {}
-
-  char read() {
-    return static_cast<char>(*_ptr++);
-  }
-
-  bool ended() const {
-    return _ptr == _end;
-  }
-};
-
-template <typename TChar>
-inline UnsafeCharPointerReader<TChar> makeReader(TChar* input) {
-  return UnsafeCharPointerReader<TChar>(input);
-}
-
-template <typename TChar>
-inline SafeCharPointerReader<TChar> makeReader(TChar* input, size_t n) {
-  return SafeCharPointerReader<TChar>(input, n);
-}
-
-#if ARDUINOJSON_ENABLE_ARDUINO_STRING
-inline SafeCharPointerReader<char> makeReader(const String& input) {
-  return SafeCharPointerReader<char>(input.c_str(), input.length());
-}
-#endif
-
-}  // namespace Internals
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Deserialization/Comments.hpp
+++ b/src/ArduinoJson/Deserialization/Comments.hpp
@ -0,0 +1,61 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+template <typename TInput>
+void skipSpacesAndComments(TInput& input) {
+  for (;;) {
+    switch (input.current()) {
+      // spaces
+      case ' ':
+      case '\t':
+      case '\r':
+      case '\n':
+        input.move();
+        continue;
+
+      // comments
+      case '/':
+        switch (input.next()) {
+          // C-style block comment
+          case '*':
+            input.move();  // skip '/'
+            // no need to skip '*'
+            for (;;) {
+              input.move();
+              if (input.current() == '\0') return;
+              if (input.current() == '*' && input.next() == '/') {
+                input.move();  // skip '*'
+                input.move();  // skip '/'
+                break;
+              }
+            }
+            break;
+
+          // C++-style line comment
+          case '/':
+            // not need to skip "//"
+            for (;;) {
+              input.move();
+              if (input.current() == '\0') return;
+              if (input.current() == '\n') break;
+            }
+            break;
+
+          // not a comment, just a '/'
+          default:
+            return;
+        }
+        break;
+
+      default:
+        return;
+    }
+  }
+}
+}
+}
--- a/src/ArduinoJson/Deserialization/DeserializationError.hpp
+++ b/src/ArduinoJson/Deserialization/DeserializationError.hpp
@ -1,83 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#if ARDUINOJSON_ENABLE_STD_STREAM
-#include <ostream>
-#endif
-
-namespace ArduinoJson {
-
-class DeserializationError {
- public:
-  enum Code {
-    Ok,
-    IncompleteInput,
-    InvalidInput,
-    NoMemory,
-    NotSupported,
-    TooDeep
-  };
-
-  DeserializationError() {}
-  DeserializationError(Code code) : _code(code) {}
-
-  friend bool operator==(const DeserializationError& err, Code code) {
-    return err._code == code;
-  }
-
-  friend bool operator==(Code code, const DeserializationError& err) {
-    return err._code == code;
-  }
-
-  friend bool operator!=(const DeserializationError& err, Code code) {
-    return err._code != code;
-  }
-
-  friend bool operator!=(Code code, const DeserializationError& err) {
-    return err._code != code;
-  }
-
-  operator bool() const {
-    return _code != Ok;
-  }
-
-  const char* c_str() const {
-    switch (_code) {
-      case Ok:
-        return "Ok";
-      case TooDeep:
-        return "TooDeep";
-      case NoMemory:
-        return "NoMemory";
-      case InvalidInput:
-        return "InvalidInput";
-      case IncompleteInput:
-        return "IncompleteInput";
-      case NotSupported:
-        return "NotSupported";
-      default:
-        return "???";
-    }
-  }
-
- private:
-  Code _code;
-};
-
-#if ARDUINOJSON_ENABLE_STD_STREAM
-inline std::ostream& operator<<(std::ostream& s,
-                                const DeserializationError& e) {
-  s << e.c_str();
-  return s;
-}
-
-inline std::ostream& operator<<(std::ostream& s, DeserializationError::Code c) {
-  s << DeserializationError(c).c_str();
-  return s;
-}
-#endif
-
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Deserialization/FlashStringReader.hpp
+++ b/src/ArduinoJson/Deserialization/FlashStringReader.hpp
@ -1,56 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#if ARDUINOJSON_ENABLE_PROGMEM
-
-namespace ArduinoJson {
-namespace Internals {
-class UnsafeFlashStringReader {
-  const char* _ptr;
-
- public:
-  explicit UnsafeFlashStringReader(const __FlashStringHelper* ptr)
-      : _ptr(reinterpret_cast<const char*>(ptr)) {}
-
-  char read() {
-    return pgm_read_byte_near(_ptr++);
-  }
-
-  bool ended() const {
-    // this reader cannot detect the end
-    return false;
-  }
-};
-
-class SafeFlashStringReader {
-  const char* _ptr;
-  const char* _end;
-
- public:
-  explicit SafeFlashStringReader(const __FlashStringHelper* ptr, size_t size)
-      : _ptr(reinterpret_cast<const char*>(ptr)), _end(_ptr + size) {}
-
-  char read() {
-    return pgm_read_byte_near(_ptr++);
-  }
-
-  bool ended() const {
-    return _ptr == _end;
-  }
-};
-
-inline UnsafeFlashStringReader makeReader(const __FlashStringHelper* input) {
-  return UnsafeFlashStringReader(input);
-}
-
-inline SafeFlashStringReader makeReader(const __FlashStringHelper* input,
-                                        size_t size) {
-  return SafeFlashStringReader(input, size);
-}
-}  // namespace Internals
-}  // namespace ArduinoJson
-
-#endif
--- a/src/ArduinoJson/Deserialization/IteratorReader.hpp
+++ b/src/ArduinoJson/Deserialization/IteratorReader.hpp
@ -1,34 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-namespace ArduinoJson {
-namespace Internals {
-
-template <typename TIterator>
-class IteratorReader {
-  TIterator _ptr, _end;
-
- public:
-  explicit IteratorReader(TIterator begin, TIterator end)
-      : _ptr(begin), _end(end) {}
-
-  bool ended() const {
-    return _ptr == _end;
-  }
-
-  char read() {
-    return char(*_ptr++);
-  }
-};
-
-template <typename TInput>
-inline IteratorReader<typename TInput::const_iterator> makeReader(
-    const TInput& input) {
-  return IteratorReader<typename TInput::const_iterator>(input.begin(),
-                                                         input.end());
-}
-}  // namespace Internals
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Deserialization/JsonParser.hpp
+++ b/src/ArduinoJson/Deserialization/JsonParser.hpp
@ -0,0 +1,102 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+#include "../JsonVariant.hpp"
+#include "../TypeTraits/IsConst.hpp"
+#include "StringWriter.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Parse JSON string to create JsonArrays and JsonObjects
+// This internal class is not indended to be used directly.
+// Instead, use JsonBuffer.parseArray() or .parseObject()
+template <typename TReader, typename TWriter>
+class JsonParser {
+ public:
+  JsonParser(JsonBuffer *buffer, TReader reader, TWriter writer,
+             uint8_t nestingLimit)
+      : _buffer(buffer),
+        _reader(reader),
+        _writer(writer),
+        _nestingLimit(nestingLimit) {}
+
+  JsonArray &parseArray();
+  JsonObject &parseObject();
+
+  JsonVariant parseVariant() {
+    JsonVariant result;
+    parseAnythingTo(&result);
+    return result;
+  }
+
+ private:
+  JsonParser &operator=(const JsonParser &);  // non-copiable
+
+  static bool eat(TReader &, char charToSkip);
+  FORCE_INLINE bool eat(char charToSkip) {
+    return eat(_reader, charToSkip);
+  }
+
+  const char *parseString();
+  bool parseAnythingTo(JsonVariant *destination);
+
+  inline bool parseArrayTo(JsonVariant *destination);
+  inline bool parseObjectTo(JsonVariant *destination);
+  inline bool parseStringTo(JsonVariant *destination);
+
+  static inline bool isBetween(char c, char min, char max) {
+    return min <= c && c <= max;
+  }
+
+  static inline bool canBeInNonQuotedString(char c) {
+    return isBetween(c, '0', '9') || isBetween(c, '_', 'z') ||
+           isBetween(c, 'A', 'Z') || c == '+' || c == '-' || c == '.';
+  }
+
+  static inline bool isQuote(char c) {
+    return c == '\'' || c == '\"';
+  }
+
+  JsonBuffer *_buffer;
+  TReader _reader;
+  TWriter _writer;
+  uint8_t _nestingLimit;
+};
+
+template <typename TJsonBuffer, typename TString, typename Enable = void>
+struct JsonParserBuilder {
+  typedef typename StringTraits<TString>::Reader InputReader;
+  typedef JsonParser<InputReader, TJsonBuffer &> TParser;
+
+  static TParser makeParser(TJsonBuffer *buffer, TString &json,
+                            uint8_t nestingLimit) {
+    return TParser(buffer, InputReader(json), *buffer, nestingLimit);
+  }
+};
+
+template <typename TJsonBuffer, typename TChar>
+struct JsonParserBuilder<TJsonBuffer, TChar *,
+                         typename EnableIf<!IsConst<TChar>::value>::type> {
+  typedef typename StringTraits<TChar *>::Reader TReader;
+  typedef StringWriter<TChar> TWriter;
+  typedef JsonParser<TReader, TWriter> TParser;
+
+  static TParser makeParser(TJsonBuffer *buffer, TChar *json,
+                            uint8_t nestingLimit) {
+    return TParser(buffer, TReader(json), TWriter(json), nestingLimit);
+  }
+};
+
+template <typename TJsonBuffer, typename TString>
+inline typename JsonParserBuilder<TJsonBuffer, TString>::TParser makeParser(
+    TJsonBuffer *buffer, TString &json, uint8_t nestingLimit) {
+  return JsonParserBuilder<TJsonBuffer, TString>::makeParser(buffer, json,
+                                                             nestingLimit);
+}
+}  // namespace Internals
+}  // namespace ArduinoJson
--- a/src/ArduinoJson/Deserialization/JsonParserImpl.hpp
+++ b/src/ArduinoJson/Deserialization/JsonParserImpl.hpp
@ -0,0 +1,189 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+#include "Comments.hpp"
+#include "JsonParser.hpp"
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::eat(
+    TReader &reader, char charToSkip) {
+  skipSpacesAndComments(reader);
+  if (reader.current() != charToSkip) return false;
+  reader.move();
+  return true;
+}
+
+template <typename TReader, typename TWriter>
+inline bool
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingTo(
+    JsonVariant *destination) {
+  skipSpacesAndComments(_reader);
+
+  switch (_reader.current()) {
+    case '[':
+      return parseArrayTo(destination);
+
+    case '{':
+      return parseObjectTo(destination);
+
+    default:
+      return parseStringTo(destination);
+  }
+}
+
+template <typename TReader, typename TWriter>
+inline ArduinoJson::JsonArray &
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArray() {
+  if (_nestingLimit == 0) return JsonArray::invalid();
+  _nestingLimit--;
+
+  // Create an empty array
+  JsonArray &array = _buffer->createArray();
+
+  // Check opening braket
+  if (!eat('[')) goto ERROR_MISSING_BRACKET;
+  if (eat(']')) goto SUCCESS_EMPTY_ARRAY;
+
+  // Read each value
+  for (;;) {
+    // 1 - Parse value
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!array.add(value)) goto ERROR_NO_MEMORY;
+
+    // 2 - More values?
+    if (eat(']')) goto SUCCES_NON_EMPTY_ARRAY;
+    if (!eat(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_ARRAY:
+SUCCES_NON_EMPTY_ARRAY:
+  _nestingLimit++;
+  return array;
+
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACKET:
+ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
+  return JsonArray::invalid();
+}
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArrayTo(
+    JsonVariant *destination) {
+  JsonArray &array = parseArray();
+  if (!array.success()) return false;
+
+  *destination = array;
+  return true;
+}
+
+template <typename TReader, typename TWriter>
+inline ArduinoJson::JsonObject &
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseObject() {
+  if (_nestingLimit == 0) return JsonObject::invalid();
+  _nestingLimit--;
+
+  // Create an empty object
+  JsonObject &object = _buffer->createObject();
+
+  // Check opening brace
+  if (!eat('{')) goto ERROR_MISSING_BRACE;
+  if (eat('}')) goto SUCCESS_EMPTY_OBJECT;
+
+  // Read each key value pair
+  for (;;) {
+    // 1 - Parse key
+    const char *key = parseString();
+    if (!key) goto ERROR_INVALID_KEY;
+    if (!eat(':')) goto ERROR_MISSING_COLON;
+
+    // 2 - Parse value
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!object.set(key, value)) goto ERROR_NO_MEMORY;
+
+    // 3 - More keys/values?
+    if (eat('}')) goto SUCCESS_NON_EMPTY_OBJECT;
+    if (!eat(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_OBJECT:
+SUCCESS_NON_EMPTY_OBJECT:
+  _nestingLimit++;
+  return object;
+
+ERROR_INVALID_KEY:
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACE:
+ERROR_MISSING_COLON:
+ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
+  return JsonObject::invalid();
+}
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseObjectTo(
+    JsonVariant *destination) {
+  JsonObject &object = parseObject();
+  if (!object.success()) return false;
+
+  *destination = object;
+  return true;
+}
+
+template <typename TReader, typename TWriter>
+inline const char *
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseString() {
+  typename RemoveReference<TWriter>::type::String str = _writer.startString();
+
+  skipSpacesAndComments(_reader);
+  char c = _reader.current();
+
+  if (isQuote(c)) {  // quotes
+    _reader.move();
+    char stopChar = c;
+    for (;;) {
+      c = _reader.current();
+      if (c == '\0') break;
+      _reader.move();
+
+      if (c == stopChar) break;
+
+      if (c == '\\') {
+        // replace char
+        c = Encoding::unescapeChar(_reader.current());
+        if (c == '\0') break;
+        _reader.move();
+      }
+
+      str.append(c);
+    }
+  } else {  // no quotes
+    for (;;) {
+      if (!canBeInNonQuotedString(c)) break;
+      _reader.move();
+      str.append(c);
+      c = _reader.current();
+    }
+  }
+
+  return str.c_str();
+}
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseStringTo(
+    JsonVariant *destination) {
+  bool hasQuotes = isQuote(_reader.current());
+  const char *value = parseString();
+  if (value == NULL) return false;
+  if (hasQuotes) {
+    *destination = value;
+  } else {
+    *destination = RawJson(value);
+  }
+  return true;
+}
--- a/src/ArduinoJson/Deserialization/StdStreamReader.hpp
+++ b/src/ArduinoJson/Deserialization/StdStreamReader.hpp
@ -1,40 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#if ARDUINOJSON_ENABLE_STD_STREAM
-
-#include <istream>
-
-namespace ArduinoJson {
-namespace Internals {
-
-class StdStreamReader {
-  std::istream& _stream;
-  char _current;
-
- public:
-  explicit StdStreamReader(std::istream& stream)
-      : _stream(stream), _current(0) {}
-
-  bool ended() const {
-    return _stream.eof();
-  }
-
-  char read() {
-    return static_cast<char>(_stream.get());
-  }
-
- private:
-  StdStreamReader& operator=(const StdStreamReader&);  // Visual Studio C4512
-};
-
-inline StdStreamReader makeReader(std::istream& input) {
-  return StdStreamReader(input);
-}
-}  // namespace Internals
-}  // namespace ArduinoJson
-
-#endif
--- a/src/ArduinoJson/Deserialization/StringWriter.hpp
+++ b/src/ArduinoJson/Deserialization/StringWriter.hpp
@ -8,7 +8,7 @@ namespace ArduinoJson {
 namespace Internals {

 template <typename TChar>
-class StringMover {
+class StringWriter {
 public:
  class String {
   public:
@ -28,7 +28,7 @@ class StringMover {
    TChar* _startPtr;
  };

-  StringMover(TChar* buffer) : _ptr(buffer) {}
+  StringWriter(TChar* buffer) : _ptr(buffer) {}

  String startString() {
    return String(&_ptr);
@ -37,5 +37,5 @@ class StringMover {
 private:
  TChar* _ptr;
 };
-}  // namespace Internals
-}  // namespace ArduinoJson
+}
+}
--- a/src/ArduinoJson/Deserialization/deserialize.hpp
+++ b/src/ArduinoJson/Deserialization/deserialize.hpp
@ -1,82 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "../StringStorage/StringStorage.hpp"
-#include "./ArduinoStreamReader.hpp"
-#include "./CharPointerReader.hpp"
-#include "./DeserializationError.hpp"
-#include "./FlashStringReader.hpp"
-#include "./IteratorReader.hpp"
-#include "./StdStreamReader.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-
-template <template <typename, typename> class TDeserializer,
-          typename TJsonBuffer, typename TReader, typename TWriter>
-TDeserializer<TReader, TWriter> makeDeserializer(TJsonBuffer *buffer,
-                                                 TReader reader, TWriter writer,
-                                                 uint8_t nestingLimit) {
-  return TDeserializer<TReader, TWriter>(buffer, reader, writer, nestingLimit);
-}
-
-// DeserializationError deserialize(TDocument& doc, TString input);
-// TDocument = DynamicJsonDocument, StaticJsonDocument
-// TString = const std::string&, const String&
-template <template <typename, typename> class TDeserializer, typename TDocument,
-          typename TString>
-typename Internals::enable_if<!Internals::is_array<TString>::value,
-                              DeserializationError>::type
-deserialize(TDocument &doc, const TString &input) {
-  using namespace Internals;
-  return makeDeserializer<TDeserializer>(&doc.buffer(), makeReader(input),
-                                         makeStringStorage(doc.buffer(), input),
-                                         doc.nestingLimit)
-      .parse(doc.template to<JsonVariant>());
-}
-//
-// DeserializationError deserialize(TDocument& doc, TChar* input);
-// TDocument = DynamicJsonDocument, StaticJsonDocument
-// TChar* = char*, const char*, const FlashStringHelper*
-template <template <typename, typename> class TDeserializer, typename TDocument,
-          typename TChar>
-DeserializationError deserialize(TDocument &doc, TChar *input) {
-  using namespace Internals;
-  return makeDeserializer<TDeserializer>(&doc.buffer(), makeReader(input),
-                                         makeStringStorage(doc.buffer(), input),
-                                         doc.nestingLimit)
-      .parse(doc.template to<JsonVariant>());
-}
-//
-// DeserializationError deserialize(TDocument& doc, TChar* input, size_t
-// inputSize);
-// TDocument = DynamicJsonDocument, StaticJsonDocument
-// TChar* = char*, const char*, const FlashStringHelper*
-template <template <typename, typename> class TDeserializer, typename TDocument,
-          typename TChar>
-DeserializationError deserialize(TDocument &doc, TChar *input,
-                                 size_t inputSize) {
-  using namespace Internals;
-  return makeDeserializer<TDeserializer>(
-             &doc.buffer(), makeReader(input, inputSize),
-             makeStringStorage(doc.buffer(), input), doc.nestingLimit)
-      .parse(doc.template to<JsonVariant>());
-}
-//
-// DeserializationError deserialize(TDocument& doc, TStream input);
-// TDocument = DynamicJsonDocument, StaticJsonDocument
-// TStream = std::istream&, Stream&
-template <template <typename, typename> class TDeserializer, typename TDocument,
-          typename TStream>
-DeserializationError deserialize(TDocument &doc, TStream &input) {
-  using namespace Internals;
-  return makeDeserializer<TDeserializer>(&doc.buffer(), makeReader(input),
-                                         makeStringStorage(doc.buffer(), input),
-                                         doc.nestingLimit)
-      .parse(doc.template to<JsonVariant>());
-}
-}  // namespace Internals
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Memory/DynamicJsonBuffer.hpp
+++ b/src/ArduinoJson/Memory/DynamicJsonBuffer.hpp
@ -4,7 +4,7 @@

 #pragma once

-#include "JsonBuffer.hpp"
+#include "JsonBufferBase.hpp"

 #include <stdlib.h>

@ -31,7 +31,8 @@ class DefaultAllocator {
 };

 template <typename TAllocator>
-class DynamicJsonBufferBase : public JsonBuffer {
+class DynamicJsonBufferBase
+    : public JsonBufferBase<DynamicJsonBufferBase<TAllocator> > {
  struct Block;
  struct EmptyBlock {
    Block* next;
@ -151,13 +152,7 @@ class DynamicJsonBufferBase : public JsonBuffer {
  Block* _head;
  size_t _nextBlockCapacity;
 };
-
-// Implements a JsonBuffer with dynamic memory allocation.
-// You are strongly encouraged to consider using StaticJsonBuffer which is much
-// more suitable for embedded systems.
-typedef Internals::DynamicJsonBufferBase<Internals::DefaultAllocator>
-    DynamicJsonBuffer;
-}  // namespace Internals
+}

 #if defined(__clang__)
 #pragma clang diagnostic pop
@ -166,4 +161,10 @@ typedef Internals::DynamicJsonBufferBase<Internals::DefaultAllocator>
 #pragma GCC diagnostic pop
 #endif
 #endif
-}  // namespace ArduinoJson
+
+// Implements a JsonBuffer with dynamic memory allocation.
+// You are strongly encouraged to consider using StaticJsonBuffer which is much
+// more suitable for embedded systems.
+typedef Internals::DynamicJsonBufferBase<Internals::DefaultAllocator>
+    DynamicJsonBuffer;
+}
--- a/src/ArduinoJson/DynamicJsonDocument.hpp
+++ b/src/ArduinoJson/DynamicJsonDocument.hpp
@ -1,84 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "JsonArray.hpp"
-#include "JsonObject.hpp"
-#include "JsonVariant.hpp"
-#include "Memory/DynamicJsonBuffer.hpp"
-
-namespace ArduinoJson {
-
-class DynamicJsonDocument {
-  Internals::DynamicJsonBuffer _buffer;
-  JsonVariant _root;
-
- public:
-  uint8_t nestingLimit;
-
-  DynamicJsonDocument() : nestingLimit(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
-  DynamicJsonDocument(size_t capacity)
-      : _buffer(capacity), nestingLimit(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
-
-  template <typename T>
-  bool is() const {
-    return _root.is<T>();
-  }
-
-  template <typename T>
-  typename Internals::JsonVariantAs<T>::type as() const {
-    return _root.as<T>();
-  }
-
-  // JsonObject to<JsonObject>()
-  template <typename T>
-  typename Internals::enable_if<Internals::is_same<T, JsonObject>::value,
-                                JsonObject>::type
-  to() {
-    clear();
-    JsonObject object(&_buffer);
-    _root = object;
-    return object;
-  }
-
-  // JsonArray to<JsonArray>()
-  template <typename T>
-  typename Internals::enable_if<Internals::is_same<T, JsonArray>::value,
-                                JsonArray>::type
-  to() {
-    clear();
-    JsonArray array(&_buffer);
-    _root = array;
-    return array;
-  }
-
-  // JsonVariant& to<JsonVariant>()
-  template <typename T>
-  typename Internals::enable_if<Internals::is_same<T, JsonVariant>::value,
-                                T&>::type
-  to() {
-    clear();
-    return _root;
-  }
-
-  Internals::DynamicJsonBuffer& buffer() {
-    return _buffer;
-  }
-
-  void clear() {
-    _buffer.clear();
-    _root = JsonVariant();
-  }
-
-  size_t memoryUsage() const {
-    return _buffer.size();
-  }
-
-  template <typename Visitor>
-  void visit(Visitor& visitor) const {
-    return _root.visit(visitor);
-  }
-};
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Json/JsonDeserializer.hpp
+++ b/src/ArduinoJson/Json/JsonDeserializer.hpp
@ -1,365 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "../Deserialization/deserialize.hpp"
-#include "../JsonVariant.hpp"
-#include "../Memory/JsonBuffer.hpp"
-#include "../Polyfills/type_traits.hpp"
-#include "./EscapeSequence.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-
-template <typename TReader, typename TStringStorage>
-class JsonDeserializer {
- public:
-  JsonDeserializer(JsonBuffer *buffer, TReader reader,
-                   TStringStorage stringStorage, uint8_t nestingLimit)
-      : _buffer(buffer),
-        _reader(reader),
-        _stringStorage(stringStorage),
-        _nestingLimit(nestingLimit),
-        _loaded(false) {}
-  DeserializationError parse(JsonVariant &variant) {
-    DeserializationError err = skipSpacesAndComments();
-    if (err) return err;
-
-    switch (current()) {
-      case '[':
-        return parseArray(variant);
-
-      case '{':
-        return parseObject(variant);
-
-      default:
-        return parseValue(variant);
-    }
-  }
-
- private:
-  JsonDeserializer &operator=(const JsonDeserializer &);  // non-copiable
-
-  char current() {
-    if (!_loaded) {
-      if (_reader.ended())
-        _current = 0;
-      else
-        _current = _reader.read();
-      _loaded = true;
-    }
-    return _current;
-  }
-
-  void move() {
-    _loaded = false;
-  }
-
-  FORCE_INLINE bool eat(char charToSkip) {
-    if (current() != charToSkip) return false;
-    move();
-    return true;
-  }
-
-  DeserializationError parseArray(JsonVariant &variant) {
-    if (_nestingLimit == 0) return DeserializationError::TooDeep;
-
-    JsonArray array(_buffer);
-    if (array.isNull()) return DeserializationError::NoMemory;
-    variant = array;
-
-    // Check opening braket
-    if (!eat('[')) return DeserializationError::InvalidInput;
-
-    // Skip spaces
-    DeserializationError err = skipSpacesAndComments();
-    if (err) return err;
-
-    // Empty array?
-    if (eat(']')) return DeserializationError::Ok;
-
-    // Read each value
-    for (;;) {
-      // 1 - Parse value
-      JsonVariant value;
-      _nestingLimit--;
-      err = parse(value);
-      _nestingLimit++;
-      if (err) return err;
-      if (!array.add(value)) return DeserializationError::NoMemory;
-
-      // 2 - Skip spaces
-      err = skipSpacesAndComments();
-      if (err) return err;
-
-      // 3 - More values?
-      if (eat(']')) return DeserializationError::Ok;
-      if (!eat(',')) return DeserializationError::InvalidInput;
-    }
-  }
-
-  DeserializationError parseObject(JsonVariant &variant) {
-    if (_nestingLimit == 0) return DeserializationError::TooDeep;
-
-    JsonObject object(_buffer);
-    if (object.isNull()) return DeserializationError::NoMemory;
-    variant = object;
-
-    // Check opening brace
-    if (!eat('{')) return DeserializationError::InvalidInput;
-
-    // Skip spaces
-    DeserializationError err = skipSpacesAndComments();
-    if (err) return err;
-
-    // Empty object?
-    if (eat('}')) return DeserializationError::Ok;
-
-    // Read each key value pair
-    for (;;) {
-      // Parse key
-      const char *key;
-      err = parseKey(&key);
-      if (err) return err;
-
-      // Skip spaces
-      err = skipSpacesAndComments();
-      if (err) return err;  // Colon
-      if (!eat(':')) return DeserializationError::InvalidInput;
-
-      // Parse value
-      JsonVariant value;
-      _nestingLimit--;
-      err = parse(value);
-      _nestingLimit++;
-      if (err) return err;
-      if (!object.set(key, value)) return DeserializationError::NoMemory;
-
-      // Skip spaces
-      err = skipSpacesAndComments();
-      if (err) return err;
-
-      // More keys/values?
-      if (eat('}')) return DeserializationError::Ok;
-      if (!eat(',')) return DeserializationError::InvalidInput;
-
-      // Skip spaces
-      err = skipSpacesAndComments();
-      if (err) return err;
-    }
-  }
-
-  DeserializationError parseValue(JsonVariant &variant) {
-    if (isQuote(current())) {
-      return parseStringValue(variant);
-    } else {
-      return parseNumericValue(variant);
-    }
-  }
-
-  DeserializationError parseKey(const char **key) {
-    if (isQuote(current())) {
-      return parseQuotedString(key);
-    } else {
-      return parseNonQuotedString(key);
-    }
-  }
-
-  DeserializationError parseStringValue(JsonVariant &variant) {
-    const char *value;
-    DeserializationError err = parseQuotedString(&value);
-    if (err) return err;
-    variant = value;
-    return DeserializationError::Ok;
-  }
-
-  DeserializationError parseQuotedString(const char **result) {
-    typename remove_reference<TStringStorage>::type::String str =
-        _stringStorage.startString();
-
-    char stopChar = current();
-
-    move();
-    for (;;) {
-      char c = current();
-      move();
-      if (c == stopChar) break;
-
-      if (c == '\0') return DeserializationError::IncompleteInput;
-
-      if (c == '\\') {
-        c = current();
-        if (c == '\0') return DeserializationError::IncompleteInput;
-        if (c == 'u') return DeserializationError::NotSupported;
-        // replace char
-        c = EscapeSequence::unescapeChar(c);
-        if (c == '\0') return DeserializationError::InvalidInput;
-        move();
-      }
-
-      str.append(c);
-    }
-
-    *result = str.c_str();
-    if (*result == NULL) return DeserializationError::NoMemory;
-    return DeserializationError::Ok;
-  }
-
-  DeserializationError parseNonQuotedString(const char **result) {
-    typename remove_reference<TStringStorage>::type::String str =
-        _stringStorage.startString();
-
-    char c = current();
-    if (c == '\0') return DeserializationError::IncompleteInput;
-
-    if (canBeInNonQuotedString(c)) {  // no quotes
-      do {
-        move();
-        str.append(c);
-        c = current();
-      } while (canBeInNonQuotedString(c));
-    } else {
-      return DeserializationError::InvalidInput;
-    }
-
-    *result = str.c_str();
-    if (*result == NULL) return DeserializationError::NoMemory;
-    return DeserializationError::Ok;
-  }
-
-  DeserializationError parseNumericValue(JsonVariant &result) {
-    char buffer[64];
-    uint8_t n = 0;
-
-    char c = current();
-    while (canBeInNonQuotedString(c) && n < 63) {
-      move();
-      buffer[n++] = c;
-      c = current();
-    }
-    buffer[n] = 0;
-
-    if (isInteger(buffer)) {
-      result = parseInteger<JsonInteger>(buffer);
-    } else if (isFloat(buffer)) {
-      result = parseFloat<JsonFloat>(buffer);
-    } else if (!strcmp(buffer, "true")) {
-      result = true;
-    } else if (!strcmp(buffer, "false")) {
-      result = false;
-    } else if (!strcmp(buffer, "null")) {
-      result = static_cast<const char *>(0);
-    } else {
-      return DeserializationError::InvalidInput;
-    }
-    return DeserializationError::Ok;
-  }
-
-  static inline bool isBetween(char c, char min, char max) {
-    return min <= c && c <= max;
-  }
-
-  static inline bool canBeInNonQuotedString(char c) {
-    return isBetween(c, '0', '9') || isBetween(c, '_', 'z') ||
-           isBetween(c, 'A', 'Z') || c == '+' || c == '-' || c == '.';
-  }
-
-  static inline bool isQuote(char c) {
-    return c == '\'' || c == '\"';
-  }
-
-  DeserializationError skipSpacesAndComments() {
-    for (;;) {
-      switch (current()) {
-        // end of string
-        case '\0':
-          return DeserializationError::IncompleteInput;
-
-        // spaces
-        case ' ':
-        case '\t':
-        case '\r':
-        case '\n':
-          move();
-          continue;
-
-        // comments
-        case '/':
-          move();  // skip '/'
-          switch (current()) {
-            // block comment
-            case '*': {
-              move();  // skip '*'
-              bool wasStar = false;
-              for (;;) {
-                char c = current();
-                if (c == '\0') return DeserializationError::IncompleteInput;
-                if (c == '/' && wasStar) {
-                  move();
-                  break;
-                }
-                wasStar = c == '*';
-                move();
-              }
-              break;
-            }
-
-            // trailing comment
-            case '/':
-              // no need to skip "//"
-              for (;;) {
-                move();
-                char c = current();
-                if (c == '\0') return DeserializationError::IncompleteInput;
-                if (c == '\n') break;
-              }
-              break;
-
-            // not a comment, just a '/'
-            default:
-              return DeserializationError::InvalidInput;
-          }
-          break;
-
-        default:
-          return DeserializationError::Ok;
-      }
-    }
-  }
-
-  JsonBuffer *_buffer;
-  TReader _reader;
-  TStringStorage _stringStorage;
-  uint8_t _nestingLimit;
-  char _current;
-  bool _loaded;
-};  // namespace Internals
-}  // namespace Internals
-
-template <typename TDocument, typename TInput>
-DeserializationError deserializeJson(TDocument &doc, const TInput &input) {
-  using namespace Internals;
-  return deserialize<JsonDeserializer>(doc, input);
-}
-
-template <typename TDocument, typename TInput>
-DeserializationError deserializeJson(TDocument &doc, TInput *input) {
-  using namespace Internals;
-  return deserialize<JsonDeserializer>(doc, input);
-}
-
-template <typename TDocument, typename TInput>
-DeserializationError deserializeJson(TDocument &doc, TInput *input,
-                                     size_t inputSize) {
-  using namespace Internals;
-  return deserialize<JsonDeserializer>(doc, input, inputSize);
-}
-
-template <typename TDocument, typename TInput>
-DeserializationError deserializeJson(TDocument &doc, TInput &input) {
-  using namespace Internals;
-  return deserialize<JsonDeserializer>(doc, input);
-}
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Json/JsonSerializer.hpp
+++ b/src/ArduinoJson/Json/JsonSerializer.hpp
@ -1,142 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "../Serialization/measure.hpp"
-#include "../Serialization/serialize.hpp"
-#include "./JsonWriter.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-
-template <typename TWriter>
-class JsonSerializer {
- public:
-  JsonSerializer(TWriter &writer) : _writer(writer) {}
-
-  void acceptFloat(JsonFloat value) {
-    _writer.writeFloat(value);
-  }
-
-  void acceptArray(const JsonArray &array) {
-    _writer.beginArray();
-
-    JsonArray::const_iterator it = array.begin();
-    while (it != array.end()) {
-      it->visit(*this);
-
-      ++it;
-      if (it == array.end()) break;
-
-      _writer.writeComma();
-    }
-
-    _writer.endArray();
-  }
-
-  void acceptObject(const JsonObject &object) {
-    _writer.beginObject();
-
-    JsonObject::const_iterator it = object.begin();
-    while (it != object.end()) {
-      _writer.writeString(it->key);
-      _writer.writeColon();
-      it->value.visit(*this);
-
-      ++it;
-      if (it == object.end()) break;
-
-      _writer.writeComma();
-    }
-
-    _writer.endObject();
-  }
-
-  void acceptString(const char *value) {
-    _writer.writeString(value);
-  }
-
-  void acceptRawJson(const char *data, size_t n) {
-    // TODO
-    for (size_t i = 0; i < n; i++) _writer.writeRaw(data[i]);
-  }
-
-  void acceptNegativeInteger(JsonUInt value) {
-    _writer.writeRaw('-');
-    _writer.writeInteger(value);
-  }
-
-  void acceptPositiveInteger(JsonUInt value) {
-    _writer.writeInteger(value);
-  }
-
-  void acceptBoolean(bool value) {
-    _writer.writeBoolean(value);
-  }
-
-  void acceptNull() {
-    _writer.writeRaw("null");
-  }
-
-  size_t bytesWritten() const {
-    return _writer.bytesWritten();
-  }
-
- private:
-  JsonWriter<TWriter> _writer;
-};
-
-}  // namespace Internals
-
-template <typename TSource, typename TDestination>
-size_t serializeJson(TSource &source, TDestination &destination) {
-  using namespace Internals;
-  return serialize<JsonSerializer>(source, destination);
-}
-
-template <typename TSource>
-size_t serializeJson(const TSource &source, char *buffer, size_t bufferSize) {
-  using namespace Internals;
-  return serialize<JsonSerializer>(source, buffer, bufferSize);
-}
-
-template <typename TSource>
-size_t measureJson(const TSource &source) {
-  using namespace Internals;
-  return measure<JsonSerializer>(source);
-}
-
-#if ARDUINOJSON_ENABLE_STD_STREAM
-inline std::ostream &operator<<(std::ostream &os, const JsonArray &source) {
-  serializeJson(source, os);
-  return os;
-}
-inline std::ostream &operator<<(std::ostream &os, const JsonObject &source) {
-  serializeJson(source, os);
-  return os;
-}
-inline std::ostream &operator<<(std::ostream &os, const JsonVariant &source) {
-  serializeJson(source, os);
-  return os;
-}
-
-namespace Internals {
-inline std::ostream &operator<<(std::ostream &os,
-                                const JsonArraySubscript &source) {
-  serializeJson(source, os);
-  return os;
-}
-
-template <typename TKey>
-inline std::ostream &operator<<(std::ostream &os,
-                                const JsonObjectSubscript<TKey> &source) {
-  serializeJson(source, os);
-  return os;
-}
-}  // namespace Internals
-
-#endif
-
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
+++ b/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
@ -1,57 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "../Serialization/measure.hpp"
-#include "../Serialization/serialize.hpp"
-#include "./IndentedPrint.hpp"
-#include "./JsonSerializer.hpp"
-#include "./Prettyfier.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-
-template <typename TPrint>
-class PrettyJsonSerializer_Base {
- public:
-  PrettyJsonSerializer_Base(TPrint &output)
-      : _indentedPrint(output), _prettyfier(_indentedPrint) {}
-
- protected:
-  IndentedPrint<TPrint> _indentedPrint;
-  Prettyfier<TPrint> _prettyfier;
-};
-
-template <typename TPrint>
-class PrettyJsonSerializer : PrettyJsonSerializer_Base<TPrint>,
-                             public JsonSerializer<Prettyfier<TPrint> > {
- public:
-  PrettyJsonSerializer(TPrint &output)
-      : PrettyJsonSerializer_Base<TPrint>(output),
-        JsonSerializer<Prettyfier<TPrint> >(
-            PrettyJsonSerializer_Base<TPrint>::_prettyfier) {}
-};
-}  // namespace Internals
-
-template <typename TSource, typename TDestination>
-size_t serializeJsonPretty(TSource &source, TDestination &destination) {
-  using namespace Internals;
-  return serialize<PrettyJsonSerializer>(source, destination);
-}
-
-template <typename TSource>
-size_t serializeJsonPretty(const TSource &source, char *buffer,
-                           size_t bufferSize) {
-  using namespace Internals;
-  return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
-}
-
-template <typename TSource>
-size_t measureJsonPretty(const TSource &source) {
-  using namespace Internals;
-  return measure<PrettyJsonSerializer>(source);
-}
-
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/JsonArray.hpp
+++ b/src/ArduinoJson/JsonArray.hpp
@ -4,126 +4,104 @@

 #pragma once

-#include "./JsonArrayData.hpp"
+#include "Data/JsonBufferAllocated.hpp"
+#include "Data/List.hpp"
+#include "Data/ReferenceType.hpp"
+#include "Data/ValueSaver.hpp"
+#include "JsonVariant.hpp"
+#include "Serialization/JsonPrintable.hpp"
+#include "StringTraits/StringTraits.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsArray.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsSame.hpp"
+
+// Returns the size (in bytes) of an array with n elements.
+// Can be very handy to determine the size of a StaticJsonBuffer.
+#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
+  (sizeof(JsonArray) + (NUMBER_OF_ELEMENTS) * sizeof(JsonArray::node_type))

 namespace ArduinoJson {

+// Forward declarations
 class JsonObject;
-
+class JsonBuffer;
 namespace Internals {
 class JsonArraySubscript;
 }

-class JsonArray {
-  friend class JsonVariant;
-
+// An array of JsonVariant.
+//
+// The constructor is private, instances must be created via
+// JsonBuffer::createArray() or JsonBuffer::parseArray().
+// A JsonArray can be serialized to a JSON string via JsonArray::printTo().
+// It can also be deserialized from a JSON string via JsonBuffer::parseArray().
+class JsonArray : public Internals::JsonPrintable<JsonArray>,
+                  public Internals::ReferenceType,
+                  public Internals::NonCopyable,
+                  public Internals::List<JsonVariant>,
+                  public Internals::JsonBufferAllocated {
 public:
-  typedef Internals::JsonArrayData::iterator iterator;
-  typedef Internals::JsonArrayData::const_iterator const_iterator;
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  // You should not call this constructor directly.
+  // Instead, use JsonBuffer::createArray() or JsonBuffer::parseArray().
+  explicit JsonArray(JsonBuffer *buffer) throw()
+      : Internals::List<JsonVariant>(buffer) {}

-  JsonArray() : _data(0) {}
-  JsonArray(Internals::JsonArrayData* arr) : _data(arr) {}
-  JsonArray(Internals::JsonBuffer* buf)
-      : _data(new (buf) Internals::JsonArrayData(buf)) {}
+  // Gets the value at the specified index
+  const Internals::JsonArraySubscript operator[](size_t index) const;
+
+  // Gets or sets the value at specified index
+  Internals::JsonArraySubscript operator[](size_t index);

  // Adds the specified value at the end of the array.
  //
  // bool add(TValue);
-  // TValue = bool, long, int, short, float, double, serialized, JsonVariant,
-  //          std::string, String, JsonArrayData, JsonObject
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          std::string, String, JsonArray, JsonObject
  template <typename T>
-  bool add(const T& value) {
-    return add_impl<const T&>(value);
+  bool add(const T &value) {
+    return add_impl<const T &>(value);
  }
  //
  // bool add(TValue);
  // TValue = char*, const char*, const FlashStringHelper*
  template <typename T>
-  bool add(T* value) {
-    return add_impl<T*>(value);
+  bool add(T *value) {
+    return add_impl<T *>(value);
  }
-
-  iterator begin() {
-    if (!_data) return iterator();
-    return _data->begin();
-  }
-
-  const_iterator begin() const {
-    if (!_data) return const_iterator();
-    return _data->begin();
-  }
-
-  iterator end() {
-    return iterator();
-  }
-
-  const_iterator end() const {
-    return const_iterator();
-  }
-
-  // Imports a 1D array
-  template <typename T, size_t N>
-  bool copyFrom(T (&array)[N]) {
-    return copyFrom(array, N);
-  }
-
-  // Imports a 1D array
+  //
+  // bool add(TValue value, uint8_t decimals);
+  // TValue = float, double
  template <typename T>
-  bool copyFrom(T* array, size_t len) {
-    bool ok = true;
-    for (size_t i = 0; i < len; i++) {
-      ok &= add(array[i]);
-    }
-    return ok;
+  DEPRECATED("Second argument is not supported anymore")
+  bool add(T value, uint8_t) {
+    return add_impl<const JsonVariant &>(JsonVariant(value));
  }

-  // Imports a 2D array
-  template <typename T, size_t N1, size_t N2>
-  bool copyFrom(T (&array)[N1][N2]) {
-    bool ok = true;
-    for (size_t i = 0; i < N1; i++) {
-      JsonArray nestedArray = createNestedArray();
-      for (size_t j = 0; j < N2; j++) {
-        ok &= nestedArray.add(array[i][j]);
-      }
-    }
-    return ok;
-  }
-
-  // Exports a 1D array
-  template <typename T, size_t N>
-  size_t copyTo(T (&array)[N]) const {
-    return copyTo(array, N);
-  }
-
-  // Exports a 1D array
+  // Sets the value at specified index.
+  //
+  // bool add(size_t index, const TValue&);
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          std::string, String, JsonArray, JsonObject
  template <typename T>
-  size_t copyTo(T* array, size_t len) const {
-    size_t i = 0;
-    for (const_iterator it = begin(); it != end() && i < len; ++it)
-      array[i++] = *it;
-    return i;
+  bool set(size_t index, const T &value) {
+    return set_impl<const T &>(index, value);
  }
-
-  // Exports a 2D array
-  template <typename T, size_t N1, size_t N2>
-  void copyTo(T (&array)[N1][N2]) const {
-    if (!_data) return;
-    size_t i = 0;
-    for (const_iterator it = begin(); it != end() && i < N1; ++it) {
-      it->as<JsonArray>().copyTo(array[i++]);
-    }
+  //
+  // bool add(size_t index, TValue);
+  // TValue = char*, const char*, const FlashStringHelper*
+  template <typename T>
+  bool set(size_t index, T *value) {
+    return set_impl<T *>(index, value);
  }
-
-  JsonArray createNestedArray();
-  JsonObject createNestedObject();
-
-  Internals::JsonArraySubscript operator[](size_t index);
-
-  const Internals::JsonArraySubscript operator[](size_t index) const;
-
-  bool operator==(const JsonArray& rhs) const {
-    return _data == rhs._data;
+  //
+  // bool set(size_t index, TValue value, uint8_t decimals);
+  // TValue = float, double
+  template <typename T>
+  typename Internals::EnableIf<Internals::IsFloatingPoint<T>::value, bool>::type
+  set(size_t index, T value, uint8_t decimals) {
+    return set_impl<const JsonVariant &>(index, JsonVariant(value, decimals));
  }

  // Gets the value at the specified index.
@ -140,69 +118,110 @@ class JsonArray {
    return it != end() ? it->is<T>() : false;
  }

-  // Removes element at specified position.
-  void remove(iterator it) {
-    if (!_data) return;
-    _data->remove(it);
-  }
+  // Creates a JsonArray and adds a reference at the end of the array.
+  // It's a shortcut for JsonBuffer::createArray() and JsonArray::add()
+  JsonArray &createNestedArray();
+
+  // Creates a JsonObject and adds a reference at the end of the array.
+  // It's a shortcut for JsonBuffer::createObject() and JsonArray::add()
+  JsonObject &createNestedObject();

  // Removes element at specified index.
  void remove(size_t index) {
    remove(begin() += index);
  }
+  using Internals::List<JsonVariant>::remove;

-  // Sets the value at specified index.
-  //
-  // bool add(size_t index, const TValue&);
-  // TValue = bool, long, int, short, float, double, serialized, JsonVariant,
-  //          std::string, String, JsonArrayData, JsonObject
+  // Returns a reference an invalid JsonArray.
+  // This object is meant to replace a NULL pointer.
+  // This is used when memory allocation or JSON parsing fail.
+  static JsonArray &invalid() {
+    static JsonArray instance(NULL);
+    return instance;
+  }
+
+  // Imports a 1D array
+  template <typename T, size_t N>
+  bool copyFrom(T (&array)[N]) {
+    return copyFrom(array, N);
+  }
+
+  // Imports a 1D array
  template <typename T>
-  bool set(size_t index, const T& value) {
-    if (!_data) return false;
-    return set_impl<const T&>(index, value);
+  bool copyFrom(T *array, size_t len) {
+    bool ok = true;
+    for (size_t i = 0; i < len; i++) {
+      ok &= add(array[i]);
+    }
+    return ok;
  }
-  //
-  // bool add(size_t index, TValue);
-  // TValue = char*, const char*, const FlashStringHelper*
+
+  // Imports a 2D array
+  template <typename T, size_t N1, size_t N2>
+  bool copyFrom(T (&array)[N1][N2]) {
+    bool ok = true;
+    for (size_t i = 0; i < N1; i++) {
+      JsonArray &nestedArray = createNestedArray();
+      for (size_t j = 0; j < N2; j++) {
+        ok &= nestedArray.add(array[i][j]);
+      }
+    }
+    return ok;
+  }
+
+  // Exports a 1D array
+  template <typename T, size_t N>
+  size_t copyTo(T (&array)[N]) const {
+    return copyTo(array, N);
+  }
+
+  // Exports a 1D array
  template <typename T>
-  bool set(size_t index, T* value) {
-    if (!_data) return false;
-    return set_impl<T*>(index, value);
+  size_t copyTo(T *array, size_t len) const {
+    size_t i = 0;
+    for (const_iterator it = begin(); it != end() && i < len; ++it)
+      array[i++] = *it;
+    return i;
  }

-  size_t size() const {
-    if (!_data) return 0;
-    return _data->size();
+  // Exports a 2D array
+  template <typename T, size_t N1, size_t N2>
+  void copyTo(T (&array)[N1][N2]) const {
+    size_t i = 0;
+    for (const_iterator it = begin(); it != end() && i < N1; ++it) {
+      it->as<JsonArray>().copyTo(array[i++]);
+    }
  }

-  bool isNull() const {
-    return _data == 0;
-  }
-
-  template <typename Visitor>
-  void visit(Visitor& visitor) const {
-    if (_data)
-      return visitor.acceptArray(*this);
-    else
-      visitor.acceptNull();
+#if ARDUINOJSON_ENABLE_DEPRECATED
+  DEPRECATED("use remove() instead")
+  FORCE_INLINE void removeAt(size_t index) {
+    return remove(index);
  }
+#endif

 private:
  template <typename TValueRef>
  bool set_impl(size_t index, TValueRef value) {
    iterator it = begin() += index;
    if (it == end()) return false;
-    return Internals::ValueSaver<TValueRef>::save(_data->_buffer, *it, value);
+    return Internals::ValueSaver<TValueRef>::save(_buffer, *it, value);
  }

  template <typename TValueRef>
  bool add_impl(TValueRef value) {
-    if (!_data) return false;
-    iterator it = _data->add();
+    iterator it = Internals::List<JsonVariant>::add();
    if (it == end()) return false;
-    return Internals::ValueSaver<TValueRef>::save(_data->_buffer, *it, value);
+    return Internals::ValueSaver<TValueRef>::save(_buffer, *it, value);
  }
-
-  Internals::JsonArrayData* _data;
 };
-}  // namespace ArduinoJson
+
+namespace Internals {
+template <>
+struct JsonVariantDefault<JsonArray> {
+  static JsonArray &get() {
+    return JsonArray::invalid();
+  }
+};
+}
+}
--- a/src/ArduinoJson/JsonArrayData.hpp
+++ b/src/ArduinoJson/JsonArrayData.hpp
@ -1,26 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "Data/List.hpp"
-#include "Data/ValueSaver.hpp"
-#include "JsonVariant.hpp"
-#include "Memory/JsonBufferAllocated.hpp"
-#include "Polyfills/type_traits.hpp"
-
-// Returns the size (in bytes) of an array with n elements.
-// Can be very handy to determine the size of a StaticJsonBuffer.
-#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS)        \
-  (sizeof(ArduinoJson::Internals::JsonArrayData) + \
-   (NUMBER_OF_ELEMENTS) *                          \
-       sizeof(ArduinoJson::Internals::JsonArrayData::node_type))
-
-namespace ArduinoJson {
-namespace Internals {
-struct JsonArrayData : List<JsonVariant>, JsonBufferAllocated {
-  explicit JsonArrayData(JsonBuffer *buf) throw() : List<JsonVariant>(buf) {}
-};
-}  // namespace Internals
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/JsonArrayImpl.hpp
+++ b/src/ArduinoJson/JsonArrayImpl.hpp
@ -5,21 +5,22 @@
 #pragma once

 #include "JsonArray.hpp"
+#include "JsonArraySubscript.hpp"
 #include "JsonObject.hpp"

 namespace ArduinoJson {

-inline JsonArray JsonArray::createNestedArray() {
-  if (!_data) return JsonArray();
-  JsonArray array(_data->_buffer);
-  if (!array.isNull()) add(array);
+inline JsonArray &JsonArray::createNestedArray() {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  add(array);
  return array;
 }

-inline JsonObject JsonArray::createNestedObject() {
-  if (!_data) return JsonObject();
-  JsonObject object(_data->_buffer);
-  if (!object.isNull()) add(object);
+inline JsonObject &JsonArray::createNestedObject() {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  add(object);
  return object;
 }
-}  // namespace ArduinoJson
+}
--- a/src/ArduinoJson/JsonArraySubscript.hpp
+++ b/src/ArduinoJson/JsonArraySubscript.hpp
@ -16,7 +16,7 @@ namespace ArduinoJson {
 namespace Internals {
 class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
 public:
-  FORCE_INLINE JsonArraySubscript(JsonArray array, size_t index)
+  FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
      : _array(array), _index(index) {}

  FORCE_INLINE JsonArraySubscript& operator=(const JsonArraySubscript& src) {
@ -27,7 +27,7 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
  // Replaces the value
  //
  // operator=(const TValue&)
-  // TValue = bool, long, int, short, float, double, serialized, JsonVariant,
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
  //          std::string, String, JsonArray, JsonObject
  template <typename T>
  FORCE_INLINE JsonArraySubscript& operator=(const T& src) {
@ -43,8 +43,8 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
    return *this;
  }

-  FORCE_INLINE bool isNull() const {
-    return _index >= _array.size();
+  FORCE_INLINE bool success() const {
+    return _index < _array.size();
  }

  template <typename T>
@ -60,7 +60,7 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
  // Replaces the value
  //
  // bool set(const TValue&)
-  // TValue = bool, long, int, short, float, double, serialized, JsonVariant,
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
  //          std::string, String, JsonArray, JsonObject
  template <typename TValue>
  FORCE_INLINE bool set(const TValue& value) {
@ -73,14 +73,17 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
  FORCE_INLINE bool set(TValue* value) {
    return _array.set(_index, value);
  }
-
-  template <typename Visitor>
-  void visit(Visitor& visitor) const {
-    return _array.get<JsonVariant>(_index).visit(visitor);
+  //
+  // bool set(TValue, uint8_t decimals);
+  // TValue = float, double
+  template <typename TValue>
+  DEPRECATED("Second argument is not supported anymore")
+  FORCE_INLINE bool set(const TValue& value, uint8_t) {
+    return _array.set(_index, value);
  }

 private:
-  JsonArray _array;
+  JsonArray& _array;
  const size_t _index;
 };

@ -95,7 +98,14 @@ inline const JsonArraySubscript JsonVariantSubscripts<TImpl>::operator[](
    size_t index) const {
  return impl()->template as<JsonArray>()[index];
 }
-}  // namespace Internals
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream& operator<<(std::ostream& os,
+                                const JsonArraySubscript& source) {
+  return source.printTo(os);
+}
+#endif
+}

 inline Internals::JsonArraySubscript JsonArray::operator[](size_t index) {
  return Internals::JsonArraySubscript(*this, index);
@ -103,9 +113,9 @@ inline Internals::JsonArraySubscript JsonArray::operator[](size_t index) {

 inline const Internals::JsonArraySubscript JsonArray::operator[](
    size_t index) const {
-  return Internals::JsonArraySubscript(*this, index);
+  return Internals::JsonArraySubscript(*const_cast<JsonArray*>(this), index);
+}
 }
-}  // namespace ArduinoJson

 #ifdef _MSC_VER
 #pragma warning(pop)
--- a/src/ArduinoJson/JsonBuffer.hpp
+++ b/src/ArduinoJson/JsonBuffer.hpp
@ -0,0 +1,78 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+#include <stddef.h>  // for size_t
+#include <stdint.h>  // for uint8_t
+#include <string.h>
+
+#include "Data/NonCopyable.hpp"
+#include "JsonVariant.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsArray.hpp"
+
+namespace ArduinoJson {
+class JsonArray;
+class JsonObject;
+
+// Entry point for using the library.
+//
+// Handle the memory management (done in derived classes) and calls the parser.
+// This abstract class is implemented by StaticJsonBuffer which implements a
+// fixed memory allocation.
+class JsonBuffer : Internals::NonCopyable {
+ public:
+  // Allocates an empty JsonArray.
+  //
+  // Returns a reference to the new JsonArray or JsonArray::invalid() if the
+  // allocation fails.
+  JsonArray &createArray();
+
+  // Allocates an empty JsonObject.
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  JsonObject &createObject();
+
+  // Duplicates a string
+  //
+  // const char* strdup(TValue);
+  // TValue = const std::string&, const String&,
+  template <typename TString>
+  DEPRECATED("char* are duplicated, you don't need strdup() anymore")
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               const char *>::type strdup(const TString &src) {
+    return Internals::StringTraits<TString>::duplicate(src, this);
+  }
+  //
+  // const char* strdup(TValue);
+  // TValue = char*, const char*, const FlashStringHelper*
+  template <typename TString>
+  DEPRECATED("char* are duplicated, you don't need strdup() anymore")
+  const char *strdup(TString *src) {
+    return Internals::StringTraits<TString *>::duplicate(src, this);
+  }
+
+  // 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;
+
+ protected:
+  // CAUTION: NO VIRTUAL DESTRUCTOR!
+  // If we add a virtual constructor the Arduino compiler will add malloc()
+  // and free() to the binary, adding 706 useless bytes.
+  ~JsonBuffer() {}
+
+  // Preserve aligment if necessary
+  static FORCE_INLINE size_t round_size_up(size_t bytes) {
+#if ARDUINOJSON_ENABLE_ALIGNMENT
+    const size_t x = sizeof(void *) - 1;
+    return (bytes + x) & ~x;
+#else
+    return bytes;
+#endif
+  }
+};
+}
--- a/src/ArduinoJson/JsonBufferBase.hpp
+++ b/src/ArduinoJson/JsonBufferBase.hpp
@ -0,0 +1,127 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+#include "Deserialization/JsonParser.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+template <typename TDerived>
+class JsonBufferBase : public JsonBuffer {
+ public:
+  // Allocates and populate a JsonArray from a JSON string.
+  //
+  // The First argument is a pointer to the JSON string, the memory must be
+  // writable
+  // because the parser will insert null-terminators and replace escaped chars.
+  //
+  // The second argument set the nesting limit
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  // With this overload, the JsonBuffer will make a copy of the string
+  //
+  // JsonArray& parseArray(TString);
+  // TString = const std::string&, const String&
+  template <typename TString>
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               JsonArray &>::type
+  parseArray(const TString &json,
+             uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseArray();
+  }
+  //
+  // JsonArray& parseArray(TString);
+  // TString = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonArray &parseArray(
+      TString *json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseArray();
+  }
+  //
+  // JsonArray& parseArray(TString);
+  // TString = std::istream&, Stream&
+  template <typename TString>
+  JsonArray &parseArray(
+      TString &json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseArray();
+  }
+
+  // Allocates and populate a JsonObject from a JSON string.
+  //
+  // The First argument is a pointer to the JSON string, the memory must be
+  // writable
+  // because the parser will insert null-terminators and replace escaped chars.
+  //
+  // The second argument set the nesting limit
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  //
+  // JsonObject& parseObject(TString);
+  // TString = const std::string&, const String&
+  template <typename TString>
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               JsonObject &>::type
+  parseObject(const TString &json,
+              uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseObject();
+  }
+  //
+  // JsonObject& parseObject(TString);
+  // TString = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonObject &parseObject(
+      TString *json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseObject();
+  }
+  //
+  // JsonObject& parseObject(TString);
+  // TString = std::istream&, Stream&
+  template <typename TString>
+  JsonObject &parseObject(
+      TString &json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseObject();
+  }
+
+  // Generalized version of parseArray() and parseObject(), also works for
+  // integral types.
+  //
+  // JsonVariant parse(TString);
+  // TString = const std::string&, const String&
+  template <typename TString>
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               JsonVariant>::type
+  parse(const TString &json,
+        uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseVariant();
+  }
+  //
+  // JsonVariant parse(TString);
+  // TString = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonVariant parse(TString *json,
+                    uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseVariant();
+  }
+  //
+  // JsonVariant parse(TString);
+  // TString = std::istream&, Stream&
+  template <typename TString>
+  JsonVariant parse(TString &json,
+                    uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseVariant();
+  }
+
+ protected:
+  ~JsonBufferBase() {}
+
+ private:
+  TDerived *that() {
+    return static_cast<TDerived *>(this);
+  }
+};
+}
+}
--- a/src/ArduinoJson/JsonBufferImpl.hpp
+++ b/src/ArduinoJson/JsonBufferImpl.hpp
@ -0,0 +1,17 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+#include "Deserialization/JsonParser.hpp"
+
+inline ArduinoJson::JsonArray &ArduinoJson::JsonBuffer::createArray() {
+  JsonArray *ptr = new (this) JsonArray(this);
+  return ptr ? *ptr : JsonArray::invalid();
+}
+
+inline ArduinoJson::JsonObject &ArduinoJson::JsonBuffer::createObject() {
+  JsonObject *ptr = new (this) JsonObject(this);
+  return ptr ? *ptr : JsonObject::invalid();
+}
--- a/src/ArduinoJson/JsonObject.hpp
+++ b/src/ArduinoJson/JsonObject.hpp
@ -4,82 +4,145 @@

 #pragma once

-#include "./JsonObjectData.hpp"
+#include "Data/JsonBufferAllocated.hpp"
+#include "Data/List.hpp"
+#include "Data/ReferenceType.hpp"
+#include "Data/ValueSaver.hpp"
+#include "JsonPair.hpp"
+#include "Serialization/JsonPrintable.hpp"
+#include "StringTraits/StringTraits.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsArray.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsSame.hpp"
+
+// Returns the size (in bytes) of an object with n elements.
+// Can be very handy to determine the size of a StaticJsonBuffer.
+#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
+  (sizeof(JsonObject) + (NUMBER_OF_ELEMENTS) * sizeof(JsonObject::node_type))

 namespace ArduinoJson {

-class JsonObject {
-  friend class JsonVariant;
+// Forward declarations
+class JsonArray;
+class JsonBuffer;
+namespace Internals {
+template <typename>
+class JsonObjectSubscript;
+}

+// A dictionary of JsonVariant indexed by string (char*)
+//
+// The constructor is private, instances must be created via
+// JsonBuffer::createObject() or JsonBuffer::parseObject().
+// A JsonObject can be serialized to a JSON string via JsonObject::printTo().
+// It can also be deserialized from a JSON string via JsonBuffer::parseObject().
+class JsonObject : public Internals::JsonPrintable<JsonObject>,
+                   public Internals::ReferenceType,
+                   public Internals::NonCopyable,
+                   public Internals::List<JsonPair>,
+                   public Internals::JsonBufferAllocated {
 public:
-  typedef Internals::JsonObjectData::iterator iterator;
-  typedef Internals::JsonObjectData::const_iterator const_iterator;
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  // You should not use this constructor directly.
+  // Instead, use JsonBuffer::createObject() or JsonBuffer.parseObject().
+  explicit JsonObject(JsonBuffer* buffer) throw()
+      : Internals::List<JsonPair>(buffer) {}

-  JsonObject() : _data(0) {}
-  JsonObject(Internals::JsonObjectData* object) : _data(object) {}
-  JsonObject(Internals::JsonBuffer* buf)
-      : _data(new (buf) Internals::JsonObjectData(buf)) {}
-
-  iterator begin() {
-    if (!_data) return iterator();
-    return _data->begin();
-  }
-
-  const_iterator begin() const {
-    if (!_data) return const_iterator();
-    return _data->begin();
-  }
-
-  // Tells weither the specified key is present and associated with a value.
+  // Gets or sets the value associated with the specified key.
  //
-  // bool containsKey(TKey);
+  // JsonObjectSubscript operator[](TKey)
  // TKey = const std::string&, const String&
  template <typename TString>
-  bool containsKey(const TString& key) const {
-    return containsKey_impl<const TString&>(key);
+  Internals::JsonObjectSubscript<const TString&> operator[](
+      const TString& key) {
+    return Internals::JsonObjectSubscript<const TString&>(*this, key);
  }
  //
-  // bool containsKey(TKey);
-  // TKey = char*, const char*, char[], const char[], const FlashStringHelper*
+  // JsonObjectSubscript operator[](TKey)
+  // TKey = char*, const char*, char[], const char[N], const FlashStringHelper*
  template <typename TString>
-  bool containsKey(TString* key) const {
-    return containsKey_impl<TString*>(key);
+  Internals::JsonObjectSubscript<TString*> operator[](TString* key) {
+    return Internals::JsonObjectSubscript<TString*>(*this, key);
  }

-  iterator end() {
-    return iterator();
-  }
-
-  const_iterator end() const {
-    return const_iterator();
-  }
-
-  // Creates and adds a JsonArray.
+  // Gets the value associated with the specified key.
  //
-  // JsonArray createNestedArray(TKey);
+  // const JsonObjectSubscript operator[](TKey) const;
  // TKey = const std::string&, const String&
  template <typename TString>
-  JsonArray createNestedArray(const TString& key);
-  // JsonArray createNestedArray(TKey);
-  // TKey = char*, const char*, char[], const char[], const FlashStringHelper*
-  template <typename TString>
-  JsonArray createNestedArray(TString* key);
-
-  // Creates and adds a JsonObject.
-  //
-  // JsonObject createNestedObject(TKey);
-  // TKey = const std::string&, const String&
-  template <typename TString>
-  JsonObject createNestedObject(const TString& key) {
-    if (!_data) return JsonObject();
-    return createNestedObject_impl<const TString&>(key);
+  const Internals::JsonObjectSubscript<const TString&> operator[](
+      const TString& key) const {
+    return Internals::JsonObjectSubscript<const TString&>(
+        *const_cast<JsonObject*>(this), key);
  }
  //
-  // JsonObject createNestedObject(TKey);
-  // TKey = char*, const char*, char[], const char[], const FlashStringHelper*
+  // const JsonObjectSubscript operator[](TKey) const;
+  // TKey = const char*, const char[N], const FlashStringHelper*
  template <typename TString>
-  JsonObject createNestedObject(TString* key) {
-    return createNestedObject_impl<TString*>(key);
+  const Internals::JsonObjectSubscript<TString*> operator[](
+      TString* key) const {
+    return Internals::JsonObjectSubscript<TString*>(
+        *const_cast<JsonObject*>(this), key);
+  }
+
+  // Sets the specified key with the specified value.
+  //
+  // bool set(TKey, TValue);
+  // TKey = const std::string&, const String&
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          std::string, String, JsonArray, JsonObject
+  template <typename TValue, typename TString>
+  bool set(const TString& key, const TValue& value) {
+    return set_impl<const TString&, const TValue&>(key, value);
+  }
+  //
+  // bool set(TKey, TValue);
+  // TKey = const std::string&, const String&
+  // TValue = char*, const char*, const FlashStringHelper*
+  template <typename TValue, typename TString>
+  bool set(const TString& key, TValue* value) {
+    return set_impl<const TString&, TValue*>(key, value);
+  }
+  //
+  // bool set(TKey, const TValue&);
+  // TKey = char*, const char*, const FlashStringHelper*
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          std::string, String, JsonArray, JsonObject
+  template <typename TValue, typename TString>
+  bool set(TString* key, const TValue& value) {
+    return set_impl<TString*, const TValue&>(key, value);
+  }
+  //
+  // bool set(TKey, TValue);
+  // TKey = char*, const char*, const FlashStringHelper*
+  // TValue = char*, const char*, const FlashStringHelper*
+  template <typename TValue, typename TString>
+  bool set(TString* key, TValue* value) {
+    return set_impl<TString*, TValue*>(key, value);
+  }
+  //
+  // bool set(TKey, TValue, uint8_t decimals);
+  // TKey = const std::string&, const String&
+  // TValue = float, double
+  template <typename TValue, typename TString>
+  DEPRECATED("Second argument is not supported anymore")
+  typename Internals::EnableIf<Internals::IsFloatingPoint<TValue>::value,
+                               bool>::type
+      set(const TString& key, TValue value, uint8_t) {
+    return set_impl<const TString&, const JsonVariant&>(key,
+                                                        JsonVariant(value));
+  }
+  //
+  // bool set(TKey, TValue, uint8_t decimals);
+  // TKey = char*, const char*, const FlashStringHelper*
+  // TValue = float, double
+  template <typename TValue, typename TString>
+  DEPRECATED("Second argument is not supported anymore")
+  typename Internals::EnableIf<Internals::IsFloatingPoint<TValue>::value,
+                               bool>::type
+      set(TString* key, TValue value, uint8_t) {
+    return set_impl<TString*, const JsonVariant&>(key, JsonVariant(value));
  }

  // Gets the value associated with the specified key.
@ -124,48 +187,51 @@ class JsonObject {
    return is_impl<TString*, TValue>(key);
  }

-  // Gets or sets the value associated with the specified key.
+  // Creates and adds a JsonArray.
  //
-  // JsonObjectSubscript operator[](TKey)
+  // JsonArray& createNestedArray(TKey);
  // TKey = const std::string&, const String&
  template <typename TString>
-  Internals::JsonObjectSubscript<const TString&> operator[](
-      const TString& key) {
-    return Internals::JsonObjectSubscript<const TString&>(*this, key);
+  JsonArray& createNestedArray(const TString& key) {
+    return createNestedArray_impl<const TString&>(key);
  }
-  //
-  // JsonObjectSubscript operator[](TKey)
-  // TKey = char*, const char*, char[], const char[N], const FlashStringHelper*
+  // JsonArray& createNestedArray(TKey);
+  // TKey = char*, const char*, char[], const char[], const FlashStringHelper*
  template <typename TString>
-  Internals::JsonObjectSubscript<TString*> operator[](TString* key) {
-    return Internals::JsonObjectSubscript<TString*>(*this, key);
+  JsonArray& createNestedArray(TString* key) {
+    return createNestedArray_impl<TString*>(key);
  }

-  // Gets the value associated with the specified key.
+  // Creates and adds a JsonObject.
  //
-  // const JsonObjectSubscript operator[](TKey) const;
+  // JsonObject& createNestedObject(TKey);
  // TKey = const std::string&, const String&
  template <typename TString>
-  const Internals::JsonObjectSubscript<const TString&> operator[](
-      const TString& key) const {
-    return Internals::JsonObjectSubscript<const TString&>(*this, key);
+  JsonObject& createNestedObject(const TString& key) {
+    return createNestedObject_impl<const TString&>(key);
  }
  //
-  // const JsonObjectSubscript operator[](TKey) const;
-  // TKey = const char*, const char[N], const FlashStringHelper*
+  // JsonObject& createNestedObject(TKey);
+  // TKey = char*, const char*, char[], const char[], const FlashStringHelper*
  template <typename TString>
-  const Internals::JsonObjectSubscript<TString*> operator[](
-      TString* key) const {
-    return Internals::JsonObjectSubscript<TString*>(*this, key);
+  JsonObject& createNestedObject(TString* key) {
+    return createNestedObject_impl<TString*>(key);
  }

-  bool operator==(const JsonObject& rhs) const {
-    return _data == rhs._data;
+  // Tells weither the specified key is present and associated with a value.
+  //
+  // bool containsKey(TKey);
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  bool containsKey(const TString& key) const {
+    return findKey<const TString&>(key) != end();
  }
-
-  void remove(iterator it) {
-    if (!_data) return;
-    _data->remove(it);
+  //
+  // bool containsKey(TKey);
+  // TKey = char*, const char*, char[], const char[], const FlashStringHelper*
+  template <typename TString>
+  bool containsKey(TString* key) const {
+    return findKey<TString*>(key) != end();
  }

  // Removes the specified key and the associated value.
@ -174,87 +240,34 @@ class JsonObject {
  // TKey = const std::string&, const String&
  template <typename TString>
  void remove(const TString& key) {
-    remove_impl<const TString&>(key);
+    remove(findKey<const TString&>(key));
  }
  //
  // void remove(TKey);
  // TKey = char*, const char*, char[], const char[], const FlashStringHelper*
  template <typename TString>
  void remove(TString* key) {
-    remove_impl<TString*>(key);
-  }
-
-  // Sets the specified key with the specified value.
-  //
-  // bool set(TKey, TValue);
-  // TKey = const std::string&, const String&
-  // TValue = bool, long, int, short, float, double, serialized, JsonVariant,
-  //          std::string, String, JsonArray, JsonObject
-  template <typename TValue, typename TString>
-  bool set(const TString& key, const TValue& value) {
-    return set_impl<const TString&, const TValue&>(key, value);
+    remove(findKey<TString*>(key));
  }
  //
-  // bool set(TKey, TValue);
-  // TKey = const std::string&, const String&
-  // TValue = char*, const char*, const FlashStringHelper*
-  template <typename TValue, typename TString>
-  bool set(const TString& key, TValue* value) {
-    return set_impl<const TString&, TValue*>(key, value);
-  }
-  //
-  // bool set(TKey, const TValue&);
-  // TKey = char*, const char*, const FlashStringHelper*
-  // TValue = bool, long, int, short, float, double, serialized, JsonVariant,
-  //          std::string, String, JsonArray, JsonObject
-  template <typename TValue, typename TString>
-  bool set(TString* key, const TValue& value) {
-    return set_impl<TString*, const TValue&>(key, value);
-  }
-  //
-  // bool set(TKey, TValue);
-  // TKey = char*, const char*, const FlashStringHelper*
-  // TValue = char*, const char*, const FlashStringHelper*
-  template <typename TValue, typename TString>
-  bool set(TString* key, TValue* value) {
-    return set_impl<TString*, TValue*>(key, value);
-  }
+  // void remove(iterator)
+  using Internals::List<JsonPair>::remove;

-  size_t size() const {
-    if (!_data) return 0;
-    return _data->size();
-  }
-
-  bool isNull() const {
-    return _data == 0;
-  }
-
-  template <typename Visitor>
-  void visit(Visitor& visitor) const {
-    if (_data)
-      visitor.acceptObject(*this);
-    else
-      return visitor.acceptNull();
+  // Returns a reference an invalid JsonObject.
+  // This object is meant to replace a NULL pointer.
+  // This is used when memory allocation or JSON parsing fail.
+  static JsonObject& invalid() {
+    static JsonObject instance(NULL);
+    return instance;
  }

 private:
-  template <typename TStringRef>
-  bool containsKey_impl(TStringRef key) const {
-    return findKey<TStringRef>(key) != end();
-  }
-
-  template <typename TStringRef>
-  JsonArray createNestedArray_impl(TStringRef key);
-
-  template <typename TStringRef>
-  JsonObject createNestedObject_impl(TStringRef key);
-
  // Returns the list node that matches the specified key.
  template <typename TStringRef>
  iterator findKey(TStringRef key) {
    iterator it;
    for (it = begin(); it != end(); ++it) {
-      if (Internals::makeString(key).equals(it->key)) break;
+      if (Internals::StringTraits<TStringRef>::equals(key, it->key)) break;
    }
    return it;
  }
@ -271,6 +284,26 @@ class JsonObject {
                       : Internals::JsonVariantDefault<TValue>::get();
  }

+  template <typename TStringRef, typename TValueRef>
+  bool set_impl(TStringRef key, TValueRef value) {
+    // ignore null key
+    if (Internals::StringTraits<TStringRef>::is_null(key)) return false;
+
+    // search a matching key
+    iterator it = findKey<TStringRef>(key);
+    if (it == end()) {
+      // add the key
+      it = Internals::List<JsonPair>::add();
+      if (it == end()) return false;
+      bool key_ok =
+          Internals::ValueSaver<TStringRef>::save(_buffer, it->key, key);
+      if (!key_ok) return false;
+    }
+
+    // save the value
+    return Internals::ValueSaver<TValueRef>::save(_buffer, it->value, value);
+  }
+
  template <typename TStringRef, typename TValue>
  bool is_impl(TStringRef key) const {
    const_iterator it = findKey<TStringRef>(key);
@ -278,34 +311,18 @@ class JsonObject {
  }

  template <typename TStringRef>
-  void remove_impl(TStringRef key) {
-    if (!_data) return;
-    _data->remove(findKey<TStringRef>(key));
-  }
+  JsonArray& createNestedArray_impl(TStringRef key);

-  template <typename TStringRef, typename TValueRef>
-  bool set_impl(TStringRef key, TValueRef value) {
-    if (!_data) return false;
-
-    // ignore null key
-    if (Internals::makeString(key).is_null()) return false;
-
-    // search a matching key
-    iterator it = findKey<TStringRef>(key);
-    if (it == end()) {
-      // add the key
-      it = _data->add();
-      if (it == end()) return false;
-      bool key_ok =
-          Internals::ValueSaver<TStringRef>::save(_data->_buffer, it->key, key);
-      if (!key_ok) return false;
-    }
-
-    // save the value
-    return Internals::ValueSaver<TValueRef>::save(_data->_buffer, it->value,
-                                                  value);
-  }
-
-  Internals::JsonObjectData* _data;
+  template <typename TStringRef>
+  JsonObject& createNestedObject_impl(TStringRef key);
 };
+
+namespace Internals {
+template <>
+struct JsonVariantDefault<JsonObject> {
+  static JsonObject& get() {
+    return JsonObject::invalid();
+  }
+};
+}  // namespace Internals
 }  // namespace ArduinoJson
--- a/src/ArduinoJson/JsonObjectData.hpp
+++ b/src/ArduinoJson/JsonObjectData.hpp
@ -1,26 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "Data/List.hpp"
-#include "Data/ValueSaver.hpp"
-#include "JsonPair.hpp"
-#include "Memory/JsonBufferAllocated.hpp"
-#include "Polyfills/type_traits.hpp"
-
-// Returns the size (in bytes) of an object with n elements.
-// Can be very handy to determine the size of a StaticJsonBuffer.
-#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS)        \
-  (sizeof(ArduinoJson::Internals::JsonObjectData) + \
-   (NUMBER_OF_ELEMENTS) *                           \
-       sizeof(ArduinoJson::Internals::JsonObjectData::node_type))
-
-namespace ArduinoJson {
-namespace Internals {
-struct JsonObjectData : List<JsonPair>, JsonBufferAllocated {
-  explicit JsonObjectData(JsonBuffer* buf) throw() : List<JsonPair>(buf) {}
-};
-}  // namespace Internals
-}  // namespace ArduinoJson
--- a/src/ArduinoJson/JsonObjectImpl.hpp
+++ b/src/ArduinoJson/JsonObjectImpl.hpp
@ -6,32 +6,23 @@

 #include "JsonArray.hpp"
 #include "JsonObject.hpp"
+#include "JsonObjectSubscript.hpp"

 namespace ArduinoJson {

-template <typename TString>
-inline JsonArray JsonObject::createNestedArray(const TString& key) {
-  return createNestedArray_impl<const TString&>(key);
-}
-
-template <typename TString>
-inline JsonArray JsonObject::createNestedArray(TString* key) {
-  return createNestedArray_impl<TString*>(key);
-}
-
 template <typename TStringRef>
-inline JsonArray JsonObject::createNestedArray_impl(TStringRef key) {
-  if (!_data) return JsonArray();
-  JsonArray array(_data->_buffer);
-  if (!array.isNull()) set(key, array);
+inline JsonArray &JsonObject::createNestedArray_impl(TStringRef key) {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  set(key, array);
  return array;
 }

 template <typename TStringRef>
-inline JsonObject JsonObject::createNestedObject_impl(TStringRef key) {
-  if (!_data) return JsonObject();
-  JsonObject object(_data->_buffer);
-  if (!object.isNull()) set(key, object);
+inline JsonObject &JsonObject::createNestedObject_impl(TStringRef key) {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  set(key, object);
  return object;
 }
-}  // namespace ArduinoJson
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Benoit Blanchon	ef12c74771	Set version to 5.13.4	2018-12-04 11:36:16 +01:00
Benoit Blanchon	0bc03e8071	Removed spurious files in the Particle library	2018-12-04 11:19:22 +01:00
Benoit Blanchon	04286f3228	Moved size measurements to github.com/bblanchon/ArduinoJson-size	2018-12-04 10:50:45 +01:00
Benoit Blanchon	0d4a93018b	Set version to 5.13.3	2018-10-06 17:50:41 +02:00
Benoit Blanchon	3ca40db9f8	Added a coupon code for the book	2018-10-06 17:42:01 +02:00
Benoit Blanchon	ce607196d1	Travis: update osx images	2018-10-06 17:24:54 +02:00
Benoit Blanchon	0b3af166ae	Fixed `JsonVariant::is<String>()` (closes #763 )	2018-10-06 17:21:16 +02:00
Benoit Blanchon	fa1a40ac6e	Fixed `JsonVariant::is<int>()` that returned true for empty strings	2018-07-05 09:53:11 +02:00
Benoit Blanchon	954428e341	Improved float serialization when `-fsingle-precision-constant` is used	2018-07-05 09:48:57 +02:00