Set version to 6.11.0

Removed `JsonObject::is<T>(k)` and `JsonObject::set(k,v)`
Replaced `T JsonArray::get<T>(i)` with `JsonVariant JsonArray::get(i)`
Replaced `T JsonObject::get<T>(k)` with `JsonVariant JsonObject::get(k)`

.clang-format

@@ -0,0 +1,5 @@
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+
+BasedOnStyle: Google
+Standard: Cpp03
+AllowShortFunctionsOnASingleLine: Empty

.gitattributes

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

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,14 @@
+<!--
+Before opening an issue, please read the FAQ:
+https://arduinojson.org/faq/
+
+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!
+-->

.gitignore

@@ -0,0 +1,12 @@
+.DS_Store
+/.idea
+/build
+/bin
+/lib
+/sftp-config.json
+.tags
+.tags_sorted_by_file
+/fuzzing/*_fuzzer
+/fuzzing/*_fuzzer.options
+/fuzzing/*_fuzzer_seed_corpus.zip
+.vs/

.mbedignore

@@ -0,0 +1,6 @@
+.github/
+examples/
+fuzzing/
+scripts/
+test/
+third-party/

.travis.yml

@@ -0,0 +1,132 @@
+sudo: false
+language: cpp
+matrix:
+  include:
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.4']
+      env: SCRIPT=test _CC=gcc-4.4 _CXX=g++-4.4
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.6']
+      env: SCRIPT=test _CC=gcc-4.6 _CXX=g++-4.6
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.7']
+      env: SCRIPT=test _CC=gcc-4.7 _CXX=g++-4.7
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.8']
+      env: SCRIPT=test _CC=gcc-4.8 _CXX=g++-4.8 SANITIZE=address
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.9']
+      env: SCRIPT=test _CC=gcc-4.9 _CXX=g++-4.9 SANITIZE=leak
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-5']
+      env: SCRIPT=test _CC=gcc-5 _CXX=g++-5 # SANITIZE=undefined
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-6']
+      env: SCRIPT=test _CC=gcc-6 _CXX=g++-6
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7']
+      env: SCRIPT=test _CC=gcc-7 _CXX=g++-7
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-8']
+      env: SCRIPT=test _CC=gcc-8 _CXX=g++-8
+    - addons:
+        apt:
+          packages: ['g++-arm-linux-gnueabihf']
+      env: SCRIPT=build _CC=arm-linux-gnueabihf-gcc _CXX=arm-linux-gnueabihf-g++
+    - env: SCRIPT=test _CC=clang _CXX=clang++
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.5']
+          packages: ['clang-3.5']
+      env: SCRIPT=test _CC=clang-3.5 _CXX=clang++-3.5 SANITIZE=address
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.6']
+          packages: ['clang-3.6']
+      env: SCRIPT=test _CC=clang-3.6 _CXX=clang++-3.6 SANITIZE=leak
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.7']
+          packages: ['clang-3.7']
+      env: SCRIPT=test _CC=clang-3.7 _CXX=clang++-3.7
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
+          packages: ['clang-3.8']
+      env: SCRIPT=test _CC=clang-3.8 _CXX=clang++-3.8 SANITIZE=undefined
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-3.9']
+          packages: ['clang-3.9']
+      env: SCRIPT=test _CC=clang-3.9 _CXX=clang++-3.9
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-4.0']
+          packages: ['clang-4.0']
+      env: SCRIPT=test _CC=clang-4.0 _CXX=clang++-4.0
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-5.0']
+          packages: ['clang-5.0']
+      env: SCRIPT=test _CC=clang-5.0 _CXX=clang++-5.0
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-6.0']
+          packages: ['clang-6.0']
+      env: SCRIPT=test _CC=clang-6.0 _CXX=clang++-6.0
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-7']
+          packages: ['clang-7']
+      env: SCRIPT=test _CC=clang-7 _CXX=clang++-7
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-8']
+          packages: ['clang-8']
+      env: SCRIPT=test _CC=clang-8 _CXX=clang++-8
+    - env: SCRIPT=coverage
+    - os: osx
+      osx_image: xcode7.3
+      env: SCRIPT=test
+    - os: osx
+      osx_image: xcode8.3
+      env: SCRIPT=test
+    - os: osx
+      osx_image: xcode9.4
+      env: SCRIPT=test
+    - os: osx
+      osx_image: xcode10
+      env: SCRIPT=test SANITIZE=address
+    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
+    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:samd:mkr1000
+    - env: SCRIPT=platformio BOARD=uno
+    - env: SCRIPT=platformio BOARD=esp01
+    - 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"
+    - "fuzzing/json_corpus"
+    - "fuzzing/msgpack_corpus"
+script: scripts/travis/$SCRIPT.sh

ArduinoJson.h

@@ -0,0 +1,5 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include "src/ArduinoJson.h"

CHANGELOG.md

@@ -1,13 +1,821 @@
-ArduinoJsonParser change log
-============================
+ArduinoJson: change log
+=======================
 
-v1.1
-----
+v6.11.0 (2019-05-26)
+-------
 
-* Example: changed `char* json` into `char json[]` so that the byes are not write protected
-* Fixed parsing bug when the JSON contains multi-dimensional arrays
+* Fixed `deserializeJson()` silently accepting a `Stream*` (issue #978)
+* Fixed invalid result from `operator|` (issue #981)
+* Made `deserializeJson()` more picky about trailing characters (issue #980)
+* Added `ARDUINOJSON_ENABLE_NAN` (default=0) to enable NaN in JSON (issue #973)
+* Added `ARDUINOJSON_ENABLE_INFINITY` (default=0) to enable Infinity in JSON
+* Removed implicit conversion in comparison operators (issue #998)
+* Added lexicographical comparison for `JsonVariant`
+* Added support for `nullptr` (issue #998)
 
-v1.0 
-----
+> ### BREAKING CHANGES
+> 
+> #### NaN and Infinity
+> 
+> The JSON specification allows neither NaN not Infinity, but previous
+> versions of ArduinoJson supported it. Now, ArduinoJson behaves like most
+> other libraries: a NaN or and Infinity in the `JsonDocument`, becomes
+> a `null` in the output JSON. Also, `deserializeJson()` returns
+> `InvalidInput` if the JSON document contains NaN or Infinity.
+> 
+> This version still supports NaN and Infinity in JSON documents, but
+> it's disabled by default to be compatible with other JSON parsers.
+> If you need the old behavior back, define `ARDUINOJSON_ENABLE_NAN` and
+> `ARDUINOJSON_ENABLE_INFINITY` to `1`;:
+> 
+> ```c++
+> #define ARDUINOJSON_ENABLE_NAN 1
+> #define ARDUINOJSON_ENABLE_INFINITY 1
+> #include <ArduinoJson.h>
+> ```
+> 
+> #### The "or" operator
+> 
+> This version slightly changes the behavior of the | operator when the 
+> variant contains a float and the user requests an integer.
+>
+> Older versions returned the floating point value truncated.
+> Now, it returns the default value.
+> 
+> ```c++
+> // suppose variant contains 1.2
+> int value = variant | 3;
+> 
+> // old behavior:
+> value == 1
+> 
+> // new behavior
+> value == 3
+> ```
+> 
+> If you need the old behavior, you must add `if (variant.is<float>())`.
 
-Initial release
+v6.10.1 (2019-04-23)
+-------
+
+* Fixed error "attributes are not allowed on a function-definition"
+* Fixed `deserializeJson()` not being picky enough (issue #969)
+* Fixed error "no matching function for call to write(uint8_t)" (issue #972)
+
+v6.10.0 (2019-03-22)
+-------
+
+* Fixed an integer overflow in the JSON deserializer
+* Added overflow handling in `JsonVariant::as<T>()` and `JsonVariant::is<T>()`.
+   - `as<T>()` returns `0` if the integer `T` overflows
+   - `is<T>()` returns `false` if the integer `T` overflows
+* Added `BasicJsonDocument` to support custom allocator (issue #876)
+* Added `JsonDocument::containsKey()` (issue #938)
+* Added `JsonVariant::containsKey()`
+
+v6.9.1 (2019-03-01)
+------
+
+* Fixed warning "unused variable" with GCC 4.4 (issue #912)
+* Fixed warning "cast  increases required alignment" (issue #914)
+* Fixed warning "conversion may alter value" (issue #914)
+* Fixed naming conflict with "CAPACITY" (issue #839)
+* Muted warning "will change in GCC 7.1" (issue #914)
+* Added a clear error message for `StaticJsonBuffer` and `DynamicJsonBuffer`
+* Marked ArduinoJson.h  as a "system header"
+
+v6.9.0 (2019-02-26)
+------
+
+* Decode escaped Unicode characters like \u00DE (issue #304, PR #791)
+  Many thanks to Daniel Schulte (aka @trilader) who implemented this feature.
+* Added option ARDUINOJSON_DECODE_UNICODE to enable it
+* Converted `JsonArray::copyFrom()/copyTo()` to free functions `copyArray()`
+* Renamed `JsonArray::copyFrom()` and `JsonObject::copyFrom()` to `set()`
+* Renamed `JsonArray::get()` to `getElement()`
+* Renamed `JsonArray::add()` (without arg) to `addElement()`
+* Renamed `JsonObject::get()` to `getMember()`
+* Renamed `JsonObject::getOrCreate()` to `getOrAddMember()`
+* Fixed `JsonVariant::isNull()` not returning `true` after `set((char*)0)`
+* Fixed segfault after `variant.set(serialized((char*)0))`
+* Detect `IncompleteInput` in `false`, `true`, and `null`
+* Added `JsonDocument::size()`
+* Added `JsonDocument::remove()`
+* Added `JsonVariant::clear()`
+* Added `JsonVariant::remove()`
+
+v6.8.0-beta (2019-01-30)
+-----------
+
+* Import functions in the ArduinoJson namespace to get clearer errors
+* Improved syntax highlighting in Arduino IDE
+* Removed default capacity of `DynamicJsonDocument`
+* `JsonArray::copyFrom()` accepts `JsonArrayConst`
+* `JsonVariant::set()` accepts `JsonArrayConst` and `JsonObjectConst`
+* `JsonDocument` was missing in the ArduinoJson namespace
+* Added `memoryUsage()` to `JsonArray`, `JsonObject`, and `JsonVariant`
+* Added `nesting()` to `JsonArray`, `JsonDocument`, `JsonObject`, and `JsonVariant`
+* Replaced `JsonDocument::nestingLimit` with an additional parameter
+  to `deserializeJson()` and `deserializeMsgPack()`
+* Fixed uninitialized variant in `JsonDocument`
+* Fixed `StaticJsonDocument` copy constructor and copy assignment
+* The copy constructor of `DynamicJsonDocument` chooses the capacity according to the memory usage of the source, not from the capacity of the source.
+* Added the ability to create/assign a `StaticJsonDocument`/`DynamicJsonDocument` from a `JsonArray`/`JsonObject`/`JsonVariant`
+* Added `JsonDocument::isNull()`
+* Added `JsonDocument::operator[]`
+* Added `ARDUINOJSON_TAB` to configure the indentation character
+* Reduced the size of the pretty JSON serializer
+* Added `add()`, `createNestedArray()` and `createNestedObject()` to `JsonVariant`
+* `JsonVariant` automatically promotes to `JsonObject` or `JsonArray` on write.
+  Calling `JsonVariant::to<T>()` is not required anymore.
+* `JsonDocument` now support the same operations as `JsonVariant`.
+  Calling `JsonDocument::as<T>()` is not required anymore.
+* Fixed example `JsonHttpClient.ino`
+* User can now use a `JsonString` as a key or a value
+
+> ### BREAKING CHANGES
+> 
+> #### `DynamicJsonDocument`'s constructor
+> 
+> The parameter to the constructor of `DynamicJsonDocument` is now mandatory
+>
+> Old code:
+>
+> ```c++
+> DynamicJsonDocument doc;
+> ```
+>
+> New code:
+>
+> ```c++
+> DynamicJsonDocument doc(1024);
+> ```
+> 
+> #### Nesting limit
+> 
+> `JsonDocument::nestingLimit` was replaced with a new parameter to `deserializeJson()` and `deserializeMsgPack()`.
+> 
+> Old code:
+> 
+> ```c++
+> doc.nestingLimit = 15;
+> deserializeJson(doc, input);
+> ```
+> 
+> New code: 
+> 
+> ```c++
+> deserializeJson(doc, input, DeserializationOption::NestingLimit(15));
+> ```
+
+v6.7.0-beta (2018-12-07)
+-----------
+
+* Removed the automatic expansion of `DynamicJsonDocument`, it now has a fixed capacity.
+* Restored the monotonic allocator because the code was getting too big
+* Reduced the memory usage
+* Reduced the code size
+* Renamed `JsonKey` to `JsonString`
+* Removed spurious files in the Particle library
+
+v6.6.0-beta (2018-11-13)
+-----------
+
+* Removed `JsonArray::is<T>(i)` and `JsonArray::set(i,v)`
+* Removed `JsonObject::is<T>(k)` and `JsonObject::set(k,v)`
+* Replaced `T JsonArray::get<T>(i)` with `JsonVariant JsonArray::get(i)`
+* Replaced `T JsonObject::get<T>(k)` with `JsonVariant JsonObject::get(k)`
+* Added `JSON_STRING_SIZE()`
+* ~~Replacing or removing a value now releases the memory~~
+* Added `DeserializationError::code()` to be used in switch statements (issue #846)
+
+v6.5.0-beta (2018-10-13)
+-----------
+
+* Added implicit conversion from `JsonArray` and `JsonObject` to `JsonVariant`
+* Allow mixed configuration in compilation units (issue #809)
+* Fixed object keys not being duplicated
+* `JsonPair::key()` now returns a `JsonKey`
+* Increased the default capacity of `DynamicJsonDocument`
+* Fixed `JsonVariant::is<String>()` (closes #763)
+* Added `JsonArrayConst`, `JsonObjectConst`, and `JsonVariantConst`
+* Added copy-constructor and copy-assignment-operator for `JsonDocument` (issue #827)
+
+v6.4.0-beta (2018-09-11)
+-----------
+
+* Copy `JsonArray` and `JsonObject`, instead of storing pointers (issue #780)
+* Added `JsonVariant::to<JsonArray>()` and `JsonVariant::to<JsonObject>()`
+
+v6.3.0-beta (2018-08-31)
+-----------
+
+* Implemented reference semantics for `JsonVariant`
+* Replaced `JsonPair`'s `key` and `value` with `key()` and `value()`
+* Fixed `serializeJson(obj[key], dst)` (issue #794)
+
+> ### BREAKING CHANGES
+>
+> #### JsonVariant
+> 
+> `JsonVariant` now has a semantic similar to `JsonObject` and `JsonArray`.
+> It's a reference to a value stored in the `JsonDocument`.
+> As a consequence, a `JsonVariant` cannot be used as a standalone variable anymore.
+>
+> Old code:
+>
+> ```c++
+> JsonVariant myValue = 42;
+> ```
+>
+> New code:
+>
+> ```c++
+> DynamicJsonDocument doc;
+> JsonVariant myValue = doc.to<JsonVariant>();
+> myValue.set(42);
+> ```
+>
+> #### JsonPair
+>
+> Old code:
+>
+> ```c++
+> for(JsonPair p : myObject) {
+>   Serial.println(p.key);
+>   Serial.println(p.value.as<int>());
+> }
+> ```
+>
+> New code:
+>
+> ```c++
+> for(JsonPair p : myObject) {
+>   Serial.println(p.key());
+>   Serial.println(p.value().as<int>());
+> }
+> ```
+>
+> CAUTION: the key is now read only!
+
+v6.2.3-beta (2018-07-19)
+-----------
+
+* Fixed exception when using Flash strings as object keys (issue #784)
+
+v6.2.2-beta (2018-07-18)
+-----------
+
+* Fixed `invalid application of 'sizeof' to incomplete type '__FlashStringHelper'` (issue #783)
+* Fixed `char[]` not duplicated when passed to `JsonVariant::operator[]`
+
+v6.2.1-beta (2018-07-17)
+-----------
+
+* Fixed `JsonObject` not inserting keys of type `String` (issue #782)
+
+v6.2.0-beta (2018-07-12)
+-----------
+
+* Disabled lazy number deserialization (issue #772)
+* Fixed `JsonVariant::is<int>()` that returned true for empty strings
+* Improved float serialization when `-fsingle-precision-constant` is used
+* Renamed function `RawJson()` to `serialized()`
+* `serializeMsgPack()` now supports values marked with `serialized()`
+
+> ### BREAKING CHANGES
+>
+> #### Non quoted strings
+>
+> Non quoted strings are now forbidden in values, but they are still allowed in keys.
+> For example, `{key:"value"}` is accepted, but `{key:value}` is not.
+>
+> #### Preformatted values
+>
+> Old code:
+>
+> ```c++
+> object["values"] = RawJson("[1,2,3,4]");
+> ```
+> 
+> New code:
+> 
+> ```c++
+> object["values"] = serialized("[1,2,3,4]");
+> ```
+
+v6.1.0-beta (2018-07-02)
+-----------
+
+* Return `JsonArray` and `JsonObject` by value instead of reference (issue #309)
+* Replaced `success()` with `isNull()`
+
+> ### BREAKING CHANGES
+> 
+> Old code:
+>
+> ```c++
+> JsonObject& obj = doc.to<JsonObject>();
+> JsonArray& arr = obj.createNestedArray("key");
+> if (!arr.success()) {
+>   Serial.println("Not enough memory");
+>   return;
+> }
+> ```
+> 
+> New code:
+> 
+> ```c++
+> JsonObject obj = doc.to<JsonObject>();
+> JsonArray arr = obj.createNestedArray("key");
+> if (arr.isNull()) {
+>   Serial.println("Not enough memory");
+>   return;
+> }
+> ```
+
+v6.0.1-beta (2018-06-11)
+-----------
+
+* Fixed conflicts with `isnan()` and `isinf()` macros (issue #752)
+
+v6.0.0-beta (2018-06-07)
+-----------
+
+* 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
+------
+
+* Added `JsonArray::remove(iterator)` (issue #479)
+* Added `JsonObject::remove(iterator)`
+* Renamed `JsonArray::removeAt(size_t)` into `remove(size_t)`
+* Renamed folder `include/` to `src/`
+* Fixed warnings `floating constant exceeds range of float`and `floating constant truncated to zero` (issue #483)
+* Removed `Print` class and converted `printTo()` to a template method (issue #276)
+* Removed example `IndentedPrintExample.ino`
+* Now compatible with Particle 0.6.1, thanks to Jacob Nite (issue #294 and PR #461 by @foodbag)
+
+v5.8.4
+------
+
+* Added custom implementation of `strtod()` (issue #453)
+* Added custom implementation of `strtol()` (issue #465)
+* `char` is now treated as an integral type (issue #337, #370)
+
+v5.8.3
+------
+
+* Fixed an access violation in `DynamicJsonBuffer` when memory allocation fails (issue #433)
+* Added operators `==` and `!=` for two `JsonVariant`s (issue #436)
+* Fixed `JsonVariant::operator[const FlashStringHelper*]` (issue #441)
+
+v5.8.2
+------
+
+* Fixed parsing of comments (issue #421)
+* Fixed ignored `Stream` timeout (issue #422)
+* Made sure we don't read more that necessary (issue #422)
+* Fixed error when the key of a `JsonObject` is a `char[]` (issue #423)
+* Reduced code size when using `const` references
+* Fixed error with string of type `unsigned char*` (issue #428)
+* Added `deprecated` attribute on `asArray()`, `asObject()` and `asString()` (issue #420)
+
+v5.8.1
+------
+
+* Fixed error when assigning a `volatile int` to a `JsonVariant` (issue #415)
+* Fixed errors with Variable Length Arrays (issue #416)
+* Fixed error when both `ARDUINOJSON_ENABLE_STD_STREAM` and `ARDUINOJSON_ENABLE_ARDUINO_STREAM` are set to `1`
+* Fixed error "Stream does not name a type" (issue #412)
+
+v5.8.0
+------
+
+* Added operator `==` to compare `JsonVariant` and strings (issue #402)
+* Added support for `Stream` (issue #300)
+* Reduced memory consumption by not duplicating spaces and comments
+
+> ### 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
+------
+
+* Added an `printTo(char[N])` and `prettyPrintTo(char[N])` (issue #292)
+* Added ability to set a nested value like this: `root["A"]["B"] = "C"` (issue #352)
+* Renamed `*.ipp` to `*Impl.hpp` because they were ignored by Arduino IDE (issue #396)
+
+v5.7.2
+------
+
+* Made PROGMEM available on more platforms (issue #381)
+* Fixed PROGMEM causing an exception on ESP8266 (issue #383)
+
+v5.7.1
+------
+
+* Added support for PROGMEM (issue #76)
+* Fixed compilation error when index is not an `int` (issue #381)
+
+v5.7.0
+------
+
+* Templatized all functions using `String` or `std::string`
+* Removed `ArduinoJson::String`
+* Removed `JsonVariant::defaultValue<T>()`
+* Removed non-template `JsonObject::get()` and `JsonArray.get()`
+* Fixed support for `StringSumHelper` (issue #184)
+* Replaced `ARDUINOJSON_USE_ARDUINO_STRING` by `ARDUINOJSON_ENABLE_STD_STRING` and `ARDUINOJSON_ENABLE_ARDUINO_STRING` (issue #378)
+* 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 :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
+------
+
+* Fixed `array[idx].as<JsonVariant>()` and `object[key].as<JsonVariant>()`
+* Fixed return value of `JsonObject::set()` (issue #350)
+* Fixed undefined behavior in `Prettyfier` and `Print` (issue #354)
+* Fixed parser that incorrectly rejected floats containing a `+` (issue #349)
+
+v5.6.6
+------
+
+* Fixed `-Wparentheses` warning introduced in v5.6.5 (PR #335 by @nuket)
+* Added `.mbedignore` for ARM mbdeb (PR #334 by @nuket)
+* Fixed  `JsonVariant::success()` which didn't propagate `JsonArray::success()` nor `JsonObject::success()` (issue #342).
+
+v5.6.5
+------
+
+* `as<char*>()` now returns `true` when input is `null` (issue #330)
+
+v5.6.4
+------
+
+* Fixed error in float serialization (issue #324)
+
+v5.6.3
+------
+
+* Improved speed of float serialization (about twice faster)
+* Added `as<JsonArray>()` as a synonym for `as<JsonArray&>()`... (issue #291)
+* Fixed `call of overloaded isinf(double&) is ambiguous` (issue #284)
+
+v5.6.2
+------
+
+* Fixed build when another lib does `#undef isnan` (issue #284)
+
+v5.6.1
+------
+
+* Added missing `#pragma once` (issue #310)
+
+v5.6.0
+------
+
+* ArduinoJson is now a header-only library (issue #199)
+
+v5.5.1
+------
+
+* Fixed compilation error with Intel Galileo (issue #299)
+
+v5.5.0
+------
+
+* Added `JsonVariant::success()` (issue #279)
+* Renamed `JsonVariant::invalid<T>()` to `JsonVariant::defaultValue<T>()`
+
+v5.4.0
+------
+
+* Changed `::String` to `ArduinoJson::String` (issue #275)
+* Changed `::Print` to `ArduinoJson::Print` too
+
+v5.3.0
+------
+
+* Added custom implementation of `ftoa` (issues #266, #267, #269 and #270)
+* Added `JsonVariant JsonBuffer::parse()` (issue #265)
+* Fixed `unsigned long` printed as `signed long` (issue #170)
+
+v5.2.0
+------
+
+* Added `JsonVariant::as<char*>()` as a synonym for `JsonVariant::as<const char*>()` (issue #257)
+* Added example `JsonHttpClient` (issue #256)
+* Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254)
+* Added `RawJson()` to insert pregenerated JSON portions (issue #259)
+
+v5.1.1
+------
+
+* Removed `String` duplication when one replaces a value in a `JsonObject` (PR #232 by @ulion)
+
+v5.1.0
+------
+
+* Added support of `long long` (issue #171)
+* Moved all build settings to `ArduinoJson/Configuration.hpp`
+
+> ### BREAKING CHANGE :warning:
+>
+> If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
+
+v5.0.8
+------
+
+* Made the library compatible with [PlatformIO](http://platformio.org/) (issue #181)
+* Fixed `JsonVariant::is<bool>()` that was incorrectly returning false (issue #214)
+
+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 :warning:
+>
+> - `JsonVariant(true).as<String>()` now returns `"true"` instead of `"1"`
+> - `JsonVariant(false).as<String>()` now returns `"false"` instead of `"0"`
+
+v5.0.6
+------
+
+* Added parameter to `DynamicJsonBuffer` constructor to set initial size (issue #152)
+* Fixed warning about library category in Arduino 1.6.6 (issue #147)
+* Examples: Added a loop to wait for serial port to be ready (issue #156)
+
+v5.0.5
+------
+
+* Added overload `JsonObjectSuscript::set(value, decimals)` (issue #143)
+* Use `float` instead of `double` to reduce the size of `JsonVariant` (issue #134)
+
+v5.0.4
+------
+
+* Fixed ambiguous overload with `JsonArraySubscript` and `JsonObjectSubscript` (issue #122)
+
+v5.0.3
+------
+
+* Fixed `printTo(String)` which wrote numbers instead of strings (issue #120)
+* Fixed return type of `JsonArray::is<T>()` and some others (issue #121)
+
+v5.0.2
+------
+
+* Fixed segmentation fault in `parseObject(String)` and `parseArray(String)`, when the
+  `StaticJsonBuffer` is too small to hold a copy of the string
+* Fixed Clang warning "register specifier is deprecated" (issue #102)
+* Fixed GCC warning "declaration shadows a member" (issue #103)
+* Fixed memory alignment, which made ESP8266 crash (issue #104)
+* Fixed compilation on Visual Studio 2010 and 2012 (issue #107)
+
+v5.0.1
+------
+
+* Fixed compilation with Arduino 1.0.6 (issue #99)
+
+v5.0.0
+------
+
+* Added support of `String` class (issues #55, #56, #70, #77)
+* Added `JsonBuffer::strdup()` to make a copy of a string (issues #10, #57)
+* Implicitly call `strdup()` for `String` but not for `char*` (issues #84, #87)
+* Added support of non standard JSON input (issue #44)
+* Added support of comments in JSON input (issue #88)
+* Added implicit cast between numerical types (issues #64, #69, #93)
+* Added ability to read number values as string (issue #90)
+* Redesigned `JsonVariant` to leverage converting constructors instead of assignment operators (issue #66)
+* Switched to new the library layout (requires Arduino 1.0.6 or above)
+
+> ### BREAKING CHANGES :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.
+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!

CMakeLists.txt

@@ -0,0 +1,22 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2019
+# MIT License
+
+cmake_minimum_required(VERSION 3.0)
+project(ArduinoJson)
+
+enable_testing()
+
+add_definitions(-DARDUINOJSON_DEBUG)
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+	add_compile_options(-g -O0)
+endif()
+
+if(${COVERAGE})
+	set(CMAKE_CXX_FLAGS "-fprofile-arcs -ftest-coverage")
+endif()
+
+include_directories(${CMAKE_CURRENT_LIST_DIR}/src)
+add_subdirectory(third-party/catch)
+add_subdirectory(test)
+add_subdirectory(fuzzing)

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)

JsonArray.cpp

@@ -1,67 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-JsonArray::JsonArray(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (tokens == 0 || tokens[0].type != JSMN_ARRAY)
-		makeInvalid();
-}
-
-
-/*
-* Returns the token for the value at the specified index
-*/
-jsmntok_t* JsonArray::getToken(int index)
-{
-	// sanity check
-	if (json == 0 || tokens == 0 || index < 0 || index >= tokens[0].size)
-		return 0;
-
-	// skip first token, it's the whole object
-	jsmntok_t* currentToken = tokens + 1;
-
-	// skip all tokens before the specified index
-	for (int i = 0; i < index; i++)
-	{
-		// move forward: current + nested tokens
-		currentToken += 1 + getNestedTokenCount(currentToken);
-	}
-
-	return currentToken;
-}
-
-JsonArray JsonArray::getArray(int index)
-{
-	return JsonArray(json, getToken(index));
-}
-
-bool JsonArray::getBool(int index)
-{
-	return getBoolFromToken(getToken(index));
-}
-
-double JsonArray::getDouble(int index)
-{
-	return getDoubleFromToken(getToken(index));
-}
-
-JsonHashTable JsonArray::getHashTable(int index)
-{
-	return JsonHashTable(json, getToken(index));
-}
-
-long JsonArray::getLong(int index)
-{
-	return getLongFromToken(getToken(index));
-}
-
-char* JsonArray::getString(int index)
-{
-	return getStringFromToken(getToken(index));
-}

