Set version to 6.0.1-beta

Return NotSupported if the JSON input contains "\u".

.github/ISSUE_TEMPLATE.md

@@ -1,11 +1,14 @@
 <!--
-Thanks for using ArduinoJson :-)
+Before opening an issue, please read the FAQ:
+https://arduinojson.org/faq/
 
-Before opening an issue, please make sure you've read these:
-https://bblanchon.github.io/ArduinoJson/faq/
-https://bblanchon.github.io/ArduinoJson/doc/pitfalls/
+Please provide all the relevant information:
+* good title
+* short description of the problem
+* target platform
+* compiler model and version
+* MVCE (https://stackoverflow.com/help/mcve)
+* compiler output
 
-Next, make sure you provide all the relevant information: platform, code snippet, and error messages.
-
-Please be concise!
+Good questions get fast answers!
 -->

.gitignore

@@ -9,3 +9,4 @@
 /fuzzing/*_fuzzer
 /fuzzing/*_fuzzer.options
 /fuzzing/*_fuzzer_seed_corpus.zip
+.vs/

.travis.yml

@@ -2,18 +2,6 @@ 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:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.5']
-      env: SCRIPT=cmake GCC=4.5
     - compiler: gcc
       addons:
         apt:
@@ -43,7 +31,19 @@ matrix:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-5']
-      env: SCRIPT=cmake GCC=5 SANITIZE=undefined
+      env: SCRIPT=cmake GCC=5 # SANITIZE=undefined 
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-6']
+      env: SCRIPT=cmake GCC=6
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7']
+      env: SCRIPT=cmake GCC=7
     - compiler: clang
       env: SCRIPT=cmake
     - compiler: clang
@@ -70,34 +70,50 @@ matrix:
           sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
           packages: ['clang-3.8']
       env: SCRIPT=cmake CLANG=3.8 SANITIZE=undefined
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-3.9']
+          packages: ['clang-3.9']
+      env: SCRIPT=cmake CLANG=3.9
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-4.0']
+          packages: ['clang-4.0']
+      env: SCRIPT=cmake CLANG=4.0
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-5.0']
+          packages: ['clang-5.0']
+      env: SCRIPT=cmake CLANG=5.0
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-6.0']
+          packages: ['clang-6.0']
+      env: SCRIPT=cmake CLANG=6.0
     - compiler: gcc
       env: SCRIPT=coverage
     - os: osx
       osx_image: xcode6.4
       compiler: clang
       env: SCRIPT=cmake
-    - os: osx
-      osx_image: xcode7
-      compiler: clang
-      env: SCRIPT=cmake
-    - os: osx
-      osx_image: xcode7.1
-      compiler: clang
-      env: SCRIPT=cmake
-    - os: osx
-      osx_image: xcode7.2
-      compiler: clang
-      env: SCRIPT=cmake
     - os: osx
       osx_image: xcode7.3
       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:avr:uno
+    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:samd:mkr1000
     - env: SCRIPT=platformio BOARD=uno
-    - env: SCRIPT=platformio BOARD=due
     - env: SCRIPT=platformio BOARD=esp01
-    #- env: SCRIPT=platformio BOARD=teensy31C
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-6.0']
+          packages: ['clang-6.0','llvm-6.0']
+      env: SCRIPT=fuzz CLANG=6.0
 cache:
   directories:
     - "~/.platformio"

ArduinoJson.h

@@ -1,8 +1,5 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #include "src/ArduinoJson.h"

CHANGELOG.md

@@ -1,6 +1,194 @@
 ArduinoJson: change log
 =======================
 
+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);
+> ```
+
+v5.13.2
+-------
+
+* Fixed `JsonBuffer::parse()` not respecting nesting limit correctly (issue #693)
+* Fixed inconsistencies in nesting level counting (PR #695 from Zhenyu Wu)
+* Fixed null values that could be pass to `strcmp()` (PR #745 from Mike Karlesky)
+* Added macros `ARDUINOJSON_VERSION`, `ARDUINOJSON_VERSION_MAJOR`...
+
+v5.13.1
+-------
+
+* Fixed `JsonVariant::operator|(int)` that returned the default value if the variant contained a double (issue #675)
+* Allowed non-quoted key to contain underscores (issue #665)
+
+v5.13.0
+-------
+
+* Changed the rules of string duplication (issue #658)
+* `RawJson()` accepts any kind of string and obeys to the same rules for duplication
+* Changed the return type of `strdup()` to `const char*` to prevent double duplication
+* Marked `strdup()` as deprecated
+
+> ### New rules for string duplication
+>
+> | type                       | duplication |
+> |:---------------------------|:------------|
+> | const char*                | no          |
+> | char*                      | ~~no~~ yes  |
+> | String                     | yes         |
+> | std::string                | yes         |
+> | const __FlashStringHelper* | yes         |
+>
+> These new rules make `JsonBuffer::strdup()` useless.
+
+v5.12.0
+-------
+
+* Added `JsonVariant::operator|` to return a default value (see below)
+* Added a clear error message when compiled as C instead of C++ (issue #629)
+* Added detection of MPLAB XC compiler (issue #629)
+* Added detection of Keil ARM Compiler (issue #629)
+* Added an example that shows how to save and load a configuration file
+* Reworked all other examples
+
+> ### How to use the new feature?
+>
+> If you have a block like this:
+>
+> ```c++
+> const char* ssid = root["ssid"];
+> if (!ssid)
+>   ssid = "default ssid";
+> ```
+>
+> You can simplify like that:
+>
+> ```c++
+> const char* ssid = root["ssid"] | "default ssid";
+> ```
+
+v5.11.2
+-------
+
+* Fixed `DynamicJsonBuffer::clear()` not resetting allocation size (issue #561)
+* Fixed incorrect rounding for float values (issue #588)
+
+v5.11.1
+-------
+
+* Removed dependency on `PGM_P` as Particle 0.6.2 doesn't define it (issue #546)
+* Fixed warning "dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]"
+* Fixed warning "floating constant exceeds range of 'float' [-Woverflow]" (issue #544)
+* Fixed warning "this statement may fall through" [-Wimplicit-fallthrough=] (issue #539)
+* Removed `ARDUINOJSON_DOUBLE_IS_64BITS` as it became useless.
+* Fixed too many decimals places in float serialization (issue #543)
+
+v5.11.0
+-------
+
+* Made `JsonBuffer` non-copyable (PR #524 by @luisrayas3)
+* Added `StaticJsonBuffer::clear()`
+* Added `DynamicJsonBuffer::clear()`
+
+v5.10.1
+-------
+
+* Fixed IntelliSense errors in Visual Micro (issue #483)
+* Fixed compilation in IAR Embedded Workbench (issue #515)
+* Fixed reading "true" as a float (issue #516)
+* Added `ARDUINOJSON_DOUBLE_IS_64BITS`
+* Added `ARDUINOJSON_EMBEDDED_MODE`
+
+v5.10.0
+-------
+
+* Removed configurable number of decimal places (issues #288, #427 and #506)
+* Changed exponentiation thresholds to `1e7` and `1e-5` (issues #288, #427 and #506)
+* `JsonVariant::is<double>()` now returns `true` for integers
+* Fixed error `IsBaseOf is not a member of ArduinoJson::TypeTraits` (issue #495)
+* Fixed error `forming reference to reference` (issue #495)
+
+> ### BREAKING CHANGES :warning:
+>
+> | Old syntax                      | New syntax          |
+> |:--------------------------------|:--------------------|
+> | `double_with_n_digits(3.14, 2)` | `3.14`              |
+> | `float_with_n_digits(3.14, 2)`  | `3.14f`             |
+> | `obj.set("key", 3.14, 2)`       | `obj["key"] = 3.14` |
+> | `arr.add(3.14, 2)`              | `arr.add(3.14)`     |
+>
+> | Input     | Old output | New output |
+> |:----------|:-----------|:-----------|
+> | `3.14159` | `3.14`     | `3.14159`  |
+> | `42.0`    | `42.00`    | `42`       |
+> | `0.0`     | `0.00`     | `0`        |
+>
+> | Expression                     | Old result | New result |
+> |:-------------------------------|:-----------|:-----------|
+> | `JsonVariant(42).is<int>()`    | `true`     | `true`     |
+> | `JsonVariant(42).is<float>()`  | `false`    | `true`     |
+> | `JsonVariant(42).is<double>()` | `false`    | `true`     |
+
 v5.9.0
 ------
 
@@ -53,23 +241,23 @@ v5.8.0
 * Added support for `Stream` (issue #300)
 * Reduced memory consumption by not duplicating spaces and comments
 
-**BREAKING CHANGES**:
-
-`JsonBuffer::parseObject()` and  `JsonBuffer::parseArray()` have been pulled down to the derived classes `DynamicJsonBuffer` and `StaticJsonBufferBase`.
-
-This means that if you have code like:
-
-```c++
-void myFunction(JsonBuffer& jsonBuffer);
-```
-
-you need to replace it with one of the following:
-
-```c++
-void myFunction(DynamicJsonBuffer& jsonBuffer);
-void myFunction(StaticJsonBufferBase& jsonBuffer);
-template<typename TJsonBuffer> void myFunction(TJsonBuffer& jsonBuffer);
-```
+> ### BREAKING CHANGES :warning:
+>
+> `JsonBuffer::parseObject()` and  `JsonBuffer::parseArray()` have been pulled down to the derived classes `DynamicJsonBuffer` and `StaticJsonBufferBase`.
+>
+> This means that if you have code like:
+>
+> ```c++
+> void myFunction(JsonBuffer& jsonBuffer);
+> ```
+>
+> you need to replace it with one of the following:
+>
+> ```c++
+> void myFunction(DynamicJsonBuffer& jsonBuffer);
+> void myFunction(StaticJsonBufferBase& jsonBuffer);
+> template<typename TJsonBuffer> void myFunction(TJsonBuffer& jsonBuffer);
+> ```
 
 v5.7.3
 ------
@@ -102,27 +290,26 @@ v5.7.0
 * Added example `StringExample.ino` to show where `String` can be used
 * Increased default nesting limit to 50 when compiled for a computer (issue #349)
 
-**BREAKING CHANGES**:
-
-The non-template functions `JsonObject::get()` and `JsonArray.get()` have been removed. This means that you need to explicitely tell the type you expect in return.
-
-Old code:
-
-```c++
-#define ARDUINOJSON_USE_ARDUINO_STRING 0
-JsonVariant value1 = myObject.get("myKey");
-JsonVariant value2 = myArray.get(0);
-```
-
-New code:
-
-```c++
-#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
-#define ARDUINOJSON_ENABLE_STD_STRING 1
-JsonVariant value1 = myObject.get<JsonVariant>("myKey");
-JsonVariant value2 = myArray.get<JsonVariant>(0);
-```
-
+> ### BREAKING CHANGES :warning:
+>
+> The non-template functions `JsonObject::get()` and `JsonArray.get()` have been removed. This means that you need to explicitely tell the type you expect in return.
+>
+> Old code:
+>
+> ```c++
+> #define ARDUINOJSON_USE_ARDUINO_STRING 0
+> JsonVariant value1 = myObject.get("myKey");
+> JsonVariant value2 = myArray.get(0);
+> ```
+>
+> New code:
+>
+> ```c++
+> #define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
+> #define ARDUINOJSON_ENABLE_STD_STRING 1
+> JsonVariant value1 = myObject.get<JsonVariant>("myKey");
+> JsonVariant value2 = myArray.get<JsonVariant>(0);
+> ```
 
 v5.6.7
 ------
@@ -214,8 +401,9 @@ v5.1.0
 * Added support of `long long` (issue #171)
 * Moved all build settings to `ArduinoJson/Configuration.hpp`
 
-**BREAKING CHANGE**:
-If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
+> ### BREAKING CHANGE :warning:
+>
+> If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
 
 v5.0.8
 ------
@@ -229,9 +417,10 @@ v5.0.7
 * Made library easier to use from a CMake project: simply `add_subdirectory(ArduinoJson/src)`
 * Changed `String` to be a `typedef` of `std::string` (issues #142 and #161)
 
-**BREAKING CHANGES**:
-- `JsonVariant(true).as<String>()` now returns `"true"` instead of `"1"`
-- `JsonVariant(false).as<String>()` now returns `"false"` instead of `"0"`
+> ### BREAKING CHANGES :warning:
+>
+> - `JsonVariant(true).as<String>()` now returns `"true"` instead of `"1"`
+> - `JsonVariant(false).as<String>()` now returns `"false"` instead of `"0"`
 
 v5.0.6
 ------
@@ -285,10 +474,11 @@ v5.0.0
 * Redesigned `JsonVariant` to leverage converting constructors instead of assignment operators (issue #66)
 * Switched to new the library layout (requires Arduino 1.0.6 or above)
 
-**BREAKING CHANGES**:
-- `JsonObject::add()` was renamed to `set()`
-- `JsonArray::at()` and `JsonObject::at()` were renamed to `get()`
-- Number of digits of floating point value are now set with `double_with_n_digits()`
+> ### BREAKING CHANGES :warning:
+>
+> - `JsonObject::add()` was renamed to `set()`
+> - `JsonArray::at()` and `JsonObject::at()` were renamed to `get()`
+> - Number of digits of floating point value are now set with `double_with_n_digits()`
 
 **Personal note about the `String` class**:
 Support of the `String` class has been added to the library because many people use it in their programs.
@@ -296,151 +486,3 @@ 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 CHANGE**: API changed significantly, see [Migrating code to the new API](https://github.com/bblanchon/ArduinoJson/wiki/Migrating-code-to-the-new-API).
-
-
-v3.4
-----
-
-* Fixed escaped char parsing (issue #16)
-
-
-v3.3
-----
-
-* Added indented output for the JSON generator (issue #11), see example bellow.
-* Added `IndentedPrint`, a decorator for `Print` to allow indented output
-
-Example:
-
-    JsonOject<2> json;
-    json["key"] = "value";
-    json.prettyPrintTo(Serial);
-
-v3.2
-----
-
-* Fixed a bug when adding nested object in `JsonArray` (bug introduced in v3.1).
-
-v3.1
-----
-
-* Calling `Generator::JsonObject::add()` twice with the same `key` now replaces the `value`
-* Added `Generator::JsonObject::operator[]`, see bellow the new API
-* Added `Generator::JsonObject::remove()` (issue #9)
-
-Old generator API:
-
-	JsonObject<3> root;
-    root.add("sensor", "gps");
-    root.add("time", 1351824120);
-    root.add("data", array);
-
-New generator API:
-
-	JsonObject<3> root;
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
-    root["data"] = array;
-
-v3.0
-----
-
-* New parser API, see bellow
-* Renamed `JsonHashTable` into `JsonObject`
-* Added iterators for `JsonArray` and `JsonObject` (issue #4)
-
-Old parser API:
-
-    JsonHashTable root = parser.parseHashTable(json);
-
-	char*  sensor    = root.getString("sensor");
-	long   time      = root.getLong("time");
-	double latitude  = root.getArray("data").getDouble(0);
-    double longitude = root.getArray("data").getDouble(1);
-
-New parser API:
-
-	JsonObject root = parser.parse(json);
-
-	char*  sensor    = root["sensor"];
-    long   time      = root["time"];
-    double latitude  = root["data"][0];
-    double longitude = root["data"][1];
-
-v2.1
-----
-
-* Fixed case `#include "jsmn.cpp"` which caused an error in Linux (issue #6)
-* Fixed a buffer overrun in JSON Parser (issue #5)
-
-v2.0
-----
-
-* Added JSON encoding (issue #2)
-* Renamed the library `ArduinoJsonParser` becomes `ArduinoJson`
-
-**Breaking change**: you need to add the following line at the top of your program.
-
-	using namespace ArduinoJson::Parser;
-
-v1.2
-----
-
-* Fixed error in JSON parser example (issue #1)
-
-v1.1
-----
-
-* Example: changed `char* json` into `char[] json` so that the bytes are not write protected
-* Fixed parsing bug when the JSON contains multi-dimensional arrays
-
-v1.0
-----
-
-Initial release

CMakeLists.txt

@@ -1,9 +1,6 @@
-# Copyright Benoit Blanchon 2014-2017
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2018
 # MIT License
-# 
-# Arduino JSON library
-# https://bblanchon.github.io/ArduinoJson/
-# If you like this project, please add a star!
 
 cmake_minimum_required(VERSION 3.0)
 project(ArduinoJson)

CONTRIBUTING.md

@@ -0,0 +1,11 @@
+# Contribution to ArduinoJson
+
+First, thank you for taking the time to contribute to this project.
+
+You can submit changes via GitHub Pull Requests.
+
+Please:
+
+1. Unit test every change in behavior
+2. Use clang-format in "file" mode to format the code
+3. Consider using the Continuous Integration (Travis and AppVeyor)

LICENSE.md

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 ---------------------
 
-Copyright © 2014-2017 Benoit BLANCHON
+Copyright © 2014-2018 Benoit BLANCHON
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,143 +1,111 @@
-ArduinoJson - C++ JSON library for IoT
-====================
+![ArduinoJson](banner.svg)
+
+---
 
 [![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)
 
-*An elegant and efficient JSON library for embedded systems.*
+ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
 
-It's designed to have the most intuitive API, the smallest footprint and is able to work without any allocation on the heap (no malloc).
-
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
-For instance, it supports Aduino's `String` and `Stream`, but also `std::string`, `std::istream` and `std::ostream`.
-
-Features
---------
+## Features
 
 * JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
-* Elegant API, very easy to use
+* MessagePack
+* Elegant API, easy to use
 * Fixed memory allocation (zero malloc)
 * No data duplication (zero copy)
-* Portable (written in C++98)
+* Portable (written in C++98, can be used in any C++ project)
 * Self-contained (no external dependency)
 * Small footprint
-* Header-only library
-* MIT License
+* Input and output streams
+* [100% code coverage](https://coveralls.io/github/bblanchon/ArduinoJson)
+* [Header-only library](https://en.wikipedia.org/wiki/Header-only)
+* [MIT License](https://en.wikipedia.org/wiki/MIT_License)
+* [Comprehensive documentation](https://arduinojson.org?utm_source=github&utm_medium=readme)
 
-Works on
---------
+## Compatibility
 
-* All Arduino boards (Uno, Due, Mini, Micro, Yun...)
-* ESP8266
-* Teensy
-* Intel Edison and Galileo
-* PlatformIO
-* Energia
-* RedBearLab boards (BLE Nano...)
-* Computers (Windows, Linux, OSX...)
+ArduinoJson works on the following hardware:
 
-Quick start
------------
+* <img src="https://www.arduino.cc/favicon.ico" height="16" width="16"> Arduino boards: [Uno](https://www.arduino.cc/en/Main/ArduinoBoardUno), [Due](https://www.arduino.cc/en/Main/ArduinoBoardDue), [Mini](https://www.arduino.cc/en/Main/ArduinoBoardMini), [Micro](https://www.arduino.cc/en/Main/ArduinoBoardMicro), [Yun](https://www.arduino.cc/en/Main/ArduinoBoardYun)...
+* <img src="http://espressif.com/sites/all/themes/espressif/favicon.ico" height="16" width="16"> Espressif chips: [ESP8266](https://en.wikipedia.org/wiki/ESP8266), [ESP32](https://en.wikipedia.org/wiki/ESP32)
+* <img src="https://www.wemos.cc/themes/martin-materialize-parallax/assets/favicon.ico" height="16" width="16"> WeMos boards: [D1](https://wiki.wemos.cc/products:d1:d1), [D1 mini](https://wiki.wemos.cc/products:d1:d1_mini),  ...
+* <img src="http://redbearlab.com/favicon.ico" height="16" width="16"> RedBearLab boards: [BLE Nano](http://redbearlab.com/blenano/), [BLE Mini](http://redbearlab.com/blemini/), [WiFi Micro](https://redbear.cc/product/wifi/wifi-micro.html), [LOLIN32](https://wiki.wemos.cc/products:lolin32:lolin32)...
+* <img src="https://www.pjrc.com/favicon.ico" height="16" width="16"> [Teensy](https://www.pjrc.com/teensy/) boards
+* <img src="https://software.intel.com/sites/all/themes/zero/favicon.ico" height="16" width="16"> Intel boards: Edison, Galileo...
+* <img src="https://www-assets.particle.io/images/favicon.png"  height="16" width="16"> Particle boards: [Photon](https://www.particle.io/products/hardware/photon-wifi-dev-kit), [Electron](https://www.particle.io/products/hardware/electron-cellular-dev-kit)...
+* <img src="http://www.ti.com/favicon.ico" height="16" width="16"> Texas Instruments boards: [MSP430](http://www.ti.com/microcontrollers/msp430-ultra-low-power-mcus/overview/overview.html)...
 
-#### Decoding / Parsing
+ArduinoJson compiles with zero warning on the following compilers, IDEs, and platforms:
+
+* <img src="https://www.arduino.cc/favicon.ico" height="16" width="16"> [Arduino IDE](https://www.arduino.cc/en/Main/Software)
+* <img src="http://cdn.platformio.org/favicon.ico" height="16" width="16"> [PlatformIO](http://platformio.org/)
+* <img src="http://energia.nu/img/favicon.ico" height="16" width="16"> [Energia](http://energia.nu/)
+* <img src="http://www.visualmicro.com/pics/arduino-visual-studio-ld.png" height="16" width="16"> [Visual Micro](http://www.visualmicro.com/)
+* <img src="http://www.atmel.com/Images/favicon.ico" height="16" width="16"> [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/)
+* <img src="https://www.iar.com/favicon.ico" height="16" width="16"> [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/)
+* <img src="http://www.st.com/etc/clientlibs/st-site/media/app/images/favicon.png" height="16" width="16"> [Atollic TrueSTUDIO](https://atollic.com/truestudio/)
+* <img src="http://www.keil.com/favicon.ico" height="16" width="16"> [Keil uVision](http://www.keil.com/)
+* <img src="http://www.microchip.com/favicon.ico" height="16" width="16"> [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide)
+* <img src="https://gcc.gnu.org/favicon.ico" height="16" width="16"> [GCC](https://gcc.gnu.org/)
+* <img src="https://clang.llvm.org/favicon.ico" height="16" width="16"> [Clang](https://clang.llvm.org/)
+* <img src="https://www.visualstudio.com/favicon.ico" height="16" width="16"> [Visual Studio](https://www.visualstudio.com/)
+
+## Quickstart
+
+### Deserialization
+
+Here is a program that parses a JSON document with ArduinoJson.
 
 ```c++
 char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-StaticJsonBuffer<200> jsonBuffer;
-
-JsonObject& root = jsonBuffer.parseObject(json);
+DynamicJsonDocument doc;
+deserializeJson(doc, json);
 
+JsonObject& root = doc.as<JsonObject>();
 const char* sensor = root["sensor"];
 long time          = root["time"];
 double latitude    = root["data"][0];
 double longitude   = root["data"][1];
 ```
 
-[See JsonParserExample.ino](examples/JsonParserExample/JsonParserExample.ino)
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
 
-#### Encoding / Generating
+### Serialization
+
+Here is a program that generates a JSON document with ArduinoJson:
 
 ```c++
-StaticJsonBuffer<200> jsonBuffer;
+DynamicJsonDocument doc;
 
-JsonObject& root = jsonBuffer.createObject();
+JsonObject& root = doc.to<JsonObject>();
 root["sensor"] = "gps";
 root["time"] = 1351824120;
 
 JsonArray& data = root.createNestedArray("data");
-data.add(48.756080, 6);  // 6 is the number of decimals to print
-data.add(2.302038, 6);   // if not specified, 2 digits are printed
+data.add(48.756080);
+data.add(2.302038);
 
-root.printTo(Serial);
+serializeJson(doc, Serial);
 // This prints:
 // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 ```
 
-[See JsonGeneratorExample.ino](examples/JsonGeneratorExample/JsonGeneratorExample.ino)
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme)
 
+## Documentation
 
-Documentation
--------------
+The documentation is available on [arduinojson.org](https://arduinojson.org/?utm_source=github&utm_medium=readme), here are some shortcuts:
 
-The documentation is available online in the [ArduinoJson Website](https://bblanchon.github.io/ArduinoJson/).
-
-The [ArduinoJson Assistant](https://bblanchon.github.io/ArduinoJson/assistant/) helps you get started with the library.
-
-
-Testimonials
-------------
-
-From Arduino's Forum user `jflaplante`:
-> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while.
-> I have no such problem so far with your library. It is working perfectly with my web services.
-
-From StackOverflow user `thegreendroid`:
-> It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
-
-From GitHub user `zacsketches`:
-> Thanks for a great library!!!
-> I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
-> ArduinoJson saved me a week's worth of time!!
-
-[From Reddit user `erm_what_`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusjk8c):
-> This is a great library and I wouldn't be able to do the project I'm doing without it. I completely recommend it.
-
-[From Reddit user `makerhacks`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusqg7b):
-> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.
-
-[From Twitter user `@hemalchevli`](https://twitter.com/hemalchevli/status/715788439397011456):
-> ArduinoJson library should be used as a benchmark/reference for making libraries. Truly elegant.
-
-[From GitHub user `sticilface`](https://github.com/bblanchon/ArduinoJson/issues/381#issuecomment-260203594):
-> its a great lib:) and i use it in everything!
-
-Donators
---------
-
-Special thanks to the following persons and companies who made generous donations to the library author:
-
-* Robert Murphy <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
-* Surge Communications <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
-* Alex Scott <img alt='United Kingdom' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1e7.svg' width='18' height='18'>
-* Firepick Services LLC <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
-* A B Doodkorte <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
-* Scott Smith <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
-* Johann Stieger <img alt='Austria' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e6-1f1f9.svg' width='18' height='18'>
-* Gustavo Donizeti Gini <img alt='Brazil' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e7-1f1f7.svg' width='18' height='18'>
-* Charles-Henri Hallard <img alt='France' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1eb-1f1f7.svg' width='18' height='18'>
-* Martijn van den Burg <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
-* Nick Koumaris <img alt='Greece' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1f7.svg' width='18' height='18'>
-* Jon Williams <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
-* Kestutis Liaugminas <img alt='Lithuania' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f1-1f1f9.svg' width='18' height='18'>
-* Darlington Adibe <img alt='Nigeria' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1ec.svg' width='18' height='18'>
-* Yoeri Kroon <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
-* Andrew Melvin <img alt='United Kingdom' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1e7.svg' width='18' height='18'>
-* Doanh Luong <img alt ='Vietnam' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fb-1f1f3.svg' width='18' height='18'>
-* Christoph Schmidt <img alt='Germany' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e9-1f1ea.svg' width='18' height='18'>
-* OpenEVSE LLC <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
-* Prokhoryatov Alexey <img alt='Russia' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f7-1f1fa.svg' width='18' height='18'>
+* The [Examples](https://arduinojson.org/example/?utm_source=github&utm_medium=readme) show how to use the library in various situations.
+* The [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=readme) contains the description of each class and function.
+* The [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=readme) has the answer to virtually every question.
+* The [ArduinoJson Assistant](https://arduinojson.org/assistant/?utm_source=github&utm_medium=readme) writes programs for you!
 
 ---
 
-Found this library useful? Please star this project or [help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:
+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!

SUPPORT.md

@@ -0,0 +1,27 @@
+# ArduinoJson Support
+
+First off, thank you very much for using ArduinoJson.
+
+We'll be very happy to help you, but first please read the following.
+
+## Before asking for help
+
+1. Read the [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=support)
+2. Search in the [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=support)
+
+If you did not find the answer, please create a [new issue on GitHub](https://github.com/bblanchon/ArduinoJson/issues/new).
+
+It is OK to add a comment to a currently opened issue, but please avoid adding comments to a closed issue.
+
+## Before hitting the Submit button
+
+Please provide all the relevant information:
+
+* Good title
+* Short description of the problem
+* Target platform
+* Compiler model and version
+* [MVCE](https://stackoverflow.com/help/mcve)
+* Compiler output
+
+Good questions get fast answers!

appveyor.yml

@@ -1,13 +1,15 @@
-version: 5.9.0.{build}
+version: 6.0.1.{build}
 environment:
   matrix:
-  - CMAKE_GENERATOR: Visual Studio 14 2015
-  - CMAKE_GENERATOR: Visual Studio 12 2013
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    CMAKE_GENERATOR: Visual Studio 15 2017
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    CMAKE_GENERATOR: Visual Studio 14 2015
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    CMAKE_GENERATOR: Visual Studio 12 2013
   - CMAKE_GENERATOR: Visual Studio 11 2012
   - CMAKE_GENERATOR: Visual Studio 10 2010
-#  - CMAKE_GENERATOR: MinGW Makefiles
-# Note: Disabled because of unexplicated error -1073741511
-# This used to work fine with GCC 4.8.2 then failed after they upgraded to GCC 4.9.3
+  - CMAKE_GENERATOR: MinGW Makefiles
 configuration: Debug
 before_build:
 - set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW

examples/JsonConfigFile/JsonConfigFile.ino

@@ -0,0 +1,146 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+//
+// This example shows how to store your project configuration in a file.
+// It uses the SD library but can be easily modified for any other file-system.
+//
+// The file contains a JSON document with the following content:
+// {
+//   "hostname": "examples.com",
+//   "port": 2731
+// }
+
+#include <ArduinoJson.h>
+#include <SD.h>
+#include <SPI.h>
+
+// Configuration that we'll store on disk
+struct Config {
+  char hostname[64];
+  int port;
+};
+
+const char *filename = "/config.txt";  // <- SD library uses 8.3 filenames
+Config config;                         // <- global configuration object
+
+// Loads the configuration from a file
+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.
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonDocument<512> doc;
+
+  // Deserialize the JSON document
+  DeserializationError error = deserializeJson(doc, file);
+  if (error)
+    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
+          root["hostname"] | "example.com",  // <- source
+          sizeof(config.hostname));          // <- destination's capacity
+
+  // Close the file (File's destructor doesn't close the file)
+  file.close();
+}
+
+// Saves the configuration to a file
+void saveConfiguration(const char *filename, const Config &config) {
+  // Delete existing file, otherwise the configuration is appended to the file
+  SD.remove(filename);
+
+  // Open file for writing
+  File file = SD.open(filename, FILE_WRITE);
+  if (!file) {
+    Serial.println(F("Failed to create file"));
+    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;
+
+  // Make our document contain an object
+  JsonObject &root = doc.to<JsonObject>();
+
+  // Set the values in the object
+  root["hostname"] = config.hostname;
+  root["port"] = config.port;
+
+  // Serialize JSON to file
+  if (serializeJson(doc, file) == 0) {
+    Serial.println(F("Failed to write to file"));
+  }
+
+  // Close the file (File's destructor doesn't close the file)
+  file.close();
+}
+
+// Prints the content of a file to the Serial
+void printFile(const char *filename) {
+  // Open file for reading
+  File file = SD.open(filename);
+  if (!file) {
+    Serial.println(F("Failed to read file"));
+    return;
+  }
+
+  // Extract each characters by one by one
+  while (file.available()) {
+    Serial.print((char)file.read());
+  }
+  Serial.println();
+
+  // Close the file (File's destructor doesn't close the file)
+  file.close();
+}
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize SD library
+  while (!SD.begin()) {
+    Serial.println(F("Failed to initialize SD library"));
+    delay(1000);
+  }
+
+  // Should load default config if run for the first time
+  Serial.println(F("Loading configuration..."));
+  loadConfiguration(filename, config);
+
+  // Create configuration file
+  Serial.println(F("Saving configuration..."));
+  saveConfiguration(filename, config);
+
+  // Dump config file
+  Serial.println(F("Print config file..."));
+  printFile(filename);
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// The website 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.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,36 +1,30 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
 //
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
+// This example shows how to generate a JSON document with ArduinoJson.
 
 #include <ArduinoJson.h>
 
 void setup() {
+  // Initialize Serial port
   Serial.begin(9600);
-  while (!Serial) {
-    // wait serial port initialization
-  }
+  while (!Serial) continue;
 
-  // Memory pool for JSON object tree.
+  // Allocate the JSON document
   //
-  // Inside the brackets, 200 is the size of the pool in bytes.
-  // If the JSON object is more complex, you need to increase that value.
-  StaticJsonBuffer<200> jsonBuffer;
+  // Inside the brackets, 200 is the RAM allocated to this document.
+  // Don't forget to change this value to match your requirement.
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonDocument<200> doc;
 
-  // StaticJsonBuffer allocates memory on the stack, it can be
-  // replaced by DynamicJsonBuffer which allocates in the heap.
-  // It's simpler but less efficient.
+  // StaticJsonObject allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
   //
-  // DynamicJsonBuffer  jsonBuffer;
+  // DynamicJsonDocument  doc(200);
 
-  // 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();
+  // Make our document be an object
+  JsonObject& root = doc.to<JsonObject>();
 
   // Add values in the object
   //
@@ -39,21 +33,19 @@ void setup() {
   root["sensor"] = "gps";
   root["time"] = 1351824120;
 
-  // Add a nested array.
+  // Add an array.
   //
-  // 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(double_with_n_digits(48.756080, 6));
-  data.add(double_with_n_digits(2.302038, 6));
+  data.add(48.756080);
+  data.add(2.302038);
 
-  root.printTo(Serial);
+  serializeJson(root, Serial);
   // This prints:
   // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 
   Serial.println();
 
-  root.prettyPrintTo(Serial);
+  serializeJsonPretty(root, Serial);
   // This prints:
   // {
   //   "sensor": "gps",
@@ -68,3 +60,16 @@ void setup() {
 void loop() {
   // not used in this example
 }
+
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/JsonHttpClient/JsonHttpClient.ino

@@ -1,184 +1,114 @@
-// Sample Arduino Json Web Client
-// Downloads and parse http://jsonplaceholder.typicode.com/users/1
-//
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
 //
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
+// This example shows how to parse a JSON document in an HTTP response.
+// It uses the Ethernet library, but can be easily adapted for Wifi.
+//
+// It performs a GET resquest on arduinojson.org/example.json
+// Here is the expected response:
+// {
+//   "sensor": "gps",
+//   "time": 1351824120,
+//   "data": [
+//     48.756080,
+//     2.302038
+//   ]
+// }
 
 #include <ArduinoJson.h>
 #include <Ethernet.h>
 #include <SPI.h>
 
-EthernetClient client;
-
-const char* server = "jsonplaceholder.typicode.com";  // server's address
-const char* resource = "/users/1";                    // http resource
-const unsigned long BAUD_RATE = 9600;                 // serial connection speed
-const unsigned long HTTP_TIMEOUT = 10000;  // max respone time from server
-const size_t MAX_CONTENT_SIZE = 512;       // max size of the HTTP response
-
-// The type of data that we want to extract from the page
-struct UserData {
-  char name[32];
-  char company[32];
-};
-
-// ARDUINO entry point #1: runs once when you press reset or power the board
 void setup() {
-  initSerial();
-  initEthernet();
-}
+  // Initialize Serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
 
-// ARDUINO entry point #2: runs over and over again forever
-void loop() {
-  if (connect(server)) {
-    if (sendRequest(server, resource) && skipResponseHeaders()) {
-      UserData userData;
-      if (readReponseContent(&userData)) {
-        printUserData(&userData);
-      }
-    }
-  }
-  disconnect();
-  wait();
-}
-
-// Initialize Serial port
-void initSerial() {
-  Serial.begin(BAUD_RATE);
-  while (!Serial) {
-    ;  // wait for serial port to initialize
-  }
-  Serial.println("Serial ready");
-}
-
-// Initialize Ethernet library
-void initEthernet() {
+  // Initialize Ethernet library
   byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
   if (!Ethernet.begin(mac)) {
-    Serial.println("Failed to configure Ethernet");
+    Serial.println(F("Failed to configure Ethernet"));
     return;
   }
-  Serial.println("Ethernet ready");
   delay(1000);
-}
 
-// Open connection to the HTTP server
-bool connect(const char* hostName) {
-  Serial.print("Connect to ");
-  Serial.println(hostName);
+  Serial.println(F("Connecting..."));
 
-  bool ok = client.connect(hostName, 80);
+  // Connect to HTTP server
+  EthernetClient client;
+  client.setTimeout(10000);
+  if (!client.connect("arduinojson.org", 80)) {
+    Serial.println(F("Connection failed"));
+    return;
+  }
 
-  Serial.println(ok ? "Connected" : "Connection Failed!");
-  return ok;
-}
+  Serial.println(F("Connected!"));
 
-// Send the HTTP GET request to the server
-bool sendRequest(const char* host, const char* resource) {
-  Serial.print("GET ");
-  Serial.println(resource);
+  // Send HTTP request
+  client.println(F("GET /example.json HTTP/1.0"));
+  client.println(F("Host: arduinojson.org"));
+  client.println(F("Connection: close"));
+  if (client.println() == 0) {
+    Serial.println(F("Failed to send request"));
+    return;
+  }
 
-  client.print("GET ");
-  client.print(resource);
-  client.println(" HTTP/1.0");
-  client.print("Host: ");
-  client.println(host);
-  client.println("Connection: close");
-  client.println();
+  // Check HTTP status
+  char status[32] = {0};
+  client.readBytesUntil('\r', status, sizeof(status));
+  if (strcmp(status, "HTTP/1.1 200 OK") != 0) {
+    Serial.print(F("Unexpected response: "));
+    Serial.println(status);
+    return;
+  }
 
-  return true;
-}
-
-// Skip HTTP headers so that we are at the beginning of the response's body
-bool skipResponseHeaders() {
-  // HTTP headers end with an empty line
+  // Skip HTTP headers
   char endOfHeaders[] = "\r\n\r\n";
-
-  client.setTimeout(HTTP_TIMEOUT);
-  bool ok = client.find(endOfHeaders);
-
-  if (!ok) {
-    Serial.println("No response or invalid response!");
+  if (!client.find(endOfHeaders)) {
+    Serial.println(F("Invalid response"));
+    return;
   }
 
-  return ok;
-}
+  // Allocate the JSON document
+  // Use arduinojson.org/assistant to compute the capacity.
+  const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
+  DynamicJsonDocument doc(capacity);
 
-// Parse the JSON from the input string and extract the interesting values
-// Here is the JSON we need to parse
-// {
-//   "id": 1,
-//   "name": "Leanne Graham",
-//   "username": "Bret",
-//   "email": "Sincere@april.biz",
-//   "address": {
-//     "street": "Kulas Light",
-//     "suite": "Apt. 556",
-//     "city": "Gwenborough",
-//     "zipcode": "92998-3874",
-//     "geo": {
-//       "lat": "-37.3159",
-//       "lng": "81.1496"
-//     }
-//   },
-//   "phone": "1-770-736-8031 x56442",
-//   "website": "hildegard.org",
-//   "company": {
-//     "name": "Romaguera-Crona",
-//     "catchPhrase": "Multi-layered client-server neural-net",
-//     "bs": "harness real-time e-markets"
-//   }
-// }
-bool readReponseContent(struct UserData* userData) {
-  // Compute optimal size of the JSON buffer according to what we need to parse.
-  // This is only required if you use StaticJsonBuffer.
-  const size_t BUFFER_SIZE =
-      JSON_OBJECT_SIZE(8)    // the root object has 8 elements
-      + JSON_OBJECT_SIZE(5)  // the "address" object has 5 elements
-      + JSON_OBJECT_SIZE(2)  // the "geo" object has 2 elements
-      + JSON_OBJECT_SIZE(3)  // the "company" object has 3 elements
-      + MAX_CONTENT_SIZE;    // additional space for strings
-
-  // Allocate a temporary memory pool
-  DynamicJsonBuffer jsonBuffer(BUFFER_SIZE);
-
-  JsonObject& root = jsonBuffer.parseObject(client);
-
-  if (!root.success()) {
-    Serial.println("JSON parsing failed!");
-    return false;
+  // Parse JSON object
+  DeserializationError error = deserializeJson(doc, client);
+  if (error) {
+    Serial.print(F("deserializeJson() failed: "));
+    Serial.println(error.c_str());
+    return;
   }
 
-  // Here were copy the strings we're interested in
-  strcpy(userData->name, root["name"]);
-  strcpy(userData->company, root["company"]["name"]);
-  // It's not mandatory to make a copy, you could just use the pointers
-  // Since, they are pointing inside the "content" buffer, so you need to make
-  // sure it's still in memory when you read the string
+  // Extract values
+  JsonObject& root = doc.as<JsonObject>();
+  Serial.println(F("Response:"));
+  Serial.println(root["sensor"].as<char*>());
+  Serial.println(root["time"].as<char*>());
+  Serial.println(root["data"][0].as<char*>());
+  Serial.println(root["data"][1].as<char*>());
 
-  return true;
-}
-
-// Print the data extracted from the JSON
-void printUserData(const struct UserData* userData) {
-  Serial.print("Name = ");
-  Serial.println(userData->name);
-  Serial.print("Company = ");
-  Serial.println(userData->company);
-}
-
-// Close the connection with the HTTP server
-void disconnect() {
-  Serial.println("Disconnect");
+  // Disconnect
   client.stop();
 }
 
-// Pause for a 1 minute
-void wait() {
-  Serial.println("Wait 60 seconds");
-  delay(60000);
+void loop() {
+  // not used in this example
 }
+
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization  problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/JsonParserExample/JsonParserExample.ino

@@ -1,29 +1,27 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
 //
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
+// This example shows how to deserialize a JSON document with ArduinoJson.
 
 #include <ArduinoJson.h>
 
 void setup() {
+  // Initialize serial port
   Serial.begin(9600);
-  while (!Serial) {
-    // wait serial port initialization
-  }
+  while (!Serial) continue;
 
-  // Memory pool for JSON object tree.
+  // Allocate the JSON document
   //
-  // Inside the brackets, 200 is the size of the pool in bytes,
-  // If the JSON object is more complex, you need to increase that value.
-  StaticJsonBuffer<200> jsonBuffer;
+  // 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;
 
-  // StaticJsonBuffer allocates memory on the stack, it can be
-  // replaced by DynamicJsonBuffer which allocates in the heap.
-  // It's simpler but less efficient.
+  // StaticJsonDocument<N> allocates memory on the stack, it can be
+  // replaced by DynamicJsonObject which allocates in the heap.
   //
-  // DynamicJsonBuffer  jsonBuffer;
+  // DynamicJsonObject doc(200);
 
   // JSON input string.
   //
@@ -33,19 +31,19 @@ void setup() {
   char json[] =
       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-  // 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);
+  // Deserialize the JSON document
+  DeserializationError error = deserializeJson(doc, json);
 
   // Test if parsing succeeds.
-  if (!root.success()) {
-    Serial.println("parseObject() failed");
+  if (error) {
+    Serial.print(F("deserializeJson() 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.
@@ -65,3 +63,16 @@ void setup() {
 void loop() {
   // not used in this example
 }
+
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// deserialization problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/JsonServer/JsonServer.ino

@@ -1,74 +1,109 @@
-// Sample Arduino Json Web Server
-// Created by Benoit Blanchon.
-// Heavily inspired by "Web Server" from David A. Mellis and Tom Igoe
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+//
+// This example shows how to implement an HTTP server that sends JSON document
+// in the responses.
+// It uses the Ethernet library but can be easily adapted for Wifi.
+//
+// It sends the value of the analog and digital pins.
+// The JSON document looks like the following:
+// {
+//   "analog": [ 0, 1, 2, 3, 4, 5 ],
+//   "digital": [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ]
+// }
 
-#include <SPI.h>
-#include <Ethernet.h>
 #include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>
 
 byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
-IPAddress ip(192, 168, 0, 177);
 EthernetServer server(80);
 
-bool readRequest(EthernetClient& client) {
-  bool currentLineIsBlank = true;
-  while (client.connected()) {
-    if (client.available()) {
-      char c = client.read();
-      if (c == '\n' && currentLineIsBlank) {
-        return true;
-      } else if (c == '\n') {
-        currentLineIsBlank = true;
-      } else if (c != '\r') {
-        currentLineIsBlank = false;
-      }
-    }
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize Ethernet libary
+  if (!Ethernet.begin(mac)) {
+    Serial.println(F("Failed to initialize Ethernet library"));
+    return;
   }
-  return false;
+
+  // Start to listen
+  server.begin();
+
+  Serial.println(F("Server is ready."));
+  Serial.print(F("Please connect to http://"));
+  Serial.println(Ethernet.localIP());
 }
 
-JsonObject& prepareResponse(JsonBuffer& jsonBuffer) {
-  JsonObject& root = jsonBuffer.createObject();
+void loop() {
+  // Wait for an incomming connection
+  EthernetClient client = server.available();
 
+  // Do we have a client?
+  if (!client) return;
+
+  Serial.println(F("New client"));
+
+  // Read the request (we ignore the content in this example)
+  while (client.available()) client.read();
+
+  // Allocate the JSON document
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonDocument<500> doc;
+
+  // Make our document represent an object
+  JsonObject& root = doc.to<JsonObject>();
+
+  // Create the "analog" array
   JsonArray& analogValues = root.createNestedArray("analog");
   for (int pin = 0; pin < 6; pin++) {
+    // Read the analog input
     int value = analogRead(pin);
+
+    // Add the value at the end of the array
     analogValues.add(value);
   }
 
+  // Create the "digital" array
   JsonArray& digitalValues = root.createNestedArray("digital");
   for (int pin = 0; pin < 14; pin++) {
+    // Read the digital input
     int value = digitalRead(pin);
+
+    // Add the value at the end of the array
     digitalValues.add(value);
   }
 
-  return root;
-}
+  Serial.print(F("Sending: "));
+  serializeJson(root, Serial);
+  Serial.println();
 
-void writeResponse(EthernetClient& client, JsonObject& json) {
-  client.println("HTTP/1.1 200 OK");
+  // Write response headers
+  client.println("HTTP/1.0 200 OK");
   client.println("Content-Type: application/json");
   client.println("Connection: close");
   client.println();
 
-  json.prettyPrintTo(client);
+  // Write JSON document
+  serializeJsonPretty(root, client);
+
+  // Disconnect
+  client.stop();
 }
 
-void setup() {
-  Ethernet.begin(mac, ip);
-  server.begin();
-}
-
-void loop() {
-  EthernetClient client = server.available();
-  if (client) {
-    bool success = readRequest(client);
-    if (success) {
-      StaticJsonBuffer<500> jsonBuffer;
-      JsonObject& json = prepareResponse(jsonBuffer);
-      writeResponse(client, json);
-    }
-    delay(1);
-    client.stop();
-  }
-}
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -1,55 +1,101 @@
-// Send a JSON object on UDP at regular interval
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
 //
-// You can easily test this program with netcat:
-// $ nc -ulp 8888
+// This example shows how to send a JSON document to a UDP socket.
+// At regular interval, it sends a UDP packet that contains the status of
+// analog and digital pins.
+// The JSON document looks like the following:
+// {
+//   "analog": [ 0, 1, 2, 3, 4, 5 ],
+//   "digital": [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ]
+// }
 //
-// by Benoit Blanchon, MIT License 2015-2017
+// If you want to test this program, you need to be able to receive the UDP
+// packets.
+// For example, you can run netcat on your computer
+// $ ncat -ulp 8888
+// See https://nmap.org/ncat/
 
 #include <ArduinoJson.h>
 #include <Ethernet.h>
 #include <SPI.h>
 
 byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
-IPAddress localIp(192, 168, 0, 177);
-IPAddress remoteIp(192, 168, 0, 109);
-unsigned int remotePort = 8888;
-unsigned localPort = 8888;
+IPAddress remoteIp(192, 168, 0, 108);  // <- EDIT!!!!
+unsigned short remotePort = 8888;
+unsigned short localPort = 8888;
 EthernetUDP udp;
 
-JsonObject& buildJson(JsonBuffer& jsonBuffer) {
-  JsonObject& root = jsonBuffer.createObject();
-
-  JsonArray& analogValues = root.createNestedArray("analog");
-  for (int pin = 0; pin < 6; pin++) {
-    int value = analogRead(pin);
-    analogValues.add(value);
-  }
-
-  JsonArray& digitalValues = root.createNestedArray("digital");
-  for (int pin = 0; pin < 14; pin++) {
-    int value = digitalRead(pin);
-    digitalValues.add(value);
-  }
-
-  return root;
-}
-
-void sendJson(JsonObject& json) {
-  udp.beginPacket(remoteIp, remotePort);
-  json.printTo(udp);
-  udp.println();
-  udp.endPacket();
-}
-
 void setup() {
-  Ethernet.begin(mac, localIp);
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize Ethernet libary
+  if (!Ethernet.begin(mac)) {
+    Serial.println(F("Failed to initialize Ethernet library"));
+    return;
+  }
+
+  // Enable UDP
   udp.begin(localPort);
 }
 
 void loop() {
-  delay(1000);
+  // Allocate the JSON document
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonDocument<500> doc;
 
-  StaticJsonBuffer<300> jsonBuffer;
-  JsonObject& json = buildJson(jsonBuffer);
-  sendJson(json);
+  // Make our document represent an object
+  JsonObject& root = doc.to<JsonObject>();
+
+  // Create the "analog" array
+  JsonArray& analogValues = root.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    // Read the analog input
+    int value = analogRead(pin);
+
+    // Add the value at the end of the array
+    analogValues.add(value);
+  }
+
+  // Create the "digital" array
+  JsonArray& digitalValues = root.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    // Read the digital input
+    int value = digitalRead(pin);
+
+    // Add the value at the end of the array
+    digitalValues.add(value);
+  }
+
+  // Log
+  Serial.print(F("Sending to "));
+  Serial.print(remoteIp);
+  Serial.print(F(" on port "));
+  Serial.println(remotePort);
+  serializeJson(root, Serial);
+
+  // Send UDP packet
+  udp.beginPacket(remoteIp, remotePort);
+  serializeJson(root, udp);
+  udp.println();
+  udp.endPacket();
+
+  // Wait
+  delay(10000);
 }
+
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/MsgPackParser/MsgPackParser.ino

@@ -0,0 +1,91 @@
+// 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
+}
+
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// deserialization problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/ProgmemExample/ProgmemExample.ino

@@ -1,46 +1,47 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
 //
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
+// This example shows the different ways you can use Flash strings with
+// ArduinoJson.
+//
+// Use Flash strings sparingly, because ArduinoJson duplicates them in the
+// JsonBuffer. Prefer plain old char*, as they are more efficient in term of
+// code size, speed, and memory usage.
 
 #include <ArduinoJson.h>
 
-// About
-// -----
-// This example shows the different ways you can use PROGMEM with ArduinoJson.
-// Please don't see this as an invitation to use PROGMEM.
-// On the contrary, you should always use char[] when possible, it's much more
-// efficient in term of code size, speed and memory usage.
-
 void setup() {
-#ifdef PROGMEM
-  DynamicJsonBuffer jsonBuffer;
+#ifdef PROGMEM  // <- check that Flash strings are supported
+
+  DynamicJsonDocument doc;
 
   // You can use a Flash String as your JSON input.
   // WARNING: the content of the Flash String will be duplicated in the
   // JsonBuffer.
-  JsonObject& root =
-      jsonBuffer.parseObject(F("{\"sensor\":\"gps\",\"time\":1351824120,"
-                               "\"data\":[48.756080,2.302038]}"));
+  deserializeJson(doc, F("{\"sensor\":\"gps\",\"time\":1351824120,"
+                         "\"data\":[48.756080,2.302038]}"));
+  JsonObject& obj = doc.as<JsonObject>();
 
   // You can use a Flash String to get an element of a JsonObject
   // No duplication is done.
-  long time = root[F("time")];
+  long time = obj[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.
-  root[F("time")] = time;
+  obj[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.
-  root["sensor"] = F("gps");
+  obj["sensor"] = F("gps");
+
+  // It works with RawJson too:
+  obj["sensor"] = RawJson(F("\"gps\""));
 
   // You can compare the content of a JsonVariant to a Flash String
-  if (root["sensor"] == F("gps")) {
+  if (obj["sensor"] == F("gps")) {
     // ...
   }
 
@@ -54,3 +55,16 @@ void setup() {
 void loop() {
   // not used in this example
 }
+
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any memory
+// problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

examples/StringExample/StringExample.ino

@@ -1,63 +1,75 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
 //
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
+// This example shows the different ways you can use String with ArduinoJson.
+//
+// Use String objects sparingly, because ArduinoJson duplicates them in the
+// JsonBuffer. Prefer plain old char[], as they are more efficient in term of
+// code size, speed, and memory usage.
 
 #include <ArduinoJson.h>
 
-// About
-// -----
-// This example shows the different ways you can use String with ArduinoJson.
-// Please don't see this as an invitation to use String.
-// On the contrary, you should always use char[] when possible, it's much more
-// efficient in term of code size, speed and memory usage.
-
 void setup() {
-  DynamicJsonBuffer jsonBuffer;
+  DynamicJsonDocument doc;
 
   // 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]}";
-  JsonObject& root = jsonBuffer.parseObject(input);
+  deserializeJson(doc, input);
+  JsonObject& obj = doc.as<JsonObject>();
 
   // You can use a String to get an element of a JsonObject
   // No duplication is done.
-  long time = root[String("time")];
+  long time = obj[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.
-  root[String("time")] = time;
+  obj[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 = root["sensor"];
+  String sensor = obj["sensor"];
 
   // Unfortunately, the following doesn't work (issue #118):
-  // sensor = root["sensor"]; // <-  error "ambiguous overload for 'operator='"
+  // sensor = obj["sensor"]; // <-  error "ambiguous overload for 'operator='"
   // As a workaround, you need to replace by:
-  sensor = root["sensor"].as<String>();
+  sensor = obj["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.
-  root["sensor"] = sensor;
+  obj["sensor"] = sensor;
+
+  // It works with RawJson too:
+  obj["sensor"] = RawJson(sensor);
 
   // You can also concatenate strings
   // WARNING: the content of the String will be duplicated in the JsonBuffer.
-  root[String("sen") + "sor"] = String("gp") + "s";
+  obj[String("sen") + "sor"] = String("gp") + "s";
 
   // You can compare the content of a JsonObject with a String
-  if (root["sensor"] == sensor) {
+  if (obj["sensor"] == sensor) {
     // ...
   }
 
   // Lastly, you can print the resulting JSON to a String
   String output;
-  root.printTo(output);
+  serializeJson(doc, output);
 }
 
 void loop() {
   // not used in this example
 }
+
+// See also
+// --------
+//
+// The website arduinojson.org contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any problem.
+// Please check it out at: https://arduinojson.org/
+//
+// 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.
+// Please check it out at: https://arduinojson.org/book/

fuzzing/Makefile

@@ -5,15 +5,18 @@ CXXFLAGS += -I../src
 all: \
 	$(OUT)/json_fuzzer \
 	$(OUT)/json_fuzzer_seed_corpus.zip \
-	$(OUT)/json_fuzzer.options
+	$(OUT)/json_fuzzer.options \
+	$(OUT)/msgpack_fuzzer \
+	$(OUT)/msgpack_fuzzer_seed_corpus.zip \
+	$(OUT)/msgpack_fuzzer.options
 
-$(OUT)/json_fuzzer: fuzzer.cpp $(shell find ../src -type f)
+$(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../src -type f)
 	$(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE)
 
-$(OUT)/json_fuzzer_seed_corpus.zip: seed_corpus/*
+$(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/*
 	zip -j $@ $?
 
-$(OUT)/json_fuzzer.options:
+$(OUT)/%_fuzzer.options:
 	@echo "[libfuzzer]" > $@
 	@echo "max_len = 256" >> $@
 	@echo "timeout = 10" >> $@

fuzzing/fuzz.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-# This script mimics an invocation from https://github.com/google/oss-fuzz
-
-cd $(dirname $0)
-export CXX='clang++'
-export CXXFLAGS='-fsanitize-coverage=trace-pc-guard -fsanitize=address'
-export LIB_FUZZING_ENGINE=-lFuzzer
-make OUT=.
-./json_fuzzer my_corpus seed_corpus -max_len=1024 -timeout=10

fuzzing/fuzzer.cpp

@@ -1,26 +0,0 @@
-#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;
-}

fuzzing/json_fuzzer.cpp

@@ -0,0 +1,11 @@
+#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;
+}

fuzzing/msgpack_corpus/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

fuzzing/msgpack_fuzzer.cpp

@@ -0,0 +1,11 @@
+#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;
+}

fuzzing/msgpack_seed_corpus/false

@@ -0,0 +1 @@
+<EFBFBD>

fuzzing/msgpack_seed_corpus/fixarray

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>hello<EFBFBD>world

fuzzing/msgpack_seed_corpus/fixint_negative

@@ -0,0 +1 @@
+<EFBFBD>

fuzzing/msgpack_seed_corpus/fixint_positive

@@ -0,0 +1 @@
+

fuzzing/msgpack_seed_corpus/fixmap

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>one
<01>two

fuzzing/msgpack_seed_corpus/fixstr

@@ -0,0 +1 @@
+<EFBFBD>hello world

fuzzing/msgpack_seed_corpus/float32

@@ -0,0 +1 @@
+<EFBFBD>@H<><48>

fuzzing/msgpack_seed_corpus/float64

@@ -0,0 +1 @@
+<EFBFBD>@	!<21><><EFBFBD>o

fuzzing/msgpack_seed_corpus/int16

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD><EFBFBD>

fuzzing/msgpack_seed_corpus/int32

@@ -0,0 +1 @@
+Ҷi<EFBFBD>.

fuzzing/msgpack_seed_corpus/int64

@@ -0,0 +1 @@
+<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

fuzzing/msgpack_seed_corpus/int8

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>

fuzzing/msgpack_seed_corpus/nil

@@ -0,0 +1 @@
+<EFBFBD>

fuzzing/msgpack_seed_corpus/str8

@@ -0,0 +1 @@
+<EFBFBD>hello

fuzzing/msgpack_seed_corpus/true

@@ -0,0 +1 @@
+<EFBFBD>

fuzzing/msgpack_seed_corpus/uint16

@@ -0,0 +1 @@
+<EFBFBD>09

fuzzing/msgpack_seed_corpus/uint32

@@ -0,0 +1 @@
+<EFBFBD>4Vx

fuzzing/msgpack_seed_corpus/uint64

@@ -0,0 +1 @@
+<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

fuzzing/msgpack_seed_corpus/uint8

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>

keywords.txt

@@ -1,15 +1,17 @@
+add	KEYWORD2
+as	KEYWORD2
+createNestedArray	KEYWORD2
+createNestedObject	KEYWORD2
+deserializeJson	KEYWORD2
+deserializeMsgPack	KEYWORD2
+DynamicJsonDocument	KEYWORD1
+get	KEYWORD2
 JsonArray	KEYWORD1
 JsonObject	KEYWORD1
 JsonVariant	KEYWORD1
-StaticJsonBuffer	KEYWORD1
-DynamicJsonBuffer	KEYWORD1
-add	KEYWORD2
-createArray	KEYWORD2
-createNestedArray	KEYWORD2
-createNestedObject	KEYWORD2
-createObject	KEYWORD2
-parseArray	KEYWORD2
-parseObject	KEYWORD2
-prettyPrintTo	KEYWORD2
-printTo	KEYWORD2
-success	KEYWORD2
+serializeMsgPack	KEYWORD2
+serializeJson	KEYWORD2
+serializeJsonPretty	KEYWORD2
+set	KEYWORD2
+StaticJsonDocument	KEYWORD1
+to	KEYWORD2

library.json

@@ -2,11 +2,12 @@
   "name": "ArduinoJson",
   "keywords": "json, rest, http, web",
   "description": "An elegant and efficient JSON library for embedded systems",
+  "homepage": "https://arduinojson.org/?utm_source=meta&utm_medium=library.json",
   "repository": {
     "type": "git",
     "url": "https://github.com/bblanchon/ArduinoJson.git"
   },
-  "version": "5.9.0",
+  "version": "6.0.1-beta",
   "authors": {
     "name": "Benoit Blanchon",
     "url": "https://blog.benoitblanchon.fr"

library.properties

@@ -1,9 +1,11 @@
 name=ArduinoJson
-version=5.9.0
+version=6.0.1-beta
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.
-paragraph=Like this project? Please star it on GitHub!
+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.
 category=Data Processing
-url=https://bblanchon.github.io/ArduinoJson/
+url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties
 architectures=*
+repository=https://github.com/bblanchon/ArduinoJson.git
+license=MIT

scripts/build-single-header.sh

@@ -40,5 +40,14 @@ process()
 cd $(dirname $0)/../
 INCLUDED=()
 process src/ArduinoJson.h true > ../ArduinoJson-$TAG.h
+g++ -x c++ -c -o ../smoketest.o - <<END
+#include "../ArduinoJson-$TAG.h"
+int main() {}
+END
+
 INCLUDED=()
-process src/ArduinoJson.hpp true > ../ArduinoJson-$TAG.hpp
+process src/ArduinoJson.hpp true > ../ArduinoJson-$TAG.hpp
+g++ -x c++ -c -o ../smoketest.o - <<END
+#include "../ArduinoJson-$TAG.hpp"
+int main() {}
+END

scripts/oss-fuzz/Vagrantfile

@@ -2,11 +2,16 @@
 Vagrant.configure(2) do |config|
   config.vm.box = "ubuntu/xenial64"
 
-  config.vm.synced_folder "E:\\Git\\Arduino\\libraries\\ArduinoJson", "/host/ArduinoJson"
+  config.vm.synced_folder "../..", "/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
 
@@ -18,10 +23,6 @@ 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

scripts/travis/arduino.sh

@@ -1,4 +1,4 @@
-#!/bin/sh -eux
+#!/bin/bash -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,9 +6,13 @@ 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

scripts/travis/fuzz.sh

@@ -0,0 +1,26 @@
+#!/bin/bash -eux
+
+ROOT_DIR=$(dirname $0)/../../
+INCLUDE_DIR=${ROOT_DIR}/src/
+FUZZING_DIR=${ROOT_DIR}/fuzzing/
+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"
+
+	clang++-${CLANG} ${CXXFLAGS} -o ${FUZZER} -I$INCLUDE_DIR ${FUZZER_CPP}
+
+	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 ${LLVM_PROFILE_FILE} -o ${FUZZER}.profdata
+	llvm-cov-${CLANG} report ./${FUZZER} -instr-profile=${FUZZER}.profdata
+}
+
+fuzz json
+fuzz msgpack

src/ArduinoJson.h

@@ -1,12 +1,17 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
+#ifdef __cplusplus
+
 #include "ArduinoJson.hpp"
 
 using namespace ArduinoJson;
+
+#else
+
+#error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp
+
+#endif

src/ArduinoJson.hpp

@@ -1,21 +1,19 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
-#include "ArduinoJson/DynamicJsonBuffer.hpp"
-#include "ArduinoJson/JsonArray.hpp"
-#include "ArduinoJson/JsonObject.hpp"
-#include "ArduinoJson/JsonVariantComparisons.hpp"
-#include "ArduinoJson/StaticJsonBuffer.hpp"
+#include "ArduinoJson/version.hpp"
+
+#include "ArduinoJson/DynamicJsonDocument.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/StaticJsonDocument.hpp"
 
-#include "ArduinoJson/Deserialization/JsonParserImpl.hpp"
 #include "ArduinoJson/JsonArrayImpl.hpp"
-#include "ArduinoJson/JsonBufferImpl.hpp"
 #include "ArduinoJson/JsonObjectImpl.hpp"
 #include "ArduinoJson/JsonVariantImpl.hpp"
-#include "ArduinoJson/Serialization/JsonSerializerImpl.hpp"

src/ArduinoJson/Configuration.hpp

@@ -1,25 +1,27 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
-// enable deprecated functions by default
-#ifndef ARDUINOJSON_ENABLE_DEPRECATED
-#define ARDUINOJSON_ENABLE_DEPRECATED 1
+// Small or big machine?
+#ifndef ARDUINOJSON_EMBEDDED_MODE
+#if defined(ARDUINO) || defined(__IAR_SYSTEMS_ICC__) || defined(__XC) || \
+    defined(__ARMCC_VERSION)
+#define ARDUINOJSON_EMBEDDED_MODE 1
+#else
+#define ARDUINOJSON_EMBEDDED_MODE 0
+#endif
 #endif
 
-#ifdef ARDUINO  // assume this is an embedded platform
+#if ARDUINOJSON_EMBEDDED_MODE
 
-// store using float instead of double to reduce the memory usage (issue #134)
+// Store floats by default to reduce the memory usage (issue #134)
 #ifndef ARDUINOJSON_USE_DOUBLE
 #define ARDUINOJSON_USE_DOUBLE 0
 #endif
 
-// store using a long because it usually match the size of a float.
+// Store longs by default, because they usually match the size of a float.
 #ifndef ARDUINOJSON_USE_LONG_LONG
 #define ARDUINOJSON_USE_LONG_LONG 0
 #endif
@@ -27,57 +29,29 @@
 #define ARDUINOJSON_USE_INT64 0
 #endif
 
-// Arduino has its own implementation of String to replace std::string
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
-#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
-#endif
-
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
-#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
-#endif
-
-// On AVR archiecture, we can use PROGMEM
-#ifndef ARDUINOJSON_ENABLE_PROGMEM
-#ifdef PROGMEM
-#define ARDUINOJSON_ENABLE_PROGMEM 1
-#else
-#define ARDUINOJSON_ENABLE_PROGMEM 0
-#endif
-#endif
-
-// Arduino doesn't have std::string
+// Embedded systems usually don't have std::string
 #ifndef ARDUINOJSON_ENABLE_STD_STRING
 #define ARDUINOJSON_ENABLE_STD_STRING 0
 #endif
 
-// Arduino doesn't support STL stream
+// Embedded systems usually don't have std::stream
 #ifndef ARDUINOJSON_ENABLE_STD_STREAM
 #define ARDUINOJSON_ENABLE_STD_STREAM 0
 #endif
 
-#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
-#ifdef ARDUINO_ARCH_AVR
-// alignment isn't needed for 8-bit AVR
-#define ARDUINOJSON_ENABLE_ALIGNMENT 0
-#else
-// but must processor needs pointer to be align on word size
-#define ARDUINOJSON_ENABLE_ALIGNMENT 1
-#endif
-#endif
-
-// low value to prevent stack overflow
+// Limit nesting as the stack is likely to be small
 #ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
 #define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
 #endif
 
-#else  // assume this is a computer
+#else  // ARDUINOJSON_EMBEDDED_MODE
 
-// on a computer we have plenty of memory so we can use doubles
+// On a computer we have plenty of memory so we can use doubles
 #ifndef ARDUINOJSON_USE_DOUBLE
 #define ARDUINOJSON_USE_DOUBLE 1
 #endif
 
-// use long long when available
+// Use long long when available
 #ifndef ARDUINOJSON_USE_LONG_LONG
 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
 #define ARDUINOJSON_USE_LONG_LONG 1
@@ -86,7 +60,7 @@
 #endif
 #endif
 
-// use _int64 on old versions of Visual Studio
+// Use _int64 on old versions of Visual Studio
 #ifndef ARDUINOJSON_USE_INT64
 #if defined(_MSC_VER) && _MSC_VER <= 1700
 #define ARDUINOJSON_USE_INT64 1
@@ -95,43 +69,88 @@
 #endif
 #endif
 
-// on a computer, we can use std::string
+// On a computer, we can use std::string
 #ifndef ARDUINOJSON_ENABLE_STD_STRING
 #define ARDUINOJSON_ENABLE_STD_STRING 1
 #endif
 
-// on a computer, there is no reason to beleive Arduino String is available
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
-#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
-#endif
-
-// PROGMEM is only available on AVR architecture
-#ifndef ARDUINOJSON_ENABLE_PROGMEM
-#define ARDUINOJSON_ENABLE_PROGMEM 0
-#endif
-
-// on a computer, we can assume that the STL is there
+// On a computer, we can assume std::stream
 #ifndef ARDUINOJSON_ENABLE_STD_STREAM
 #define ARDUINOJSON_ENABLE_STD_STREAM 1
 #endif
 
-// on a computer, there is no reason to beleive Arduino Stream is available
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
-#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
-#endif
-
-#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
-// even if not required, most cpu's are faster with aligned pointers
-#define ARDUINOJSON_ENABLE_ALIGNMENT 1
-#endif
-
-// on a computer, we should have a lot of space on the stack
+// On a computer, the stack is large so we can increase nesting limit
 #ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
 #define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50
 #endif
 
+#endif  // ARDUINOJSON_EMBEDDED_MODE
+
+#ifdef ARDUINO
+
+// Enable support for Arduino String
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
+#endif
+
+// Enable support for Arduino Stream
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
+#endif
+
+#else  // ARDUINO
+
+// Disable support for Arduino String
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
+#endif
+
+// Disable support for Arduino Stream
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
+#endif
+
+#endif  // ARDUINO
+
+#ifndef ARDUINOJSON_ENABLE_PROGMEM
+#ifdef PROGMEM
+#define ARDUINOJSON_ENABLE_PROGMEM 1
+#else
+#define ARDUINOJSON_ENABLE_PROGMEM 0
+#endif
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+#ifdef ARDUINO_ARCH_AVR
+// alignment isn't needed for 8-bit AVR
+#define ARDUINOJSON_ENABLE_ALIGNMENT 0
+#else
+// but most processors need pointers to be align on word size
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+#endif
+
+// Control the exponentiation threshold for big numbers
+// CAUTION: cannot be more that 1e9 !!!!
+#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
+#define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7
+#endif
+
+// Control the exponentiation threshold for small numbers
+#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD
+#define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5
 #endif
 
 #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

src/ArduinoJson/Data/IsVariant.hpp

@@ -0,0 +1,17 @@
+// 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

src/ArduinoJson/Data/JsonFloat.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 

src/ArduinoJson/Data/JsonInteger.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 

src/ArduinoJson/Data/JsonVariantAs.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 

src/ArduinoJson/Data/JsonVariantComparer.hpp

@@ -1,69 +0,0 @@
-// Copyright Benoit Blanchon 2014-2017
-// MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
-
-#pragma once
-
-#include "../JsonVariantBase.hpp"
-#include "../StringTraits/StringTraits.hpp"
-#include "../TypeTraits/EnableIf.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-template <typename TComparand, typename Enable = void>
-struct JsonVariantComparer {};
-
-template <typename TString>
-struct JsonVariantComparer<
-    TString,
-    typename TypeTraits::EnableIf<TypeTraits::IsString<TString>::value>::type> {
-  template <typename TVariant>
-  static bool equals(const JsonVariantBase<TVariant> &variant,
-                     const TString &comparand) {
-    const char *value = variant.template as<const char *>();
-    return Internals::StringTraits<TString>::equals(comparand, value);
-  }
-};
-
-template <typename TComparand>
-struct JsonVariantComparer<
-    TComparand, typename TypeTraits::EnableIf<
-                    !TypeTraits::IsVariant<TComparand>::value &&
-                    !TypeTraits::IsString<TComparand>::value>::type> {
-  template <typename TVariant>
-  static bool equals(const JsonVariantBase<TVariant> &variant,
-                     const TComparand &comparand) {
-    return variant.template as<TComparand>() == comparand;
-  }
-};
-
-template <typename TVariant2>
-struct JsonVariantComparer<TVariant2,
-                           typename TypeTraits::EnableIf<
-                               TypeTraits::IsVariant<TVariant2>::value>::type> {
-  template <typename TVariant1>
-  static bool equals(const JsonVariantBase<TVariant1> &left,
-                     const TVariant2 &right) {
-    if (left.template is<bool>() && right.template is<bool>())
-      return left.template as<bool>() == right.template as<bool>();
-    if (left.template is<JsonInteger>() && right.template is<JsonInteger>())
-      return left.template as<JsonInteger>() ==
-             right.template as<JsonInteger>();
-    if (left.template is<JsonFloat>() && right.template is<JsonFloat>())
-      return left.template as<JsonFloat>() == right.template as<JsonFloat>();
-    if (left.template is<JsonArray>() && right.template is<JsonArray>())
-      return left.template as<JsonArray>() == right.template as<JsonArray>();
-    if (left.template is<JsonObject>() && right.template is<JsonObject>())
-      return left.template as<JsonObject>() == right.template as<JsonObject>();
-    if (left.template is<char *>() && right.template is<char *>())
-      return strcmp(left.template as<char *>(), right.template as<char *>()) ==
-             0;
-
-    return false;
-  }
-};
-}
-}

src/ArduinoJson/Data/JsonVariantContent.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 

src/ArduinoJson/Data/JsonVariantDefault.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 

src/ArduinoJson/Data/JsonVariantType.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
@@ -20,20 +17,11 @@ enum JsonVariantType {
   JSON_UNPARSED,          // JsonVariant contains an unparsed string
   JSON_STRING,            // JsonVariant stores a const char*
   JSON_BOOLEAN,           // JsonVariant stores a bool
-  JSON_POSITIVE_INTEGER,  // JsonVariant stores an unsigned long
-  JSON_NEGATIVE_INTEGER,  // JsonVariant stores an unsigned long that must be
-                          // negated
+  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 JsonArray
   JSON_OBJECT,            // JsonVariant stores a pointer to a JsonObject
-
-  // The following values are reserved for float values
-  // Multiple values are used for double, depending on the number of decimal
-  // digits that must be printed in the JSON output.
-  // This little trick allow to save one extra member in JsonVariant
-  JSON_FLOAT_0_DECIMALS
-  // JSON_FLOAT_1_DECIMAL
-  // JSON_FLOAT_2_DECIMALS
-  // ...
+  JSON_FLOAT              // JsonVariant stores a JsonFloat
 };
 }
 }

src/ArduinoJson/Data/List.hpp

@@ -1,13 +1,10 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
-#include "../JsonBuffer.hpp"
+#include "../Memory/JsonBuffer.hpp"
 #include "ListConstIterator.hpp"
 #include "ListIterator.hpp"
 
@@ -30,7 +27,7 @@ class List {
   // 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) {}
+  explicit List(JsonBuffer *buf) : _buffer(buf), _firstNode(NULL) {}
 
   // Returns true if the object is valid
   // Would return false in the following situation:
@@ -87,11 +84,19 @@ class List {
     }
   }
 
+  JsonBuffer &buffer() const {
+    return *_buffer;
+  }
+
  protected:
+  void clear() {
+    _firstNode = 0;
+  }
+
   JsonBuffer *_buffer;
 
  private:
   node_type *_firstNode;
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

src/ArduinoJson/Data/ListConstIterator.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 

src/ArduinoJson/Data/ListIterator.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 

src/ArduinoJson/Data/ListNode.hpp

@@ -1,15 +1,12 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
 #include <stddef.h>  // for NULL
 
-#include "JsonBufferAllocated.hpp"
+#include "../Memory/JsonBufferAllocated.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -18,10 +15,10 @@ namespace Internals {
 // Used by List<T> and its iterators.
 template <typename T>
 struct ListNode : public Internals::JsonBufferAllocated {
-  ListNode() : next(NULL) {}
+  ListNode() throw() : next(NULL) {}
 
   ListNode<T> *next;
   T content;
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

src/ArduinoJson/Data/ReferenceType.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
@@ -22,16 +19,6 @@ class ReferenceType {
   bool operator!=(const ReferenceType& other) const {
     return this != &other;
   }
-
- protected:
-  ReferenceType() {}
-
- private:
-  // copy constructor is private
-  ReferenceType(const ReferenceType&);
-
-  // copy operator is private
-  ReferenceType& operator=(const ReferenceType&);
 };
 }
 }

src/ArduinoJson/Data/ValueSaver.hpp

@@ -0,0 +1,52 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#pragma once
+
+#include "../JsonVariant.hpp"
+#include "../Memory/JsonBuffer.hpp"
+#include "../Polyfills/type_traits.hpp"
+#include "../Strings/StringTraits.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename Source, typename Enable = void>
+struct ValueSaver {
+  template <typename Destination>
+  static bool save(JsonBuffer*, Destination& destination, Source source) {
+    destination = source;
+    return true;
+  }
+};
+
+template <typename Source>
+struct ValueSaver<
+    Source, typename enable_if<StringTraits<Source>::should_duplicate>::type> {
+  template <typename Destination>
+  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;
+  }
+};
+
+// const char*, const signed char*, const unsigned char*
+template <typename Char>
+struct ValueSaver<
+    Char*, typename enable_if<!StringTraits<Char*>::should_duplicate>::type> {
+  template <typename Destination>
+  static bool save(JsonBuffer*, Destination& dest, Char* source) {
+    dest = reinterpret_cast<const char*>(source);
+    return true;
+  }
+};
+}  // namespace Internals
+}  // namespace ArduinoJson

src/ArduinoJson/Data/ValueSetter.hpp

@@ -1,53 +0,0 @@
-// Copyright Benoit Blanchon 2014-2017
-// MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
-
-#pragma once
-
-#include "../JsonBuffer.hpp"
-#include "../JsonVariant.hpp"
-#include "../StringTraits/StringTraits.hpp"
-#include "../TypeTraits/EnableIf.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-
-template <typename TSource, typename Enable = void>
-struct ValueSetter {
-  template <typename TDestination>
-  static bool set(JsonBuffer*, TDestination& destination,
-                  const TSource& source) {
-    destination = source;
-    return true;
-  }
-};
-
-template <typename TSource>
-struct ValueSetter<TSource, typename TypeTraits::EnableIf<StringTraits<
-                                TSource>::should_duplicate>::type> {
-  template <typename TDestination>
-  static bool set(JsonBuffer* buffer, TDestination& destination,
-                  const TSource& source) {
-    const char* copy = buffer->strdup(source);
-    if (!copy) return false;
-    destination = copy;
-    return true;
-  }
-};
-
-template <typename TSource>
-struct ValueSetter<TSource, typename TypeTraits::EnableIf<!StringTraits<
-                                TSource>::should_duplicate>::type> {
-  template <typename TDestination>
-  static bool set(JsonBuffer*, TDestination& destination,
-                  const TSource& source) {
-    // unsigned char* -> char*
-    destination = reinterpret_cast<const char*>(source);
-    return true;
-  }
-};
-}
-}

src/ArduinoJson/Deserialization/ArduinoStreamReader.hpp

@@ -0,0 +1,41 @@
+// 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

src/ArduinoJson/Deserialization/CharPointerReader.hpp

@@ -0,0 +1,64 @@
+// 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

src/ArduinoJson/Deserialization/Comments.hpp

@@ -1,64 +0,0 @@
-// Copyright Benoit Blanchon 2014-2017
-// MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
-
-#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;
-    }
-  }
-}
-}
-}

src/ArduinoJson/Deserialization/DeserializationError.hpp

@@ -0,0 +1,83 @@
+// 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

src/ArduinoJson/Deserialization/FlashStringReader.hpp

@@ -0,0 +1,56 @@
+// 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

src/ArduinoJson/Deserialization/IteratorReader.hpp

@@ -0,0 +1,34 @@
+// 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

src/ArduinoJson/Deserialization/JsonParser.hpp

@@ -1,107 +0,0 @@
-// Copyright Benoit Blanchon 2014-2017
-// MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
-
-#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);
-  FORCE_INLINE bool parseAnythingToUnsafe(JsonVariant *destination);
-
-  inline bool parseArrayTo(JsonVariant *destination);
-  inline bool parseObjectTo(JsonVariant *destination);
-  inline bool parseStringTo(JsonVariant *destination);
-
-  static inline bool isInRange(char c, char min, char max) {
-    return min <= c && c <= max;
-  }
-
-  static inline bool isLetterOrNumber(char c) {
-    return isInRange(c, '0', '9') || isInRange(c, 'a', 'z') ||
-           isInRange(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 Internals::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 TypeTraits::EnableIf<!TypeTraits::IsConst<TChar>::value>::type> {
-  typedef typename Internals::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);
-}
-}
-}

src/ArduinoJson/Deserialization/JsonParserImpl.hpp

@@ -1,196 +0,0 @@
-// Copyright Benoit Blanchon 2014-2017
-// MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
-
-#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) {
-  if (_nestingLimit == 0) return false;
-  _nestingLimit--;
-  bool success = parseAnythingToUnsafe(destination);
-  _nestingLimit++;
-  return success;
-}
-
-template <typename TReader, typename TWriter>
-inline bool
-ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingToUnsafe(
-    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() {
-  // 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:
-  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() {
-  // 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:
-  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 TypeTraits::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 (!isLetterOrNumber(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;
-}

src/ArduinoJson/Deserialization/StdStreamReader.hpp

@@ -0,0 +1,40 @@
+// 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

src/ArduinoJson/Deserialization/deserialize.hpp

@@ -0,0 +1,82 @@
+// 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

src/ArduinoJson/DynamicJsonDocument.hpp

@@ -0,0 +1,86 @@
+// 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 = new (&_buffer) JsonObject(&_buffer);
+    if (!object) return JsonObject::invalid();
+    _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 = new (&_buffer) JsonArray(&_buffer);
+    if (!array) return JsonArray::invalid();
+    _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

src/ArduinoJson/Json/EscapeSequence.hpp

@@ -1,16 +1,13 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
 namespace ArduinoJson {
 namespace Internals {
 
-class Encoding {
+class EscapeSequence {
  public:
   // Optimized for code size on a 8-bit AVR
   static char escapeChar(char c) {
@@ -36,5 +33,5 @@ class Encoding {
     return &"\"\"\\\\b\bf\fn\nr\rt\t"[excludeIdenticals ? 4 : 0];
   }
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

src/ArduinoJson/Json/IndentedPrint.hpp

@@ -1,9 +1,6 @@
-// Copyright Benoit Blanchon 2014-2017
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
 // MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
 
 #pragma once
 
@@ -11,7 +8,7 @@ namespace ArduinoJson {
 namespace Internals {
 
 // Decorator on top of Print to allow indented output.
-// This class is used by JsonPrintable::prettyPrintTo() but can also be used
+// This class is used by serializeJsonPretty() but can also be used
 // for your own purpose, like logging.
 template <typename Print>
 class IndentedPrint {
@@ -67,5 +64,5 @@ class IndentedPrint {
   static const int MAX_LEVEL = 15;    // because it's only 4 bits
   static const int MAX_TAB_SIZE = 7;  // because it's only 3 bits
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

src/ArduinoJson/Json/JsonDeserializer.hpp

@@ -0,0 +1,318 @@
+// 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 = new (_buffer) JsonArray(_buffer);
+    if (!array) 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 = new (_buffer) JsonObject(_buffer);
+    if (!object) 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 = parseString(&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) {
+    bool hasQuotes = isQuote(current());
+    const char *value;
+    DeserializationError error = parseString(&value);
+    if (error) return error;
+    if (hasQuotes) {
+      variant = value;
+    } else {
+      variant = RawJson(value);
+    }
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError parseString(const char **result) {
+    typename remove_reference<TStringStorage>::type::String str =
+        _stringStorage.startString();
+
+    char c = current();
+    if (c == '\0') return DeserializationError::IncompleteInput;
+
+    if (isQuote(c)) {  // quotes
+      move();
+      char stopChar = c;
+      for (;;) {
+        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);
+      }
+    } else 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;
+  }
+
+  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
+
+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