JsonArray.h

@@ -1,42 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014 - MIT License
- */
-
-#ifndef __JSONARRAY_H
-#define __JSONARRAY_H
-
-#include "JsonObjectBase.h"
-
-class JsonHashTable;
-
-class JsonArray : public JsonObjectBase
-{
-	template <int N>
-	friend class JsonParser;
-
-	friend class JsonHashTable;
-
-public:
-
-	JsonArray()	{}
-
-	int getLength()
-	{
-		return tokens != 0 ? tokens[0].size : 0;
-	}
-
-	JsonArray getArray(int index);
-	bool getBool(int index);
-	double getDouble(int index);
-	JsonHashTable getHashTable(int index);
-	long getLong(int index);
-	char* getString(int index);
-
-private:
-
-	JsonArray(char* json, jsmntok_t* tokens);
-	jsmntok_t* getToken(int index);
-};
-
-#endif

JsonHashTable.cpp

@@ -1,84 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-#include <string.h> // for strcmp()
-
-JsonHashTable::JsonHashTable(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (tokens == 0 || tokens[0].type != JSMN_OBJECT)
-		makeInvalid();
-}
-
-/*
-* Returns the token for the value associated with the specified key
-*/
-jsmntok_t* JsonHashTable::getToken(const char* desiredKey)
-{	
-	// sanity check
-	if (json == 0 || tokens == 0 || desiredKey == 0)
-		return 0;
-
-	// skip first token, it's the whole object
-	jsmntok_t* currentToken = tokens + 1;
-
-	// scan each keys
-	for (int i = 0; i < tokens[0].size / 2 ; i++)
-	{
-		// get key token string
-		char* key = getStringFromToken(currentToken);
-
-		// compare with desired name
-		if (strcmp(desiredKey, key) == 0)
-		{
-			// return the value token that follows the key token
-			return currentToken + 1;
-		}
-
-		// move forward: key + value + nested tokens
-		currentToken += 2 + getNestedTokenCount(currentToken + 1);
-	}
-
-	// nothing found, return NULL
-	return 0; 
-}
-
-bool JsonHashTable::containsKey(const char* key)
-{
-	return getToken(key) != 0;
-}
-
-JsonArray JsonHashTable::getArray(const char* key)
-{
-	return JsonArray(json, getToken(key));
-}
-
-bool JsonHashTable::getBool(const char* key)
-{
-	return getBoolFromToken(getToken(key));
-}
-
-double JsonHashTable::getDouble(const char* key)
-{
-	return getDoubleFromToken(getToken(key));
-}
-
-JsonHashTable JsonHashTable::getHashTable(const char* key)
-{
-	return JsonHashTable(json, getToken(key));
-}
-
-long JsonHashTable::getLong(const char* key)
-{
-	return getLongFromToken(getToken(key));
-}
-
-char* JsonHashTable::getString(const char* key)
-{
-	return getStringFromToken(getToken(key));
-}

JsonHashTable.h

@@ -1,39 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#ifndef __JSONHASHTABLE_H
-#define __JSONHASHTABLE_H
-
-#include "JsonObjectBase.h"
-
-class JsonArray;
-
-class JsonHashTable : public JsonObjectBase
-{
-	template <int N>
-	friend class JsonParser;
-
-	friend class JsonArray;
-
-public:
-
-	JsonHashTable() {}
-
-	bool containsKey(const char* key);
-
-	JsonArray getArray(const char* key);
-	bool getBool(const char* key);
-	double getDouble(const char* key);
-	JsonHashTable getHashTable(const char* key);
-	long getLong(const char* key);
-	char* getString(const char* key);
-
-private:
-
-	JsonHashTable(char* json, jsmntok_t* tokens);
-	jsmntok_t* getToken(const char* key);
-};
-
-#endif

JsonObjectBase.cpp

@@ -1,67 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014
- * MIT License
- */
-
-#include "JsonObjectBase.h"
-
-#include <stdlib.h> // for strtol, strtod
-
-int JsonObjectBase::getNestedTokenCount(jsmntok_t* token)
-{
-	int end = token->end;
-	int count = 0;	
-
-	token++;
-
-	while (token->start < end)
-	{
-		token++;
-		count++;
-	}
-
-	return count;
-}
-
-bool JsonObjectBase::getBoolFromToken(jsmntok_t* token)
-{
-	if (token->type != JSMN_PRIMITIVE) return 0;
-
-	// "true"
-	if (json[token->start] == 't') return true;
-
-	// "false"
-	if (json[token->start] == 'f') return false;
-
-	// "null"
-	if (json[token->start] == 'n') return false;
-	
-	// number
-	return strtol(json + token->start, 0, 0) != 0;
-}
-
-double JsonObjectBase::getDoubleFromToken(jsmntok_t* token)
-{
-	if (token == 0 || token->type != JSMN_PRIMITIVE) return 0;
-
-	return strtod(json + token->start, 0);
-}
-
-long JsonObjectBase::getLongFromToken(jsmntok_t* token)
-{
-	if (token == 0 || token->type != JSMN_PRIMITIVE) return 0;
-
-	return strtol(json + token->start, 0, 0);
-}
-
-char* JsonObjectBase::getStringFromToken(jsmntok_t* token)
-{
-	if (token == 0 || token->type != JSMN_PRIMITIVE && token->type != JSMN_STRING)
-		return 0;
-
-	// add null terminator to the string
-	json[token->end] = 0;
-
-	return json + token->start;
-}

JsonObjectBase.h

@@ -1,52 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014
- * MIT License
- */
-
-#ifndef __JSONOBJECTBASE_H
-#define __JSONOBJECTBASE_H
-
-#include "utility/jsmn.h"
-
-class JsonObjectBase
-{
-public:
-
-	JsonObjectBase()
-	{
-		makeInvalid();
-	}
-
-	bool success() 
-	{ 
-		return json != 0 && tokens != 0;
-	}
-
-protected:
-	
-	JsonObjectBase(char* json, jsmntok_t* tokens)
-	{
-		this->json = json;
-		this->tokens = tokens;
-	}
-		
-	void makeInvalid()
-	{
-		json = 0;
-		tokens = 0;
-	}
-	
-	static int getNestedTokenCount(jsmntok_t* token);
-
-	bool getBoolFromToken(jsmntok_t* token);
-	double getDoubleFromToken(jsmntok_t* token);
-	long getLongFromToken(jsmntok_t* token);
-	char* getStringFromToken(jsmntok_t* token);
-
-	char* json;
-	jsmntok_t* tokens;
-};
-
-#endif
-

JsonParser.h

@@ -1,69 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#ifndef __JSONPARSER_H
-#define __JSONPARSER_H
-
-#include "JsonHashTable.h"
-#include "JsonArray.h"
-
-/*
-* The JSON parser.
-*
-* You need to specifiy the number of token to be allocated for that parser.
-* Values from 16 to 32 are recommended.
-* The parser size will be MAX_TOKEN*8 bytes.
-* Don't forget that the memory size of standard Arduino board is only 2KB
-*
-* CAUTION: JsonArray and JsonHashTable contain pointers to tokens of the
-* JsonParser, so they need the JsonParser to be in memory to work.
-* As a result, you must not create JsonArray and JsonHashTable that have a 
-* longer life that the JsonParser.
-*/
-template <int MAX_TOKENS>
-class JsonParser
-{
-public:
-
-	/*
-	* Parse the JSON string and return a array.
-	*
-	* The content of the string may be altered to add '\0' at the
-	* end of string tokens
-	*/ 
-	JsonArray parseArray(char* json)
-	{
-		return JsonArray(json, parse(json));
-	}
-
-	/*
-	* Parse the JSON string and return a array.
-	*
-	* The content of the string may be altered to add '\0' at the
-	* end of string tokens
-	*/
-	JsonHashTable parseHashTable(char* json)
-	{
-		return JsonHashTable(json, parse(json));
-	}
-
-private:
-
-	jsmntok_t* parse(char* json)
-	{
-		jsmn_parser parser;
-		jsmn_init(&parser);
-
-		if (JSMN_SUCCESS != jsmn_parse(&parser, json, tokens, MAX_TOKENS))
-			return 0;
-
-		return tokens;
-	}
-
-	jsmntok_t tokens[MAX_TOKENS];
-};
-
-#endif
-

LICENSE.md

@@ -0,0 +1,10 @@
+The MIT License (MIT)
+---------------------
+
+Copyright © 2014-2019 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:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,409 +1,113 @@
-An efficient JSON parser for Arduino
-====================================
+![ArduinoJson](banner.svg)
 
-This library is an thin C++ wrapper around the *jsmn* tokenizer: http://zserge.com/jsmn.html
+---
 
-It's design to be very lightweight, works without any allocation on the heap (no malloc) and supports nested objects.
+[![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=6.11.0)](https://www.ardu-badge.com/ArduinoJson/6.11.0)
+[![Build Status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
+[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=6.x)](https://travis-ci.org/bblanchon/ArduinoJson)
+[![Coverage Status](https://coveralls.io/repos/github/bblanchon/ArduinoJson/badge.svg?branch=6.x)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
+[![Star this project](http://githubbadges.com/star.svg?user=bblanchon&repo=ArduinoJson&style=flat&color=fff&background=007ec6)](https://github.com/bblanchon/ArduinoJson)
 
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library on any other C++ project.
+ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
 
+## Features
 
-Features
---------
+* JSON decoding (comments are supported)
+* JSON encoding (with optional indentation)
+* MessagePack
+* Elegant API, easy to use
+* Fixed memory allocation (zero malloc)
+* No data duplication (zero copy)
+* Portable (written in C++98, can be used in any C++ project)
+* Self-contained (no external dependency)
+* Small footprint
+* 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)
 
-* Based on the well-proven [jsmn](http://zserge.com/jsmn.html) tokenizer
-* Supports nested objects
-* Works with fixed memory allocation : no `malloc()`
-* Low footprint
-* MIT License
+## Compatibility
 
+ArduinoJson works on the following hardware:
 
-Example
--------
+* <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)...
 
-    char json[] = "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}";
+ArduinoJson compiles with zero warning on the following compilers, IDEs, and platforms:
 
-    JsonParser<32> parser;
+* <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/)
 
-    JsonHashTable hashTable = parser.parseHashTable(json);
+## Quickstart
 
-    if (!hashTable.success())
-    {
-        return;
-    }
+### Deserialization
 
-    char* name = hashTable.getString("Name");
+Here is a program that parses a JSON document with ArduinoJson.
 
-    JsonArray skills = hashTable.getArray("Skills");
+```c++
+char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    int age = hashTable.getLong("Age");
+DynamicJsonDocument doc(1024);
+deserializeJson(doc, json);
 
-    bool online = hashTable.getBool("Online");
+const char* sensor = doc["sensor"];
+long time          = doc["time"];
+double latitude    = doc["data"][0];
+double longitude   = doc["data"][1];
+```
 
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
 
+### Serialization
 
-How to  use ?
--------------
+Here is a program that generates a JSON document with ArduinoJson:
 
-### 1. Install the library
+```c++
+DynamicJsonDocument doc(1024);
 
-Download the library and extract it to:
+doc["sensor"] = "gps";
+doc["time"]   = 1351824120;
 
-    <your Arduino Sketch folder>/libraries/ArduinoJsonParser
+JsonArray data = doc.createNestedArray("data");
+data.add(48.756080);
+data.add(2.302038);
 
-### 2. Import in your sketch
+serializeJson(doc, Serial);
+// This prints:
+// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+```
 
-Just add the following line on the top of your `.ino` file:
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme)
 
-    #include <JsonParser.h>
-    
-### 3. Create a parser
+## Documentation
 
-To extract data from the JSON string, you need to create a `JsonParser`, and specify the number of token you allocate for the parser itself:
+The documentation is available on [arduinojson.org](https://arduinojson.org/?utm_source=github&utm_medium=readme), here are some shortcuts:
 
-    JsonParser<32> parser;
-    
-> #### How to choose the number of tokens ?
+* 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!
 
-> A token is an element of the JSON object: either a key, a value, an hash-table or an array.
-> As an example the `char json[]` on the top of this page contains 12 tokens (don't forget to count 1 for the whole object and 1 more for the array itself).
+---
 
-> The more tokens you allocate, the more complex the JSON can be, but also the more memory is occupied.
-> Each token takes 8 bytes, so `sizeof(JsonParser<32>)` is 256 bytes which is quite big in an Arduino with only 2KB of RAM.
-> Don't forget that you also have to store the JSON string in RAM and it's probably big.
+Do you like this library? Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)!
 
-> 32 tokens may seem small, but it's very decent for an 8-bit processor, you wouldn't get better results with other JSON libraries.
-
-### 4. Extract data
-
-To use this library, you need to know beforehand what is the type of data contained in the JSON string, which is very likely.
-
-The root object has to be either a hash-table (like `{"key":"value"}`) or an array (like `[1,2]`). 
-
-The nested objects can be either arrays, booleans, hash-tables, numbers or strings.
-If you need other type, you can get the string value and parse it yourself.
-
-#### Hash-table
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    {
-        "Name":"Blanchon",
-        "Skills":[
-            "C",
-            "C++",
-            "C#"],
-        "Age":32,
-        "Online":true
-    }
-
-In this case the root object of the JSON string is a hash-table, so you need to extract a `JsonHashTable`:
-   
-    JsonHashTable root = parser.parseHashTable(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the member you need:
-    
-    char* name = hashTable.getString("Name");
-
-    JsonArray skills = hashTable.getArray("Skills");
-
-    int age = hashTable.getLong("Age");
-
-    bool online = hashTable.getBool("Online");
-    
-#### Array
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    [
-        [ 1.2, 3.4 ],
-        [ 5.6, 7.8 ]               
-    ]
-
-In this case the root object of the JSON string is an array, so you need to extract a `JsonArray`:
-   
-    JsonArray root = parser.parseArray(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the content by its index in the array:
-    
-    JsonArray row0 = root.getArray(0);
-    double a = row0.getDouble(0);
-    
-or simply:
-
-    double a = root.getArray(0).getDouble(0);
-
-
-Common pitfalls
----------------
-
-### 1. Not enough tokens
-
-By design, the library has no way to tell you why `JsonParser::parseArray()` or `JsonParser::parseHashTable()` failed.
-
-There are basically two reasons why they may fail:
-
-1. the JSON string is invalid
-2. the JSON string contains more tokens that the parser can store
-
-So, if you are sure the JSON string is correct and you still can't parse it, you should slightly increase the number of token of the parser.
-
-### 2. Not enough memory
-
-You may go into unpredictable trouble if you allocate more memory than your processor really has.
-It's a very common issue in embedded development. 
-
-To diagnose this, look at every big objects in you code and sum their size to check that they fit in RAM.
-
-For example, don't do this:
-
-    char json[1024];        // 1 KB
-    JsonParser<64> parser;    // 512 B
-
-because it may be too big for a processor with only 2 KB: you need free memory to store other variables and the call stack.
-
-That is why an 8-bit processor is not able to parse long and complex JSON strings.
-
-### 3. JsonParser not in memory
-
-To reduce the memory consumption, `JsonArray` and `JsonHashTable` contains pointer to the token that are inside the `JsonParser`. This can only work if the `JsonParser` is still in memory.
-
-For example, don't do this:
-
-    JsonArray getArray(char* json)
-    {
-        JsonParser<16> parser;
-        return parser.parseArray(parser); 
-    }
-
-because the local variable `parser` will be *removed* from memory when the function `getArray()` returns, and the pointer inside `JsonArray` will point to an invalid location.
-
-### 4. JSON string is altered
-
-This will probably never be an issue, but you need to be aware of this feature.
-
-When you pass a `char[]` to `JsonParser::parseArray()` or `JsonParser::parseHashTable()`, the content of the string will be altered to add `\0` at the end of the tokens.
-
-This is because we want functions like `JsonArray::getString()` to return a null-terminating string without any memory allocation.
-   
-
-Memory usage
-------------
-
-Here are the size of the main classes of the library.
-
-This table is for an 8-bit Arduino, types would be bigger on a 32-bit processor.
-
-<table>
-    <tr>
-        <th>Type</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>Parser&lt;N&gt;</td>
-        <td>8 x N</td>
-    </tr>
-    <tr>
-        <td>JsonArray</td>
-        <td>4</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable</td>
-        <td>4</td>
-    </tr>
-</table> 
-
-
-Code size
----------
-
-Theses tables has been created by analyzing the map file generated by AVR-GCC after adding `-Wl,-Map,foo.map` to the command line.
-
-As you'll see the code size if between 1680 and 3528 bytes, depending on the features you use.
-
-### Minimum setup
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strcmp(char*,char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>jsmn_init(jsmn_parser*)</td>
-        <td>20</td>
-    </tr>
-    <tr>
-        <td>jsmn_parse(jsmn_parser*, char const*, jsmntok_t*, unsigned int)</td>
-        <td>960</td>
-    </tr>
-    <tr>
-        <td>JsonParser::parse(char*)</td>
-        <td>106</td>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getNestedTokenCount(jsmntok_t*)</td>
-        <td>84</td>        
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getStringFromToken(jsmntok_t*)</td>
-        <td>68</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::JsonArray(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getToken(int)</td>
-        <td>112</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getString(int)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::JsonHashTable(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getToken(char*)</td>
-        <td>180</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getString(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>1680</td>
-    </tr>
-</table>
-
-### Additional space to parse nested  objects
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonArray::getArray(int)</td>
-        <td>42</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getHashTable(int)</td>
-        <td>64</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getArray(char*)</td>
-        <td>64</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::getHashTable(char*)</td>
-        <td>42</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>212</td>
-    </tr>
-</table>
-
-### Additional space to parse `bool` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getBoolFromToken(jsmntok_t*)</td>
-        <td>82</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getBool(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getBool(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>130</td>
-    </tr>
-</table>
-
-### Additional space to parse `double` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtod(char*,int)</td>
-        <td>704</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getDoubleFromToken(jsmntok_t*)</td>
-        <td>44</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getDouble(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getDouble(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>796</td>
-    </tr>
-</table>
-
-### Additional space to parse `long` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtol(char*,char**,int)</td>
-        <td>606</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getLongFromToken(jsmntok_t*)</td>
-        <td>56</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getLong(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getLong(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>710</td>
-    </tr>
-</table>
+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

@@ -0,0 +1,20 @@
+version: 6.11.0.{build}
+environment:
+  matrix:
+  - 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
+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
+- cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
+build_script:
+- cmake --build . --config %CONFIGURATION%
+test_script:
+- ctest -C %CONFIGURATION% --output-on-failure .

examples/JsonConfigFile/JsonConfigFile.ino

@@ -0,0 +1,147 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// 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
+// }
+//
+// https://arduinojson.org/v6/example/config/
+
+#include <ArduinoJson.h>
+#include <SD.h>
+#include <SPI.h>
+
+// Our configuration structure.
+//
+// Never use a JsonDocument to store the configuration!
+// A JsonDocument is *not* a permanent storage; it's only a temporary storage
+// used during the serialization phase. See:
+// https://arduinojson.org/v6/faq/why-must-i-create-a-separate-config-object/
+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 a temporary JsonDocument
+  // Don't forget to change the capacity to match your requirements.
+  // Use arduinojson.org/v6/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"));
+
+  // Copy values from the JsonDocument to the Config
+  config.port = doc["port"] | 2731;
+  strlcpy(config.hostname,                  // <- destination
+          doc["hostname"] | "example.com",  // <- source
+          sizeof(config.hostname));         // <- destination's capacity
+
+  // Close the file (Curiously, 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 a temporary JsonDocument
+  // Don't forget to change the capacity to match your requirements.
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonDocument<256> doc;
+
+  // Set the values in the document
+  doc["hostname"] = config.hostname;
+  doc["port"] = config.port;
+
+  // Serialize JSON to file
+  if (serializeJson(doc, file) == 0) {
+    Serial.println(F("Failed to write to file"));
+  }
+
+  // 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.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
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization or deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a case study of a project that has
+// a complex configuration with nested members.
+// Contrary to this example, the project in the book uses the SPIFFS filesystem.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -0,0 +1,77 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows how to generate a JSON document with ArduinoJson.
+//
+// https://arduinojson.org/v6/example/generator/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  // Initialize Serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Allocate the JSON document
+  //
+  // 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/v6/assistant to compute the capacity.
+  StaticJsonDocument<200> doc;
+
+  // StaticJsonObject allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument  doc(200);
+
+  // Add values in the document
+  //
+  doc["sensor"] = "gps";
+  doc["time"] = 1351824120;
+
+  // Add an array.
+  //
+  JsonArray data = doc.createNestedArray("data");
+  data.add(48.756080);
+  data.add(2.302038);
+
+  // Generate the minified JSON and send it to the Serial port.
+  //
+  serializeJson(doc, Serial);
+  // The above line prints:
+  // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+  // Start a new line
+  Serial.println();
+
+  // Generate the prettified JSON and send it to the Serial port.
+  //
+  serializeJsonPretty(doc, Serial);
+  // The above line prints:
+  // {
+  //   "sensor": "gps",
+  //   "time": 1351824120,
+  //   "data": [
+  //     48.756080,
+  //     2.302038
+  //   ]
+  // }
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like serializing directly to a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonHttpClient/JsonHttpClient.ino

@@ -0,0 +1,116 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// 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
+//   ]
+// }
+//
+// https://arduinojson.org/v6/example/http-client/
+
+#include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>
+
+void setup() {
+  // Initialize Serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize Ethernet library
+  byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+  if (!Ethernet.begin(mac)) {
+    Serial.println(F("Failed to configure Ethernet"));
+    return;
+  }
+  delay(1000);
+
+  Serial.println(F("Connecting..."));
+
+  // Connect to HTTP server
+  EthernetClient client;
+  client.setTimeout(10000);
+  if (!client.connect("arduinojson.org", 80)) {
+    Serial.println(F("Connection failed"));
+    return;
+  }
+
+  Serial.println(F("Connected!"));
+
+  // 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;
+  }
+
+  // Check HTTP status
+  char status[32] = {0};
+  client.readBytesUntil('\r', status, sizeof(status));
+  // It should be "HTTP/1.0 200 OK" or "HTTP/1.1 200 OK"
+  if (strcmp(status + 9, "200 OK") != 0) {
+    Serial.print(F("Unexpected response: "));
+    Serial.println(status);
+    return;
+  }
+
+  // Skip HTTP headers
+  char endOfHeaders[] = "\r\n\r\n";
+  if (!client.find(endOfHeaders)) {
+    Serial.println(F("Invalid response"));
+    return;
+  }
+
+  // Allocate the JSON document
+  // Use arduinojson.org/v6/assistant to compute the capacity.
+  const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
+  DynamicJsonDocument doc(capacity);
+
+  // Parse JSON object
+  DeserializationError error = deserializeJson(doc, client);
+  if (error) {
+    Serial.print(F("deserializeJson() failed: "));
+    Serial.println(error.c_str());
+    return;
+  }
+
+  // Extract values
+  Serial.println(F("Response:"));
+  Serial.println(doc["sensor"].as<char*>());
+  Serial.println(doc["time"].as<long>());
+  Serial.println(doc["data"][0].as<float>(), 6);
+  Serial.println(doc["data"][1].as<float>(), 6);
+
+  // Disconnect
+  client.stop();
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization  problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization
+// showing how to parse the response from GitHub's API. In the last chapter,
+// it shows how to parse the huge documents from OpenWeatherMap
+// and Reddit.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonParserExample/JsonParserExample.ino

@@ -1,94 +1,80 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include <JsonParser.h>
-
-void ParseAnObject()
-{
-    char[] json = "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}";
-
-    JsonParser<32> parser;
-
-    Serial.print("Parse ");
-    Serial.println(json);
-
-    JsonHashTable hashTable = parser.parseHashTable(json);
-
-    if (!hashTable.success())
-    {
-        Serial.println("JsonParser.parseHashTable() failed");
-        return;
-    }
-
-    char* name = hashTable.getString("Name");
-    Serial.print("name=");
-    Serial.println(name);
-
-    JsonArray skills = hashTable.getArray("Skills");
-    Serial.println("skills:");
-    for (int i = 0; i < skills.getLength(); i++)
-    {
-        char* value = skills.getString(i);
-        Serial.print(i);
-        Serial.print(" ");
-        Serial.println(value);
-    }
-
-    int age = hashTable.getLong("Age");
-    Serial.print("age=");
-    Serial.println(age);
-
-    bool online = hashTable.getBool("Online");
-    Serial.print("online=");
-    Serial.println(online);
-}
-
-void ParseAnArray()
-{
-    char[] json = "[[1.2,3.4],[5.6,7.8]]";
-
-    JsonParser<32> parser;
-
-    Serial.print("Parse ");
-    Serial.println(json);
-
-    JsonArray array = parser.parseArray(json);
-
-    if (!array.success())
-    {
-        Serial.println("JsonParser.parseArray() failed");
-        return;
-    }
-
-    for (int i = 0; i < array.getLength(); i++)
-    {
-        Serial.println(i);
-
-        JsonArray innerArray = array.getArray(i);
-
-        for (int j = 0; j < innerArray.getLength(); j++)
-        {
-            double value = innerArray.getDouble(j);
-
-            Serial.print("  ");
-            Serial.print(j);
-            Serial.print("=");
-            Serial.println(value);
-        }
-    }
-}
-
-void setup()
-{
-    Serial.begin(9600);
-
-    ParseAnObject();
-    ParseAnArray();
-}
-
-void loop()
-{
-
-}
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows how to deserialize a JSON document with ArduinoJson.
+//
+// https://arduinojson.org/v6/example/parser/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Allocate the JSON document
+  //
+  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Don't forget to change this value to match your JSON document.
+  // Use arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<200> doc;
+
+  // StaticJsonDocument<N> allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument doc(200);
+
+  // JSON input string.
+  //
+  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
+  // the minimal amount of memory because the JsonDocument stores pointers to
+  // the input buffer.
+  // If you use another type of input, ArduinoJson must copy the strings from
+  // the input to the JsonDocument, so you need to increase the capacity of the
+  // JsonDocument.
+  char json[] =
+      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+
+  // Deserialize the JSON document
+  DeserializationError error = deserializeJson(doc, json);
+
+  // Test if parsing succeeds.
+  if (error) {
+    Serial.print(F("deserializeJson() failed: "));
+    Serial.println(error.c_str());
+    return;
+  }
+
+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do doc["time"].as<long>();
+  const char* sensor = doc["sensor"];
+  long time = doc["time"];
+  double latitude = doc["data"][0];
+  double longitude = doc["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
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like deserializing directly from a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonServer/JsonServer.ino

@@ -0,0 +1,110 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows how to implement an HTTP server that sends a JSON document
+// in the response.
+// It uses the Ethernet library but can be easily adapted for Wifi.
+//
+// The JSON document contains the values of the analog and digital pins.
+// It looks like that:
+// {
+//   "analog": [0, 76, 123, 158, 192, 205],
+//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
+// }
+//
+// https://arduinojson.org/v6/example/http-server/
+
+#include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+EthernetServer server(80);
+
+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;
+  }
+
+  // Start to listen
+  server.begin();
+
+  Serial.println(F("Server is ready."));
+  Serial.print(F("Please connect to http://"));
+  Serial.println(Ethernet.localIP());
+}
+
+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 a temporary JsonDocument
+  // Use arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<500> doc;
+
+  // Create the "analog" array
+  JsonArray analogValues = doc.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 = doc.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);
+  }
+
+  Serial.print(F("Sending: "));
+  serializeJson(doc, Serial);
+  Serial.println();
+
+  // Write response headers
+  client.println(F("HTTP/1.0 200 OK"));
+  client.println(F("Content-Type: application/json"));
+  client.println(F("Connection: close"));
+  client.print(F("Content-Length: "));
+  client.println(measureJsonPretty(doc));
+  client.println();
+
+  // Write JSON document
+  serializeJsonPretty(doc, client);
+
+  // Disconnect
+  client.stop();
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, then adds more features like serializing
+// directly to a file or an HTTP client.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -0,0 +1,100 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// 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.
+// It looks like that:
+// {
+//   "analog": [0, 76, 123, 158, 192, 205],
+//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
+// }
+//
+// 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/
+//
+// https://arduinojson.org/v6/example/udp-beacon/
+
+#include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+IPAddress remoteIp(192, 168, 0, 108);  // <- EDIT!!!!
+unsigned short remotePort = 8888;
+unsigned short localPort = 8888;
+EthernetUDP udp;
+
+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;
+  }
+
+  // Enable UDP
+  udp.begin(localPort);
+}
+
+void loop() {
+  // Allocate a temporary JsonDocument
+  // Use arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<500> doc;
+
+  // Create the "analog" array
+  JsonArray analogValues = doc.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 = doc.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(doc, Serial);
+
+  // Send UDP packet
+  udp.beginPacket(remoteIp, remotePort);
+  serializeJson(doc, udp);
+  udp.println();
+  udp.endPacket();
+
+  // Wait
+  delay(10000);
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, then adds more features like serializing
+// directly to a file or any stream.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/MsgPackParser/MsgPackParser.ino

@@ -0,0 +1,75 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows how to deserialize a MessagePack document with
+// ArduinoJson.
+//
+// https://arduinojson.org/v6/example/msgpack-parser/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Allocate the JSON document
+  //
+  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Don't forget to change this value to match your JSON document.
+  // Use arduinojson.org/v6/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.
+  //
+  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
+  // the minimal amount of memory because the JsonDocument stores pointers to
+  // the input buffer.
+  // If you use another type of input, ArduinoJson must copy the strings from
+  // the input to the JsonDocument, so you need to increase the capacity of the
+  // JsonDocument.
+  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]
+  // }
+
+  DeserializationError error = deserializeMsgPack(doc, input);
+
+  // Test if parsing succeeded.
+  if (error) {
+    Serial.print("deserializeMsgPack() failed: ");
+    Serial.println(error.c_str());
+    return;
+  }
+
+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do doc["time"].as<long>();
+  const char* sensor = doc["sensor"];
+  long time = doc["time"];
+  double latitude = doc["data"][0];
+  double longitude = doc["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
+}

examples/ProgmemExample/ProgmemExample.ino

@@ -0,0 +1,72 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows the different ways you can use Flash strings with
+// ArduinoJson.
+//
+// Use Flash strings sparingly, because ArduinoJson duplicates them in the
+// JsonDocument. Prefer plain old char*, as they are more efficient in term of
+// code size, speed, and memory usage.
+//
+// https://arduinojson.org/v6/example/progmem/
+
+#include <ArduinoJson.h>
+
+void setup() {
+#ifdef PROGMEM  // <- check that Flash strings are supported
+
+  DynamicJsonDocument doc(1024);
+
+  // You can use a Flash String as your JSON input.
+  // WARNING: the strings in the input will be duplicated in the JsonDocument.
+  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 = 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
+  // JsonDocument.
+  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
+  // JsonDocument.
+  obj["sensor"] = F("gps");
+
+  // It works with serialized() too:
+  obj["sensor"] = serialized(F("\"gps\""));
+  obj["sensor"] = serialized(F("\xA3gps"), 3);
+
+  // You can compare the content of a JsonVariant to a Flash String
+  if (obj["sensor"] == F("gps")) {
+    // ...
+  }
+
+#else
+
+#warning PROGMEM is not supported on this platform
+
+#endif
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any memory
+// problem.
+//
+// The book "Mastering ArduinoJson" contains a quick C++ course that explains
+// how your microcontroller stores strings in memory. It also tells why you
+// should not abuse Flash strings with ArduinoJson.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/StringExample/StringExample.ino

@@ -0,0 +1,77 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows the different ways you can use String with ArduinoJson.
+//
+// Use String objects sparingly, because ArduinoJson duplicates them in the
+// JsonDocument. Prefer plain old char[], as they are more efficient in term of
+// code size, speed, and memory usage.
+//
+// https://arduinojson.org/v6/example/string/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  DynamicJsonDocument doc(1024);
+
+  // You can use a String as your JSON input.
+  // WARNING: the string in the input  will be duplicated in the JsonDocument.
+  String input =
+      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+  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 = 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 JsonDocument.
+  obj[String("time")] = time;
+
+  // You can get a String from a JsonObject or JsonArray:
+  // No duplication is done, at least not in the JsonDocument.
+  String sensor = obj["sensor"];
+
+  // Unfortunately, the following doesn't work (issue #118):
+  // sensor = obj["sensor"]; // <-  error "ambiguous overload for 'operator='"
+  // As a workaround, you need to replace by:
+  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 JsonDocument.
+  obj["sensor"] = sensor;
+
+  // It works with serialized() too:
+  obj["sensor"] = serialized(sensor);
+
+  // You can also concatenate strings
+  // WARNING: the content of the String will be duplicated in the JsonDocument.
+  obj[String("sen") + "sor"] = String("gp") + "s";
+
+  // You can compare the content of a JsonObject with a String
+  if (obj["sensor"] == sensor) {
+    // ...
+  }
+
+  // Lastly, you can print the resulting JSON to a String
+  String output;
+  serializeJson(doc, output);
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any problem.
+//
+// The book "Mastering ArduinoJson" contains a quick C++ course that explains
+// how your microcontroller stores strings in memory. On several occasions, it
+// shows how you can avoid String in your program.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

fuzzing/CMakeLists.txt

@@ -0,0 +1,17 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2019
+# MIT License
+
+if(MSVC)
+	add_compile_options(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+add_executable(msgpack_fuzzer
+	msgpack_fuzzer.cpp
+	fuzzer_main.cpp
+)
+
+add_executable(json_fuzzer
+	json_fuzzer.cpp
+	fuzzer_main.cpp
+)

fuzzing/Makefile

@@ -0,0 +1,22 @@
+# CAUTION: this file is invoked by https://github.com/google/oss-fuzz
+
+CXXFLAGS += -I../src -DARDUINOJSON_DEBUG
+
+all: \
+	$(OUT)/json_fuzzer \
+	$(OUT)/json_fuzzer_seed_corpus.zip \
+	$(OUT)/json_fuzzer.options \
+	$(OUT)/msgpack_fuzzer \
+	$(OUT)/msgpack_fuzzer_seed_corpus.zip \
+	$(OUT)/msgpack_fuzzer.options
+
+$(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../src -type f)
+	$(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE)
+
+$(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/*
+	zip -j $@ $?
+
+$(OUT)/%_fuzzer.options:
+	@echo "[libfuzzer]" > $@
+	@echo "max_len = 256" >> $@
+	@echo "timeout = 10" >> $@

fuzzing/fuzzer_main.cpp

@@ -0,0 +1,50 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+// This file is NOT use by Google's OSS fuzz
+// I only use it to reproduce the bugs found
+
+#include <stdint.h>  // size_t
+#include <stdio.h>   // fopen et al.
+#include <stdlib.h>  // exit
+#include <iostream>
+#include <vector>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+std::vector<uint8_t> read(const char* path) {
+  FILE* f = fopen(path, "rb");
+  if (!f) {
+    std::cerr << "Failed to open " << path << std::endl;
+    exit(1);
+  }
+
+  fseek(f, 0, SEEK_END);
+  size_t size = ftell(f);
+  fseek(f, 0, SEEK_SET);
+
+  std::vector<uint8_t> buffer(size);
+  if (fread(buffer.data(), 1, size, f) != size) {
+    fclose(f);
+    std::cerr << "Failed to read " << path << std::endl;
+    exit(1);
+  }
+
+  fclose(f);
+  return buffer;
+}
+
+int main(int argc, const char* argv[]) {
+  if (argc < 2) {
+    std::cerr << "Usage: msgpack_fuzzer files" << std::endl;
+    return 1;
+  }
+
+  for (int i = 1; i < argc; i++) {
+    std::cout << "Loading " << argv[i] << std::endl;
+    std::vector<uint8_t> buffer = read(argv[i]);
+    LLVMFuzzerTestOneInput(buffer.data(), buffer.size());
+  }
+  return 0;
+}

fuzzing/json_corpus/.gitignore

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

fuzzing/json_fuzzer.cpp

@@ -0,0 +1,11 @@
+#include <ArduinoJson.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  DynamicJsonDocument doc(4096);
+  DeserializationError error = deserializeJson(doc, data, size);
+  if (!error) {
+    std::string json;
+    serializeJson(doc, json);
+  }
+  return 0;
+}

fuzzing/json_seed_corpus/Comments.json

@@ -0,0 +1,10 @@
+//comment
+/*comment*/
+[ //comment
+/*comment*/"comment"/*comment*/,//comment
+/*comment*/{//comment
+/* comment*/"key"//comment
+: //comment
+"value"//comment
+}/*comment*/
+]//comment

fuzzing/json_seed_corpus/EmptyArray.json

@@ -0,0 +1 @@
+[]

fuzzing/json_seed_corpus/EmptyObject.json

@@ -0,0 +1 @@
+{}

fuzzing/json_seed_corpus/ExcessiveNesting.json

@@ -0,0 +1 @@
+[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20,[21,[22,[23,[24,[25,[26,[27,[28,[29,[30,[31,[32,[33,[34,[35,[36,[37,[38,[39,[40,[41,[42,[43,[44,[45,[46,[47,[48,[49,[50,[51,[52,[53,[54,[55,[56,[57,[58,[59,[60,[61,[62,[63,[64,[65,[66,[67,[68,[69,[70,[71,[72,[73,[74,[75,[76,[77,[78,[79,[80,[81,[82,[83,[84,[85,[86,[87,[88,[89,[90,[91,[92,[93,[94,[95,[96,[97,[98,[99,[100,[101,[102,[103,[104,[105,[106,[107,[108,[109,[110,[111,[112,[113,[114,[115,[116,[117,[118,[119,[120]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

fuzzing/json_seed_corpus/IntegerOverflow.json

@@ -0,0 +1 @@
+9720730739393920739

fuzzing/json_seed_corpus/Numbers.json

@@ -0,0 +1,24 @@
+[
+  123,
+  -123,
+  123.456,
+  -123.456,
+  12e34,
+  12e-34,
+  12e+34,
+  12E34,
+  12E-34,
+  12E+34,
+  12.34e56,
+  12.34e-56,
+  12.34e+56,
+  12.34E56,
+  12.34E-56,
+  12.34E+56,
+  NaN,
+  -NaN,
+  +NaN,
+  Infinity,
+  +Infinity,
+  -Infinity
+]

fuzzing/json_seed_corpus/OpenWeatherMap.json

@@ -0,0 +1,53 @@
+{
+  "coord": {
+    "lon": -0.13,
+    "lat": 51.51
+  },
+  "weather": [
+    {
+      "id": 301,
+      "main": "Drizzle",
+      "description": "drizzle",
+      "icon": "09n"
+    },
+    {
+      "id": 701,
+      "main": "Mist",
+      "description": "mist",
+      "icon": "50n"
+    },
+    {
+      "id": 741,
+      "main": "Fog",
+      "description": "fog",
+      "icon": "50n"
+    }
+  ],
+  "base": "stations",
+  "main": {
+    "temp": 281.87,
+    "pressure": 1032,
+    "humidity": 100,
+    "temp_min": 281.15,
+    "temp_max": 283.15
+  },
+  "visibility": 2900,
+  "wind": {
+    "speed": 1.5
+  },
+  "clouds": {
+    "all": 90
+  },
+  "dt": 1483820400,
+  "sys": {
+    "type": 1,
+    "id": 5091,
+    "message": 0.0226,
+    "country": "GB",
+    "sunrise": 1483776245,
+    "sunset": 1483805443
+  },
+  "id": 2643743,
+  "name": "London",
+  "cod": 200
+}

fuzzing/json_seed_corpus/Strings.json

@@ -0,0 +1,8 @@
+[
+  "hello",
+  'hello',
+  hello,
+  {"hello":"world"},
+  {'hello':'world'},
+  {hello:world}
+]

fuzzing/json_seed_corpus/WeatherUnderground.json

@@ -0,0 +1,90 @@
+{
+  "response": {
+    "version": "0.1",
+    "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
+    "features": {
+      "conditions": 1
+    }
+  },
+  "current_observation": {
+    "image": {
+      "url": "http://icons-ak.wxug.com/graphics/wu2/logo_130x80.png",
+      "title": "Weather Underground",
+      "link": "http://www.wunderground.com"
+    },
+    "display_location": {
+      "full": "San Francisco, CA",
+      "city": "San Francisco",
+      "state": "CA",
+      "state_name": "California",
+      "country": "US",
+      "country_iso3166": "US",
+      "zip": "94101",
+      "latitude": "37.77500916",
+      "longitude": "-122.41825867",
+      "elevation": "47.00000000"
+    },
+    "observation_location": {
+      "full": "SOMA - Near Van Ness, San Francisco, California",
+      "city": "SOMA - Near Van Ness, San Francisco",
+      "state": "California",
+      "country": "US",
+      "country_iso3166": "US",
+      "latitude": "37.773285",
+      "longitude": "-122.417725",
+      "elevation": "49 ft"
+    },
+    "estimated": {},
+    "station_id": "KCASANFR58",
+    "observation_time": "Last Updated on June 27, 5:27 PM PDT",
+    "observation_time_rfc822": "Wed, 27 Jun 2012 17:27:13 -0700",
+    "observation_epoch": "1340843233",
+    "local_time_rfc822": "Wed, 27 Jun 2012 17:27:14 -0700",
+    "local_epoch": "1340843234",
+    "local_tz_short": "PDT",
+    "local_tz_long": "America/Los_Angeles",
+    "local_tz_offset": "-0700",
+    "weather": "Partly Cloudy",
+    "temperature_string": "66.3 F (19.1 C)",
+    "temp_f": 66.3,
+    "temp_c": 19.1,
+    "relative_humidity": "65%",
+    "wind_string": "From the NNW at 22.0 MPH Gusting to 28.0 MPH",
+    "wind_dir": "NNW",
+    "wind_degrees": 346,
+    "wind_mph": 22,
+    "wind_gust_mph": "28.0",
+    "wind_kph": 35.4,
+    "wind_gust_kph": "45.1",
+    "pressure_mb": "1013",
+    "pressure_in": "29.93",
+    "pressure_trend": "+",
+    "dewpoint_string": "54 F (12 C)",
+    "dewpoint_f": 54,
+    "dewpoint_c": 12,
+    "heat_index_string": "NA",
+    "heat_index_f": "NA",
+    "heat_index_c": "NA",
+    "windchill_string": "NA",
+    "windchill_f": "NA",
+    "windchill_c": "NA",
+    "feelslike_string": "66.3 F (19.1 C)",
+    "feelslike_f": "66.3",
+    "feelslike_c": "19.1",
+    "visibility_mi": "10.0",
+    "visibility_km": "16.1",
+    "solarradiation": "",
+    "UV": "5",
+    "precip_1hr_string": "0.00 in ( 0 mm)",
+    "precip_1hr_in": "0.00",
+    "precip_1hr_metric": " 0",
+    "precip_today_string": "0.00 in (0 mm)",
+    "precip_today_in": "0.00",
+    "precip_today_metric": "0",
+    "icon": "partlycloudy",
+    "icon_url": "http://icons-ak.wxug.com/i/c/k/partlycloudy.gif",
+    "forecast_url": "http://www.wunderground.com/US/CA/San_Francisco.html",
+    "history_url": "http://www.wunderground.com/history/airport/KCASANFR58/2012/6/27/DailyHistory.html",
+    "ob_url": "http://www.wunderground.com/cgi-bin/findweather/getForecast?query=37.773285,-122.417725"
+  }
+}

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(4096);
+  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,10 +1,36 @@
-JsonParser	KEYWORD1
-JsonArray	KEYWORD1
-JsonHashTable	KEYWORD1
-getArray	KEYWORD2
-getBool	KEYWORD2
-getDouble	KEYWORD2
-getHashTableKEYWORD2
-getLong	KEYWORD2
-parseArray	KEYWORD2
-parseHashTable	KEYWORD2
+# Macros
+JSON_ARRAY_SIZE	KEYWORD2
+JSON_OBJECT_SIZE	KEYWORD2
+JSON_STRING_SIZE	KEYWORD2
+
+# Free functions
+deserializeJson	KEYWORD2
+deserializeMsgPack	KEYWORD2
+serialized	KEYWORD2
+serializeJson	KEYWORD2
+serializeJsonPretty	KEYWORD2
+serializeMsgPack	KEYWORD2
+
+# Methods
+add	KEYWORD2
+as	KEYWORD2
+createNestedArray	KEYWORD2
+createNestedObject	KEYWORD2
+get	KEYWORD2
+set	KEYWORD2
+to	KEYWORD2
+
+# Type names
+DeserializationError	KEYWORD1	DATA_TYPE
+DynamicJsonDocument	KEYWORD1	DATA_TYPE
+JsonArray	KEYWORD1	DATA_TYPE
+JsonArrayConst	KEYWORD1	DATA_TYPE
+JsonFloat	KEYWORD1	DATA_TYPE
+JsonInteger	KEYWORD1	DATA_TYPE
+JsonObject	KEYWORD1	DATA_TYPE
+JsonObjectConst	KEYWORD1	DATA_TYPE
+JsonString	KEYWORD1	DATA_TYPE
+JsonUInt	KEYWORD1	DATA_TYPE
+JsonVariant	KEYWORD1	DATA_TYPE
+JsonVariantConst	KEYWORD1	DATA_TYPE
+StaticJsonDocument	KEYWORD1	DATA_TYPE

library.json

@@ -0,0 +1,23 @@
+{
+  "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": "6.11.0",
+  "authors": {
+    "name": "Benoit Blanchon",
+    "url": "https://blog.benoitblanchon.fr"
+  },
+  "exclude": [
+    "fuzzing",
+    "scripts",
+    "test",
+    "third-party"
+  ],
+  "frameworks": "arduino",
+  "platforms": "*"
+}

library.properties

@@ -0,0 +1,11 @@
+name=ArduinoJson
+version=6.11.0
+author=Benoit Blanchon <blog.benoitblanchon.fr>
+maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
+sentence=An efficient and elegant JSON library for Arduino.
+paragraph=ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation.
+category=Data Processing
+url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties
+architectures=*
+repository=https://github.com/bblanchon/ArduinoJson.git
+license=MIT

scripts/build-arduino-package.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+TAG=$(git describe)
+OUTPUT="ArduinoJson-$TAG.zip"
+
+cd $(dirname $0)/../..
+
+# remove existing file
+rm -f $OUTPUT
+
+# create zip
+7z a $OUTPUT \
+	ArduinoJson/CHANGELOG.md \
+	ArduinoJson/examples \
+	ArduinoJson/src \
+	ArduinoJson/keywords.txt \
+	ArduinoJson/library.properties \
+	ArduinoJson/LICENSE.md \
+	ArduinoJson/README.md \
+	ArduinoJson/ArduinoJson.h

scripts/build-single-header.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+TAG=$(git describe)
+RE_INCLUDE='^#include[[:space:]]*["<](.*)[">]'
+RE_EMPTY='^(#pragma[[:space:]]+once)?[[:space:]]*(//.*)?$'
+
+declare -A INCLUDED
+
+process()
+{
+	local PARENT=$1
+	local FOLDER=$(dirname $1)
+	local SHOW_COMMENT=$2
+	while IFS= read -r LINE; do
+		if [[ $LINE =~ $RE_INCLUDE ]]; then
+			local CHILD=${BASH_REMATCH[1]}
+			pushd "$FOLDER" > /dev/null
+			if [[ -e $CHILD ]]; then
+				local CHILD_PATH=$(realpath $CHILD)
+				if [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then
+					#echo "// $PARENT -> $CHILD"
+					INCLUDED[$CHILD_PATH]=true
+					process "$CHILD" false
+				fi
+			else
+				if [[ ! ${INCLUDED[$CHILD]} ]]; then
+					echo "$LINE"
+					INCLUDED[$CHILD]=true
+				fi
+			fi
+			popd > /dev/null
+		elif [[ "${SHOW_COMMENT}" = "true" ]] ; then
+			echo "$LINE"
+		elif [[ ! $LINE =~ $RE_EMPTY ]]; then
+			echo "$LINE"
+		fi
+	done < $PARENT
+}
+
+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
+g++ -x c++ -c -o ../smoketest.o - <<END
+#include "../ArduinoJson-$TAG.hpp"
+int main() {}
+END

scripts/create-build-envs.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+export PATH="$PATH:/Applications/CMake.app/Contents/bin/"
+
+cd $(dirname $0)/..
+ROOT=$(pwd)
+
+mkdir "build"
+cd build
+BUILD=$(pwd)
+
+build-env()
+{
+	cd $BUILD
+	mkdir "$1"
+	cd "$1"
+	cmake "$ROOT" -G "$2"
+}
+
+if [[ $(uname) == MINGW* ]]
+then
+	build-env "Make" "MinGW Makefiles"
+	build-env "SublimeText" "Sublime Text 2 - Ninja"
+	build-env "VisualStudio" "Visual Studio 14 2015"
+else
+	build-env "SublimeText" "Sublime Text 2 - Ninja"
+	build-env "Make" "Unix Makefiles"
+	build-env "Xcode" "Xcode"
+fi

scripts/oss-fuzz/.gitignore

@@ -0,0 +1,2 @@
+/.vagrant/
+*.log

scripts/oss-fuzz/Vagrantfile

@@ -0,0 +1,34 @@
+# A virtual machine to run https://github.com/google/oss-fuzz
+Vagrant.configure(2) do |config|
+  config.vm.box = "ubuntu/xenial64"
+
+  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
+
+    sudo apt-get update
+    sudo apt-get install -y make git docker.io zip
+    sudo groupadd docker
+    sudo usermod -aG docker $USER
+
+    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
+
+    echo "export PROJECT_NAME='arduinojson'" >> $HOME/.profile
+    echo "export CC='clang'" >> $HOME/.profile
+    echo "export CXX='clang++'" >> $HOME/.profile
+    echo "export LD_LIBRARY_PATH=/usr/lib/x86_64-linux-gnu/" >> $HOME/.profile
+
+    echo "Run /host/ArduinoJson/fuzzing/fuzz.sh" | sudo tee /etc/motd
+  SHELL
+end

scripts/publish-particle-library.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+set -eu
+
+SOURCE_DIR="$(dirname "$0")/.."
+WORK_DIR=$(mktemp -d)
+trap 'rm -rf "$WORK_DIR"' EXIT
+
+cp "$SOURCE_DIR/README.md" "$WORK_DIR/README.md"
+cp "$SOURCE_DIR/CHANGELOG.md" "$WORK_DIR/CHANGELOG.md"
+cp "$SOURCE_DIR/library.properties" "$WORK_DIR/library.properties"
+cp "$SOURCE_DIR/LICENSE.md" "$WORK_DIR/LICENSE.txt"
+cp -r "$SOURCE_DIR/src" "$WORK_DIR/"
+cp -r "$SOURCE_DIR/examples" "$WORK_DIR/"
+
+cd "$WORK_DIR"
+particle library upload
+particle library publish

scripts/publish.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+
+set -eu
+
+cd "$(dirname "$0")/.."
+
+VERSION="$1"
+DATE=$(date +%F)
+TAG="v$VERSION"
+VERSION_REGEX="[0-9a-z\\.\\-]+"
+
+update_version_in_source () {
+	IFS=".-" read MAJOR MINOR REVISION EXTRA < <(echo "$VERSION")
+	UNDERLINE=$(printf -- '-%.0s' $(seq 1 ${#TAG}))
+
+	sed -i~ -bE "s/version=$VERSION_REGEX/version=$VERSION/; s|ardu-badge.com/ArduinoJson/$VERSION_REGEX|ardu-badge.com/ArduinoJson/$VERSION|; " README.md
+	rm README.md*~
+
+	sed -i~ -bE "4s/HEAD/$TAG ($DATE)/; 5s/-+/$UNDERLINE/" CHANGELOG.md
+	rm CHANGELOG.md*~
+
+	sed -i~ -bE "s/\"version\":.*$/\"version\": \"$VERSION\",/" library.json
+	rm library.json*~
+
+	sed -i~ -bE "s/version=.*$/version=$VERSION/" library.properties
+	rm library.properties*~
+
+	sed -i~ -bE "s/version: .*$/version: $VERSION.{build}/" appveyor.yml
+	rm appveyor.yml*~
+
+	sed -i~ -bE \
+		-e "s/ARDUINOJSON_VERSION .*$/ARDUINOJSON_VERSION \"$VERSION\"/" \
+		-e "s/ARDUINOJSON_VERSION_MAJOR .*$/ARDUINOJSON_VERSION_MAJOR $MAJOR/" \
+		-e "s/ARDUINOJSON_VERSION_MINOR .*$/ARDUINOJSON_VERSION_MINOR $MINOR/" \
+		-e "s/ARDUINOJSON_VERSION_REVISION .*$/ARDUINOJSON_VERSION_REVISION $REVISION/" \
+		src/ArduinoJson/version.hpp
+	rm src/ArduinoJson/version.hpp*~
+}
+
+commit_new_version () {
+	git add src/ArduinoJson/version.hpp README.md CHANGELOG.md library.json library.properties appveyor.yml
+	git commit -m "Set version to $VERSION"
+}
+
+add_tag () {
+	CHANGES=$(awk '/\* /{ FOUND=1; print; next } { if (FOUND) exit}' CHANGELOG.md)
+	git tag -m "ArduinoJson $VERSION"$'\n'"$CHANGES" "$TAG"
+}
+
+push () {
+	git push --follow-tags
+}
+
+update_version_in_source
+commit_new_version
+add_tag
+push
+
+scripts/build-arduino-package.sh
+scripts/build-single-header.sh
+scripts/wandbox/publish.sh "../ArduinoJson-$TAG.h"

scripts/travis/arduino.sh

@@ -0,0 +1,20 @@
+#!/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
+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
+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
+	arduino --verify --board $BOARD $EXAMPLE
+done

scripts/travis/build.sh

@@ -0,0 +1,14 @@
+#!/bin/sh -ex
+
+export CC="$_CC"
+export CXX="$_CXX"
+
+if [ -n "$SANITIZE" ]; then
+	export CXXFLAGS="-fsanitize=$SANITIZE"
+	BUILD_TYPE="Debug"
+else
+	BUILD_TYPE="Release"
+fi
+
+cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE .
+cmake --build .

scripts/travis/coverage.sh

@@ -0,0 +1,8 @@
+#!/bin/sh -eux
+
+cmake -DCOVERAGE=true .
+make 
+make test
+
+pip install --user cpp-coveralls 'requests[security]'
+coveralls --exclude third-party --gcov-options '\-lp'; fi

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,undefined,fuzzer -fno-sanitize-recover=all"
+
+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 -timeout=1
+
+	llvm-profdata-${CLANG} merge -sparse ${LLVM_PROFILE_FILE} -o ${FUZZER}.profdata
+	llvm-cov-${CLANG} report ./${FUZZER} -instr-profile=${FUZZER}.profdata
+}
+
+fuzz json
+fuzz msgpack

scripts/travis/platformio.sh

@@ -0,0 +1,22 @@
+#!/bin/sh -eux
+
+pip install --user platformio
+
+rm -r test
+
+case $BOARD in
+uno)
+  platformio lib install 868 # SD library
+  platformio lib install 872 # Ethernet library
+  ;;
+esp01)
+  platformio lib uninstall 161 || true
+  platformio lib uninstall 868 || true
+  platformio lib uninstall 872 || true
+  ;;
+esac
+
+for EXAMPLE in $PWD/examples/*/*.ino; 
+do
+	platformio ci $EXAMPLE -l '.' -b $BOARD
+done

scripts/travis/test.sh

@@ -0,0 +1,4 @@
+#!/bin/sh -ex
+
+"$(dirname "$0")/build.sh"
+ctest --output-on-failure .

scripts/wandbox/JsonGeneratorExample.cpp

@@ -0,0 +1,60 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows how to generate a JSON document with ArduinoJson.
+
+#include <iostream>
+#include "ArduinoJson.h"
+
+int main() {
+  // Allocate the JSON document
+  //
+  // 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/v6/assistant to compute the capacity.
+  StaticJsonDocument<200> doc;
+
+  // StaticJsonObject allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument  doc(200);
+
+  // StaticJsonObject allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument  doc(200);
+
+  // Add values in the document
+  //
+  doc["sensor"] = "gps";
+  doc["time"] = 1351824120;
+
+  // Add an array.
+  //
+  JsonArray data = doc.createNestedArray("data");
+  data.add(48.756080);
+  data.add(2.302038);
+
+  // Generate the minified JSON and send it to STDOUT
+  //
+  serializeJson(doc, std::cout);
+  // The above line prints:
+  // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+  // Start a new line
+  std::cout << std::endl;
+
+  // Generate the prettified JSON and send it to STDOUT
+  //
+  serializeJsonPretty(doc, std::cout);
+  // The above line prints:
+  // {
+  //   "sensor": "gps",
+  //   "time": 1351824120,
+  //   "data": [
+  //     48.756080,
+  //     2.302038
+  //   ]
+  // }
+}

scripts/wandbox/JsonParserExample.cpp

@@ -0,0 +1,59 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows how to deserialize a JSON document with ArduinoJson.
+
+#include <iostream>
+#include "ArduinoJson.h"
+
+int main() {
+  // Allocate the JSON document
+  //
+  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Don't forget to change this value to match your JSON document.
+  // Use arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<300> doc;
+
+  // StaticJsonDocument<N> allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument doc(200);
+
+  // JSON input string.
+  //
+  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
+  // the minimal amount of memory because the JsonDocument stores pointers to
+  // the input buffer.
+  // If you use another type of input, ArduinoJson must copy the strings from
+  // the input to the JsonDocument, so you need to increase the capacity of the
+  // JsonDocument.
+  char json[] =
+      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+
+  // Deserialize the JSON document
+  DeserializationError error = deserializeJson(doc, json);
+
+  // Test if parsing succeeds.
+  if (error) {
+    std::cerr << "deserializeJson() failed: " << error.c_str() << std::endl;
+    return 1;
+  }
+
+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do doc["time"].as<long>();
+  const char* sensor = doc["sensor"];
+  long time = doc["time"];
+  double latitude = doc["data"][0];
+  double longitude = doc["data"][1];
+
+  // Print values.
+  std::cout << sensor << std::endl;
+  std::cout << time << std::endl;
+  std::cout << latitude << std::endl;
+  std::cout << longitude << std::endl;
+
+  return 0;
+}

scripts/wandbox/MsgPackParserExample.cpp

@@ -0,0 +1,68 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+//
+// This example shows how to generate a JSON document with ArduinoJson.
+
+#include <iostream>
+#include "ArduinoJson.h"
+
+int main() {
+  // Allocate the JSON document
+  //
+  // Inside the brackets, 300 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<300> 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) {
+    std::cerr << "deserializeMsgPack() failed: " << error.c_str() << std::endl;
+    return 1;
+  }
+
+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do doc["time"].as<long>();
+  const char* sensor = doc["sensor"];
+  long time = doc["time"];
+  double latitude = doc["data"][0];
+  double longitude = doc["data"][1];
+
+  // Print values.
+  std::cout << sensor << std::endl;
+  std::cout << time << std::endl;
+  std::cout << latitude << std::endl;
+  std::cout << longitude << std::endl;
+
+  return 0;
+}

scripts/wandbox/publish.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+set -eu
+
+ARDUINOJSON_H="$1"
+
+read_string() {
+	jq --slurp --raw-input '.' "$1"
+}
+
+compile() {
+	FILE_PATH="$(dirname $0)/$1.cpp"
+	cat >parameters.json <<END
+{
+  "code":$(read_string "$FILE_PATH"),
+  "codes": [{"file":"ArduinoJson.h","code":$(read_string "$ARDUINOJSON_H")}],
+  "options": "warning",
+  "compiler": "gcc-4.9.3",
+  "save": true
+}
+END
+	URL=$(curl -sS -H "Content-type: application/json" -d @parameters.json  https://wandbox.org/api/compile.json | jq --raw-output .url)
+	rm parameters.json
+	echo "  $1: $URL"
+}
+
+compile "JsonGeneratorExample"
+compile "JsonParserExample"
+compile "MsgPackParserExample"

src/ArduinoJson.h

@@ -0,0 +1,17 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#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

@@ -0,0 +1,69 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#pragma once
+
+#ifndef ARDUINOJSON_DEBUG
+#ifdef __clang__
+#pragma clang system_header
+#elif defined __GNUC__
+#pragma GCC system_header
+#endif
+#endif
+
+#include "ArduinoJson/Namespace.hpp"
+
+#include "ArduinoJson/Array/ArrayRef.hpp"
+#include "ArduinoJson/Object/ObjectRef.hpp"
+#include "ArduinoJson/Variant/VariantRef.hpp"
+
+#include "ArduinoJson/Document/DynamicJsonDocument.hpp"
+#include "ArduinoJson/Document/StaticJsonDocument.hpp"
+
+#include "ArduinoJson/Array/ArrayImpl.hpp"
+#include "ArduinoJson/Array/ElementProxy.hpp"
+#include "ArduinoJson/Array/Utilities.hpp"
+#include "ArduinoJson/Collection/CollectionImpl.hpp"
+#include "ArduinoJson/Object/MemberProxy.hpp"
+#include "ArduinoJson/Object/ObjectImpl.hpp"
+#include "ArduinoJson/Variant/VariantAsImpl.hpp"
+#include "ArduinoJson/Variant/VariantImpl.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/compatibility.hpp"
+
+namespace ArduinoJson {
+typedef ARDUINOJSON_NAMESPACE::ArrayConstRef JsonArrayConst;
+typedef ARDUINOJSON_NAMESPACE::ArrayRef JsonArray;
+typedef ARDUINOJSON_NAMESPACE::Float JsonFloat;
+typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger;
+typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst;
+typedef ARDUINOJSON_NAMESPACE::ObjectRef JsonObject;
+typedef ARDUINOJSON_NAMESPACE::Pair JsonPair;
+typedef ARDUINOJSON_NAMESPACE::String JsonString;
+typedef ARDUINOJSON_NAMESPACE::UInt JsonUInt;
+typedef ARDUINOJSON_NAMESPACE::VariantConstRef JsonVariantConst;
+typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant;
+using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
+using ARDUINOJSON_NAMESPACE::copyArray;
+using ARDUINOJSON_NAMESPACE::DeserializationError;
+using ARDUINOJSON_NAMESPACE::deserializeJson;
+using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
+using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
+using ARDUINOJSON_NAMESPACE::JsonDocument;
+using ARDUINOJSON_NAMESPACE::serialized;
+using ARDUINOJSON_NAMESPACE::serializeJson;
+using ARDUINOJSON_NAMESPACE::serializeJsonPretty;
+using ARDUINOJSON_NAMESPACE::serializeMsgPack;
+using ARDUINOJSON_NAMESPACE::StaticJsonDocument;
+
+namespace DeserializationOption {
+using ARDUINOJSON_NAMESPACE::NestingLimit;
+}
+}  // namespace ArduinoJson

src/ArduinoJson/Array/ArrayFunctions.hpp

@@ -0,0 +1,29 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#pragma once
+
+#include "../Collection/CollectionData.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) {
+  return arr ? arr->add(pool) : 0;
+}
+
+template <typename Visitor>
+inline void arrayAccept(const CollectionData *arr, Visitor &visitor) {
+  if (arr)
+    visitor.visitArray(*arr);
+  else
+    visitor.visitNull();
+}
+
+inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) {
+  if (lhs == rhs) return true;
+  if (!lhs || !rhs) return false;
+
+  return lhs->equalsArray(*rhs);
+}
+}  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Array/ArrayImpl.hpp

@@ -0,0 +1,22 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#pragma once
+
+#include "../Object/ObjectRef.hpp"
+#include "ArrayRef.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TArray>
+inline ArrayRef ArrayShortcuts<TArray>::createNestedArray() const {
+  return impl()->addElement().template to<ArrayRef>();
+}
+
+template <typename TArray>
+inline ObjectRef ArrayShortcuts<TArray>::createNestedObject() const {
+  return impl()->addElement().template to<ObjectRef>();
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Array/ArrayIterator.hpp

@@ -0,0 +1,121 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#pragma once
+
+#include "../Variant/SlotFunctions.hpp"
+#include "../Variant/VariantRef.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class VariantPtr {
+ public:
+  VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {}
+
+  VariantRef *operator->() {
+    return &_variant;
+  }
+
+  VariantRef &operator*() {
+    return _variant;
+  }
+
+ private:
+  VariantRef _variant;
+};
+
+class ArrayIterator {
+ public:
+  ArrayIterator() : _slot(0) {}
+  explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot)
+      : _pool(pool), _slot(slot) {}
+
+  VariantRef operator*() const {
+    return VariantRef(_pool, _slot->data());
+  }
+  VariantPtr operator->() {
+    return VariantPtr(_pool, _slot->data());
+  }
+
+  bool operator==(const ArrayIterator &other) const {
+    return _slot == other._slot;
+  }
+
+  bool operator!=(const ArrayIterator &other) const {
+    return _slot != other._slot;
+  }
+
+  ArrayIterator &operator++() {
+    _slot = _slot->next();
+    return *this;
+  }
+
+  ArrayIterator &operator+=(size_t distance) {
+    _slot = _slot->next(distance);
+    return *this;
+  }
+
+  VariantSlot *internal() {
+    return _slot;
+  }
+
+ private:
+  MemoryPool *_pool;
+  VariantSlot *_slot;
+};
+
+class VariantConstPtr {
+ public:
+  VariantConstPtr(const VariantData *data) : _variant(data) {}
+
+  VariantConstRef *operator->() {
+    return &_variant;
+  }
+
+  VariantConstRef &operator*() {
+    return _variant;
+  }
+
+ private:
+  VariantConstRef _variant;
+};
+
+class ArrayConstRefIterator {
+ public:
+  ArrayConstRefIterator() : _slot(0) {}
+  explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {}
+
+  VariantConstRef operator*() const {
+    return VariantConstRef(_slot->data());
+  }
+  VariantConstPtr operator->() {
+    return VariantConstPtr(_slot->data());
+  }
+
+  bool operator==(const ArrayConstRefIterator &other) const {
+    return _slot == other._slot;
+  }
+
+  bool operator!=(const ArrayConstRefIterator &other) const {
+    return _slot != other._slot;
+  }
+
+  ArrayConstRefIterator &operator++() {
+    _slot = _slot->next();
+    return *this;
+  }
+
+  ArrayConstRefIterator &operator+=(size_t distance) {
+    _slot = _slot->next(distance);
+    return *this;
+  }
+
+  const VariantSlot *internal() {
+    return _slot;
+  }
+
+ private:
+  const VariantSlot *_slot;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Array/ArrayRef.hpp

@@ -0,0 +1,153 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#pragma once
+
+#include "../Variant/VariantData.hpp"
+#include "ArrayFunctions.hpp"
+#include "ArrayIterator.hpp"
+
+// Returns the size (in bytes) of an array with n elements.
+// Can be very handy to determine the size of a StaticMemoryPool.
+#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
+  ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot))
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class ObjectRef;
+template <typename>
+class ElementProxy;
+
+template <typename TData>
+class ArrayRefBase {
+ public:
+  operator VariantConstRef() const {
+    const void* data = _data;  // prevent warning cast-align
+    return VariantConstRef(reinterpret_cast<const VariantData*>(data));
+  }
+
+  template <typename Visitor>
+  FORCE_INLINE void accept(Visitor& visitor) const {
+    arrayAccept(_data, visitor);
+  }
+
+  FORCE_INLINE bool isNull() const {
+    return _data == 0;
+  }
+
+  FORCE_INLINE size_t memoryUsage() const {
+    return _data ? _data->memoryUsage() : 0;
+  }
+
+  FORCE_INLINE size_t nesting() const {
+    return _data ? _data->nesting() : 0;
+  }
+
+  FORCE_INLINE size_t size() const {
+    return _data ? _data->size() : 0;
+  }
+
+ protected:
+  ArrayRefBase(TData* data) : _data(data) {}
+  TData* _data;
+};
+
+class ArrayConstRef : public ArrayRefBase<const CollectionData>,
+                      public Visitable {
+  friend class ArrayRef;
+  typedef ArrayRefBase<const CollectionData> base_type;
+
+ public:
+  typedef ArrayConstRefIterator iterator;
+
+  FORCE_INLINE iterator begin() const {
+    if (!_data) return iterator();
+    return iterator(_data->head());
+  }
+
+  FORCE_INLINE iterator end() const {
+    return iterator();
+  }
+
+  FORCE_INLINE ArrayConstRef() : base_type(0) {}
+  FORCE_INLINE ArrayConstRef(const CollectionData* data) : base_type(data) {}
+
+  FORCE_INLINE bool operator==(ArrayConstRef rhs) const {
+    return arrayEquals(_data, rhs._data);
+  }
+
+  FORCE_INLINE VariantConstRef operator[](size_t index) const {
+    return getElement(index);
+  }
+
+  FORCE_INLINE VariantConstRef getElement(size_t index) const {
+    return VariantConstRef(_data ? _data->get(index) : 0);
+  }
+};
+
+class ArrayRef : public ArrayRefBase<CollectionData>,
+                 public ArrayShortcuts<ArrayRef>,
+                 public Visitable {
+  typedef ArrayRefBase<CollectionData> base_type;
+
+ public:
+  typedef ArrayIterator iterator;
+
+  FORCE_INLINE ArrayRef() : base_type(0), _pool(0) {}
+  FORCE_INLINE ArrayRef(MemoryPool* pool, CollectionData* data)
+      : base_type(data), _pool(pool) {}
+
+  operator VariantRef() {
+    void* data = _data;  // prevent warning cast-align
+    return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
+  }
+
+  operator ArrayConstRef() const {
+    return ArrayConstRef(_data);
+  }
+
+  VariantRef addElement() const {
+    return VariantRef(_pool, arrayAdd(_data, _pool));
+  }
+
+  FORCE_INLINE iterator begin() const {
+    if (!_data) return iterator();
+    return iterator(_pool, _data->head());
+  }
+
+  FORCE_INLINE iterator end() const {
+    return iterator();
+  }
+
+  // Copy a ArrayRef
+  FORCE_INLINE bool set(ArrayConstRef src) const {
+    if (!_data || !src._data) return false;
+    return _data->copyFrom(*src._data, _pool);
+  }
+
+  FORCE_INLINE bool operator==(ArrayRef rhs) const {
+    return arrayEquals(_data, rhs._data);
+  }
+
+  // Gets the value at the specified index.
+  FORCE_INLINE VariantRef getElement(size_t index) const {
+    return VariantRef(_pool, _data ? _data->get(index) : 0);
+  }
+
+  // Removes element at specified position.
+  FORCE_INLINE void remove(iterator it) const {
+    if (!_data) return;
+    _data->remove(it.internal());
+  }
+
+  // Removes element at specified index.
+  FORCE_INLINE void remove(size_t index) const {
+    if (!_data) return;
+    _data->remove(index);
+  }
+
+ private:
+  MemoryPool* _pool;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Array/ArrayShortcuts.hpp

@@ -0,0 +1,47 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#pragma once
+
+#include "../Polyfills/attributes.hpp"
+#include "../Polyfills/type_traits.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+// Forward declarations.
+template <typename>
+class ElementProxy;
+
+template <typename TArray>
+class ArrayShortcuts {
+ public:
+  // Returns the element at specified index if the variant is an array.
+  FORCE_INLINE ElementProxy<const TArray &> operator[](size_t index) const;
+
+  FORCE_INLINE ObjectRef createNestedObject() const;
+
+  FORCE_INLINE ArrayRef createNestedArray() const;
+
+  // Adds the specified value at the end of the array.
+  //
+  // bool add(TValue);
+  // TValue = bool, long, int, short, float, double, serialized, VariantRef,
+  //          std::string, String, ObjectRef
+  template <typename T>
+  FORCE_INLINE bool add(const T &value) const {
+    return impl()->addElement().set(value);
+  }
+  //
+  // bool add(TValue);
+  // TValue = char*, const char*, const __FlashStringHelper*
+  template <typename T>
+  FORCE_INLINE bool add(T *value) const {
+    return impl()->addElement().set(value);
+  }
+
+ private:
+  const TArray *impl() const {
+    return static_cast<const TArray *>(this);
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Array/ElementProxy.hpp

@@ -0,0 +1,165 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#pragma once
+
+#include "../Configuration.hpp"
+#include "../Operators/VariantOperators.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TArray>
+class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
+                     public Visitable {
+  typedef ElementProxy<TArray> this_type;
+
+ public:
+  FORCE_INLINE ElementProxy(TArray array, size_t index)
+      : _array(array), _index(index) {}
+
+  FORCE_INLINE this_type& operator=(const this_type& src) {
+    getUpstreamElement().set(src.as<VariantConstRef>());
+    return *this;
+  }
+
+  // Replaces the value
+  //
+  // operator=(const TValue&)
+  // TValue = bool, long, int, short, float, double, serialized, VariantRef,
+  //          std::string, String, ArrayRef, ObjectRef
+  template <typename T>
+  FORCE_INLINE this_type& operator=(const T& src) {
+    getUpstreamElement().set(src);
+    return *this;
+  }
+  //
+  // operator=(TValue)
+  // TValue = char*, const char*, const __FlashStringHelper*
+  template <typename T>
+  FORCE_INLINE this_type& operator=(T* src) {
+    getUpstreamElement().set(src);
+    return *this;
+  }
+
+  FORCE_INLINE void clear() const {
+    getUpstreamElement().clear();
+  }
+
+  FORCE_INLINE bool isNull() const {
+    return getUpstreamElement().isNull();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename VariantAs<T>::type as() const {
+    return getUpstreamElement().template as<T>();
+  }
+
+  template <typename T>
+  FORCE_INLINE bool is() const {
+    return getUpstreamElement().template is<T>();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename VariantTo<T>::type to() const {
+    return getUpstreamElement().template to<T>();
+  }
+
+  // Replaces the value
+  //
+  // bool set(const TValue&)
+  // TValue = bool, long, int, short, float, double, serialized, VariantRef,
+  //          std::string, String, ArrayRef, ObjectRef
+  template <typename TValue>
+  FORCE_INLINE bool set(const TValue& value) const {
+    return getUpstreamElement().set(value);
+  }
+  //
+  // bool set(TValue)
+  // TValue = char*, const char*, const __FlashStringHelper*
+  template <typename TValue>
+  FORCE_INLINE bool set(TValue* value) const {
+    return getUpstreamElement().set(value);
+  }
+
+  template <typename Visitor>
+  void accept(Visitor& visitor) const {
+    return getUpstreamElement().accept(visitor);
+  }
+
+  FORCE_INLINE size_t size() const {
+    return getUpstreamElement().size();
+  }
+
+  template <typename TNestedKey>
+  VariantRef getMember(TNestedKey* key) const {
+    return getUpstreamElement().getMember(key);
+  }
+
+  template <typename TNestedKey>
+  VariantRef getMember(const TNestedKey& key) const {
+    return getUpstreamElement().getMember(key);
+  }
+
+  template <typename TNestedKey>
+  VariantRef getOrAddMember(TNestedKey* key) const {
+    return getUpstreamElement().getOrAddMember(key);
+  }
+
+  template <typename TNestedKey>
+  VariantRef getOrAddMember(const TNestedKey& key) const {
+    return getUpstreamElement().getOrAddMember(key);
+  }
+
+  VariantRef addElement() const {
+    return getUpstreamElement().addElement();
+  }
+
+  VariantRef getElement(size_t index) const {
+    return getUpstreamElement().getElement(index);
+  }
+
+  FORCE_INLINE void remove(size_t index) const {
+    getUpstreamElement().remove(index);
+  }
+  // remove(char*) const
+  // remove(const char*) const
+  // remove(const __FlashStringHelper*) const
+  template <typename TChar>
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
+      TChar* key) const {
+    getUpstreamElement().remove(key);
+  }
+  // remove(const std::string&) const
+  // remove(const String&) const
+  template <typename TString>
+  FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
+      const TString& key) const {
+    getUpstreamElement().remove(key);
+  }
+
+ private:
+  FORCE_INLINE VariantRef getUpstreamElement() const {
+    return _array.getElement(_index);
+  }
+
+  TArray _array;
+  const size_t _index;
+};
+
+template <typename TArray>
+inline ElementProxy<const TArray&> ArrayShortcuts<TArray>::operator[](
+    size_t index) const {
+  return ElementProxy<const TArray&>(*impl(), index);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif