Set version to 6.13.0

https://github.com/msgpack/website/blob/master/README.md#how-to-list-up-your-project-on-msgpackorg

.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/FUNDING.yml

@@ -0,0 +1 @@
+custom: https://arduinojson.org/book/

.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

@@ -1,6 +1,12 @@
-*.sdf
-*.user
-*.suo
-Debug
-ipch
-*.opensdf
+.DS_Store
+/.idea
+/build
+/bin
+/lib
+/sftp-config.json
+.tags
+.tags_sorted_by_file
+/extras/fuzzing/*_fuzzer
+/extras/fuzzing/*_fuzzer.options
+/extras/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']
+          packages: ['clang-5.0']
+      env: SCRIPT=test _CC=clang-5.0 _CXX=clang++-5.0
+    - addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          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']
+          packages: ['clang-6.0','llvm-6.0']
+      env: SCRIPT=fuzz CLANG=6.0
+cache:
+  directories:
+    - "~/.platformio"
+    - "extras/fuzzing/json_corpus"
+    - "extras/fuzzing/msgpack_corpus"
+script: extras/ci/$SCRIPT.sh

ArduinoJson.h

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

ArduinoJson.sln

@@ -1,40 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.21005.1
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonGeneratorTests", "JsonGeneratorTests\JsonGeneratorTests.vcxproj", "{B9545D97-E084-4A19-8E48-929157064360}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonParserTests", "JsonParserTests\JsonParserTests.vcxproj", "{4DD596EF-0185-4AB4-A3C2-F20C496F7806}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonParser", "JsonParser\JsonParser.vcxproj", "{C15274DE-2695-4DFE-8520-4424223FE6DA}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonGenerator", "JsonGenerator\JsonGenerator.vcxproj", "{C6536D27-738D-4CEB-A2BC-E13C8897D894}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{B9545D97-E084-4A19-8E48-929157064360}.Debug|Win32.ActiveCfg = Debug|Win32
-		{B9545D97-E084-4A19-8E48-929157064360}.Debug|Win32.Build.0 = Debug|Win32
-		{B9545D97-E084-4A19-8E48-929157064360}.Release|Win32.ActiveCfg = Release|Win32
-		{B9545D97-E084-4A19-8E48-929157064360}.Release|Win32.Build.0 = Release|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Debug|Win32.ActiveCfg = Debug|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Debug|Win32.Build.0 = Debug|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Release|Win32.ActiveCfg = Release|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Release|Win32.Build.0 = Release|Win32
-		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Debug|Win32.ActiveCfg = Debug|Win32
-		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Debug|Win32.Build.0 = Debug|Win32
-		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Release|Win32.ActiveCfg = Release|Win32
-		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Release|Win32.Build.0 = Release|Win32
-		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Debug|Win32.ActiveCfg = Debug|Win32
-		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Debug|Win32.Build.0 = Debug|Win32
-		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Release|Win32.ActiveCfg = Release|Win32
-		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

BuildArduinoPackage.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-ZIP="C:\Program Files\7-Zip\7z.exe"
-
-TAG=$(git describe)
-OUTPUT="ArduinoJson-$TAG.zip"
-
-cd ..
-
-INPUT=$(find ArduinoJson -regex ".*\.\(cpp\|h\|md\|txt\|ino\)$" -not -regex ".*Tests/.*")
-
-rm -f $OUTPUT
-"$ZIP" a $OUTPUT $INPUT

CHANGELOG.md

@@ -1,97 +1,869 @@
-Arduino JSON: change log
-========================
+ArduinoJson: change log
+=======================
 
-v3.3
-----
+v6.13.0 (2019-11-01)
+-------
 
-* Added indented output for the JSON generator, see example bellow.
-* Added `IndentedPrint`, a decorator for `Print` to allow indented output
+* Added support for custom writer/reader classes (issue #1088)
+* Added conversion from `JsonArray` and `JsonObject` to `bool`, to be consistent with `JsonVariant`
+* Fixed `deserializeJson()` when input contains duplicate keys (issue #1095)
+* Improved `deserializeMsgPack()` speed by reading several bytes at once
+* Added detection of Atmel AVR8/GNU C Compiler (issue #1112)
+* Fixed deserializer that stopped reading at the first `0xFF` (PR #1118 by @mikee47)
+* Fixed dangling reference in copies of `MemberProxy` and `ElementProxy` (issue #1120)
 
-Example:
+v6.12.0 (2019-09-05)
+-------
 
-    JsonOject<2> json;
-    json["key"] = "value";
-    json.prettyPrintTo(Serial);
+* Use absolute instead of relative includes (issue #1072)
+* Changed `JsonVariant::as<bool>()` to return `true` for any non-null value (issue #1005)
+* Moved ancillary files to `extras/` (issue #1011)
 
-v3.2
-----
+v6.11.5 (2019-08-23)
+-------
 
-* Fixed a bug when adding nested object in `JsonArray` (bug introduced in v3.1).
+* Added fallback implementations of `strlen_P()`, `strncmp_P()`, `strcmp_P()`, and `memcpy_P()` (issue #1073)
 
-v3.1
-----
+v6.11.4 (2019-08-12)
+-------
 
-* Calling `Generator::JsonObject::add()` twice with the same `key` now replaces the `value`
-* Added `Generator::JsonObject::operator[]`, see bellow the new API
-* Added `Generator::JsonObject::remove()`
+* Added `measureJson()` to the `ArduinoJson` namespace (PR #1069 by @nomis)
+* Added support for `basic_string<char, traits, allocator>` (issue #1045)
+* Fixed example `JsonConfigFile.ino` for ESP8266
+* Include `Arduino.h` if `ARDUINO` is defined (PR #1071 by @nomis)
 
-Old generator API:
+v6.11.3 (2019-07-22)
+-------
 
-	JsonObject<3> root; 
-    root.add("sensor", "gps");
-    root.add("time", 1351824120);
-    root.add("data", array);
+* Added operators `==` and `!=` for `JsonDocument`, `ElementProxy`, and `MemberProxy`
+* Fixed comparison of `JsonVariant` when one contains a linked string and the other contains an owned string (issue #1051)
 
-New generator API:
+v6.11.2 (2019-07-08)
+-------
 
-	JsonObject<3> root; 
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
-    root["data"] = array;
+* Fixed assignment of `JsonDocument` to `JsonVariant` (issue #1023)
+* Fix invalid conversion error on Particle Argon (issue #1035)
 
-v3.0
-----
+v6.11.1 (2019-06-21)
+-------
 
-* New parser API, see bellow
-* Renamed `JsonHashTable` into `JsonObject`
-* Added iterators for `JsonArray` and `JsonObject`
+* Fixed `serialized()` not working with Flash strings (issue #1030)
 
-Old parser API:
+v6.11.0 (2019-05-26)
+-------
 
-    JsonHashTable root = parser.parseHashTable(json);
+* 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)
 
-	char*  sensor    = root.getString("sensor");
-	long   time      = root.getLong("time");
-	double latitude  = root.getArray("data").getDouble(0);
-    double longitude = root.getArray("data").getDouble(1);
+> ### 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>())`.
 
-New parser API:
+v6.10.1 (2019-04-23)
+-------
 
-	JsonObject root = parser.parse(json);
+* 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)
 
-	char*  sensor    = root["sensor"];
-    long   time      = root["time"];
-    double latitude  = root["data"][0];
-    double longitude = root["data"][1];
+v6.10.0 (2019-03-22)
+-------
 
-v2.1
-----
+* 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()`
 
-* Fixed case `#include "jsmn.cpp"` which caused an error in Linux (issue #6)
-* Fixed a buffer overrun in JSON Parser (issue #5)
+v6.9.1 (2019-03-01)
+------
 
-v2.0
-----
+* 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"
 
-* Added JSON encoding (issue #2)
-* Renamed the library `ArduinoJsonParser` becomes `ArduinoJson`
+v6.9.0 (2019-02-26)
+------
 
-**Breaking change**: you need to add the following line at the top of your program.
+* 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()`
 
-	using namespace ArduinoJson::Parser;
+v6.8.0-beta (2019-01-30)
+-----------
 
-v1.2
-----
+* 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
 
-* Fixed error in JSON parser example (issue #1)
+> ### 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));
+> ```
 
-v1.1
-----
+v6.7.0-beta (2018-12-07)
+-----------
 
-* Example: changed `char* json` into `char[] json` so that the bytes are not write protected
-* Fixed parsing bug when the JSON contains multi-dimensional arrays
+* 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
 
-v1.0 
-----
+v6.6.0-beta (2018-11-13)
+-----------
 
-Initial release
+* 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,21 @@
+# 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(extras/tests)
+add_subdirectory(extras/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)

JsonGenerator.cpp

@@ -1,15 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-// This file is here to help the Arduino IDE find the .cpp files
-
-#include "JsonGenerator/EscapedString.cpp"
-#include "JsonGenerator/IndentedPrint.cpp"
-#include "JsonGenerator/JsonArrayBase.cpp"
-#include "JsonGenerator/JsonObjectBase.cpp"
-#include "JsonGenerator/JsonValue.cpp"
-#include "JsonGenerator/JsonPrettyPrint.cpp"
-#include "JsonGenerator/JsonPrintable.cpp"
-#include "JsonGenerator/StringBuilder.cpp"

JsonGenerator.h

@@ -1,7 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonGenerator/JsonArray.h"
-#include "JsonGenerator/JsonObject.h"

JsonGenerator/EscapedString.cpp

@@ -1,45 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include "EscapedString.h"
-
-using namespace ArduinoJson::Internals;
-
-static inline char getSpecialChar(char c)
-{
-    // Optimized for code size on a 8-bit AVR
-
-    const char* p = "\"\"\\\\\bb\ff\nn\rr\tt\0";
-
-    while (p[0] && p[0] != c)
-    {
-        p += 2;
-    }
-
-    return p[1];
-}
-
-static inline size_t printCharTo(char c, Print& p)
-{
-    char specialChar = getSpecialChar(c);
-
-    return specialChar != 0
-        ? p.write('\\') + p.write(specialChar)
-        : p.write(c);
-}
-
-size_t EscapedString::printTo(const char* s, Print& p)
-{
-    if (!s) return p.print("null");
-    
-    size_t n = p.write('\"');
-
-    while (*s)
-    {
-        n += printCharTo(*s++, p);
-    }
-
-    return n + p.write('\"');
-}

JsonGenerator/EscapedString.h

@@ -1,20 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "Print.h"
-
-namespace ArduinoJson
-{
-    namespace Internals
-    {
-        class EscapedString
-        {
-        public:
-            static size_t printTo(const char*, Print&);
-        };
-    }
-}

JsonGenerator/IndentedPrint.cpp

@@ -1,45 +0,0 @@
-#include "IndentedPrint.h"
-
-using namespace ArduinoJson::Generator;
-
-void IndentedPrint::indent()
-{
-    if (level < MAX_LEVEL)
-        level++;
-}
-
-void IndentedPrint::unindent()
-{
-    if (level > 0)
-        level--;
-}
-
-void IndentedPrint::setTabSize(uint8_t n)
-{
-    if (n < MAX_TAB_SIZE)
-        tabSize = n;
-}
-
-size_t IndentedPrint::write(uint8_t c)
-{
-    size_t n = 0;
-
-    if (isNewLine)
-        n += writeTabs();
-
-    n += sink.write(c);
-
-    isNewLine = c == '\n';
-
-    return n;
-}
-
-inline size_t IndentedPrint::writeTabs()
-{
-    size_t n = 0;
-
-    for (int i = 0; i < level*tabSize; i++)
-        n += sink.write(' ');
-
-    return n;
-}

JsonGenerator/IndentedPrint.h

@@ -1,53 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "Print.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        // Decorator on top of Print to allow indented output.
-        // This class is used by JsonPrintable::prettyPrintTo() but can also be used
-        // for your own purpose, like logging.
-        class IndentedPrint : public Print
-        {
-        public:
-
-            IndentedPrint(Print& p)
-                : sink(p)
-            {
-                level = 0;
-                tabSize = 2;
-                isNewLine = true;
-            }
-
-            virtual size_t write(uint8_t);
-
-            // Adds one level of indentation
-            void indent();
-
-            // Removes one level of indentation
-            void unindent();
-
-            // Set the number of space printed for each level of indentation
-            void setTabSize(uint8_t n);
-
-        private:
-            Print& sink;
-            uint8_t level : 4;
-            uint8_t tabSize : 3;
-            bool isNewLine : 1;
-            
-            size_t writeTabs();
-
-            static const int MAX_LEVEL = 15; // because it's only 4 bits
-            static const int MAX_TAB_SIZE = 7; // because it's only 3 bits
-        };
-    }
-}
-

JsonGenerator/JsonArray.h

@@ -1,28 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonArrayBase.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        template<int N>
-        class JsonArray : public JsonArrayBase
-        {
-        public:
-            JsonArray()
-                : JsonArrayBase(items, N)
-            {
-
-            }         
-
-        private:
-            JsonValue items[N];
-        };
-    }
-}

JsonGenerator/JsonArrayBase.cpp

@@ -1,34 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArrayBase.h"
-
-using namespace ArduinoJson::Generator;
-using namespace ArduinoJson::Internals;
-
-size_t JsonArrayBase::printTo(Print& p) const
-{
-    size_t n = 0;
-
-    n += p.write('[');
-
-    // NB: the code has been optimized for a small size on a 8-bit AVR
-
-    const JsonValue* current = items;
-    for (int i = count; i > 0; i--)
-    {       
-        n += current->printTo(p);
-        current++;
-
-        if (i > 1)
-        {
-            n += p.write(',');
-        }
-    }
-
-    n += p.write(']');
-
-    return n;
-}

JsonGenerator/JsonArrayBase.h

@@ -1,79 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonPrintable.h"
-#include "JsonValue.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        class JsonArrayBase : public JsonPrintable
-        {
-        public:
-            JsonArrayBase(JsonValue* items, int capacity)
-                : items(items), capacity(capacity), count(0)
-            {
-
-            }
-
-            void add(const Printable& value)
-            {
-                addIfPossible<const Printable&>(value);
-            }
-
-            void add(bool value)
-            {
-                addIfPossible<bool>(value);
-            }
-
-            void add(int value)
-            {
-                addIfPossible<long>(value);
-            }
-
-            void add(long value)
-            {
-                addIfPossible<long>(value);
-            }
-
-            void add(double value)
-            {
-                addIfPossible<double>(value);
-            }
-
-            void add(const char* value)
-            {
-                addIfPossible<const char*>(value);
-            }
-
-            template<int DIGITS>
-            void add(double value)
-            {
-                if (count >= capacity) return;
-
-                JsonValue& v = items[count++];
-                v.set<DIGITS>(value);
-            }
-
-            virtual size_t printTo(Print& p) const;
-
-            using JsonPrintable::printTo;
-
-        private:
-            JsonValue* items;
-            int capacity, count;
-
-            template<typename T>
-            void addIfPossible(T value)
-            {
-                if (count < capacity)
-                    items[count++] = value;
-            }
-        };
-    }
-}

JsonGenerator/JsonGenerator.vcxproj

@@ -1,101 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="EscapedString.h" />
-    <ClInclude Include="IndentedPrint.h" />
-    <ClInclude Include="JsonPrettyPrint.h" />
-    <ClInclude Include="JsonArray.h" />
-    <ClInclude Include="JsonArrayBase.h" />
-    <ClInclude Include="JsonObject.h" />
-    <ClInclude Include="JsonObjectBase.h" />
-    <ClInclude Include="JsonPrintable.h" />
-    <ClInclude Include="JsonValue.h" />
-    <ClInclude Include="Print.h" />
-    <ClInclude Include="Printable.h" />
-    <ClInclude Include="StringBuilder.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="EscapedString.cpp" />
-    <ClCompile Include="IndentedPrint.cpp" />
-    <ClCompile Include="JsonPrettyPrint.cpp" />
-    <ClCompile Include="JsonArrayBase.cpp" />
-    <ClCompile Include="JsonObjectBase.cpp" />
-    <ClCompile Include="JsonPrintable.cpp" />
-    <ClCompile Include="JsonValue.cpp" />
-    <ClCompile Include="Print.cpp" />
-    <ClCompile Include="StringBuilder.cpp" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{C6536D27-738D-4CEB-A2BC-E13C8897D894}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>JsonGenerator</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup />
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

JsonGenerator/JsonGenerator.vcxproj.filters

@@ -1,84 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="EscapedString.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonArrayBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonPrintable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonValue.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Print.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Printable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="StringBuilder.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonObjectBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonObject.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="IndentedPrint.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonPrettyPrint.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="EscapedString.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonArrayBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonValue.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="StringBuilder.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Print.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonObjectBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="IndentedPrint.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonPrettyPrint.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonPrintable.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

JsonGenerator/JsonObject.h

@@ -1,44 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonObjectBase.h"
-
-#ifndef ARDUINO_JSON_NO_DEPRECATION_WARNING
-#ifdef __GNUC__
-#define DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#define DEPRECATED __declspec(deprecated)
-#endif
-#else
-#define DEPRECATED
-#endif
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        template <int N>
-        class JsonObject : public JsonObjectBase
-        {
-        public:
-            JsonObject()
-                : JsonObjectBase(items, N)
-            {
-            }
-
-        private:
-            KeyValuePair items[N];
-        };
-
-        
-        // Obsolete: use JsonObject instead
-        template <int N>
-        class DEPRECATED JsonHashTable : public JsonObject<N>
-        {            
-        };
-    }
-}

JsonGenerator/JsonObjectBase.cpp

@@ -1,92 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonObjectBase.h"
-#include <string.h> // for strcmp
-
-using namespace ArduinoJson::Generator;
-using namespace ArduinoJson::Internals;
-
-JsonValue JsonObjectBase::nullValue;
-
-size_t JsonObjectBase::printTo(Print& p) const
-{
-    size_t n = 0;
-
-    n += p.write('{');
-
-    // NB: the code has been optimized for a small size on a 8-bit AVR
-
-    const KeyValuePair* current = items;
-    for (int i = count; i > 0; i--)
-    {       
-        n += EscapedString::printTo(current->key, p);
-        n += p.write(':');
-        n += current->value.printTo(p);
-
-        current++;
-
-        if (i > 1)
-        {
-            n += p.write(',');
-        }
-    }
-
-    n += p.write('}');
-
-    return n;
-}
-
-JsonObjectBase::KeyValuePair* JsonObjectBase::getMatchingPair(JsonKey key) const
-{
-    KeyValuePair* p = items;
-
-    for (int i = count; i > 0; --i)
-    {
-        if (!strcmp(p->key, key))
-            return p;
-
-        p++;
-    }
-
-    return 0;
-}
-
-JsonValue& JsonObjectBase::operator[](JsonKey key)
-{
-    KeyValuePair* match = getMatchingPair(key);
-
-    if (match)
-        return match->value;
-
-    JsonValue* value;
-
-    if (count < capacity)
-    {
-        items[count].key = key;
-        value = &items[count].value;
-        count++;
-    }
-    else
-    {
-        value = &nullValue;
-    }
-
-    value->reset();
-    return *value;
-}
-
-bool JsonObjectBase::containsKey(JsonKey key) const
-{
-    return getMatchingPair(key) != 0;
-}
-
-void JsonObjectBase::remove(JsonKey key)
-{
-    KeyValuePair* match = getMatchingPair(key);    
-    if (match == 0) return;
-
-    *match = items[--count];
-}

JsonGenerator/JsonObjectBase.h

@@ -1,62 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonPrintable.h"
-#include "JsonValue.h"
-#include "EscapedString.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        typedef const char* JsonKey;
-
-        class JsonObjectBase : public JsonPrintable
-        {
-        public:
-            JsonValue& operator[](JsonKey);
-            bool containsKey(JsonKey) const;
-            void remove(JsonKey key);
-
-            template<typename T>
-            void add(JsonKey key, T value)
-            {
-                operator[](key) = value;
-            }
-
-            template<int DIGITS>
-            void add(JsonKey key, double value)
-            {
-                operator[](key).set<DIGITS>(value);
-            }
-
-            using JsonPrintable::printTo;
-
-            virtual size_t printTo(Print& p) const;
-
-        protected:
-
-            struct KeyValuePair
-            {
-                JsonKey     key;
-                JsonValue   value;
-            };
-
-            JsonObjectBase(KeyValuePair* items, int capacity)
-                : items(items), capacity(capacity), count(0)
-            {
-            }
-
-        private:
-            KeyValuePair* items;
-            int capacity, count;
-            static JsonValue nullValue;
-
-            KeyValuePair* getMatchingPair(JsonKey key) const;
-        };
-    }
-}

JsonGenerator/JsonPrettyPrint.cpp

@@ -1,97 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonPrettyPrint.h"
-
-using namespace ArduinoJson::Generator;
-
-size_t JsonPrettyPrint::write(uint8_t c)
-{
-    size_t n = inString ? handleStringChar(c) : handleMarkupChar(c);    
-    previousChar = c;
-    return n;
-}
-
-inline size_t JsonPrettyPrint::handleStringChar(uint8_t c)
-{
-    bool isQuote = c == '"' && previousChar != '\\';
-
-    if (isQuote) inString = false;
-
-    return sink.write(c);
-}
-
-inline size_t JsonPrettyPrint::handleMarkupChar(uint8_t c)
-{
-    switch (c)
-    {
-    case '{':
-    case '[':
-        return handleBlockOpen(c);
-
-    case '}':
-    case ']':
-        return handleBlockClose(c);
-
-    case ':':
-        return handleColumn();
-
-    case ',':
-        return handleComma();
-
-    case '"':
-        return handleQuoteOpen();
-
-    default:
-        return handleNormalChar(c);
-    }
-}
-
-inline size_t JsonPrettyPrint::handleBlockOpen(uint8_t c)
-{
-    return indentIfNeeded() + sink.write(c);
-}
-
-inline size_t JsonPrettyPrint::handleBlockClose(uint8_t c)
-{  
-    return unindentIfNeeded() + sink.write(c);
-}
-
-inline size_t JsonPrettyPrint::handleColumn()
-{
-    return sink.write(':') + sink.write(' ');
-}
-
-inline size_t JsonPrettyPrint::handleComma() 
-{
-    return sink.write(',') + sink.println();
-}
-
-inline size_t JsonPrettyPrint::handleQuoteOpen()
-{
-    inString = true;
-    return indentIfNeeded() + sink.write('"');
-}
-
-inline size_t JsonPrettyPrint::handleNormalChar(uint8_t c)
-{
-    return indentIfNeeded() + sink.write(c);
-}
-
-size_t JsonPrettyPrint::indentIfNeeded()
-{
-    if (!inEmptyBlock()) return 0;
-
-    sink.indent();
-    return sink.println();
-}
-
-size_t JsonPrettyPrint::unindentIfNeeded()
-{
-    if (inEmptyBlock()) return 0;
-
-    sink.unindent();
-    return sink.println();
-}

JsonGenerator/JsonPrettyPrint.h

@@ -1,52 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "Print.h"
-#include "IndentedPrint.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        // Converts a compact JSON string into an indented one.
-        class JsonPrettyPrint : public Print
-        {
-        public:
-
-            JsonPrettyPrint(IndentedPrint& p)
-                : sink(p)
-            {
-                previousChar = 0;
-                inString = false;
-            }
-
-            virtual size_t write(uint8_t);
-
-        private:            
-            uint8_t previousChar;
-            IndentedPrint& sink;
-            bool inString;
-
-            bool inEmptyBlock()
-            {
-                return previousChar == '{' || previousChar == '[';
-            }
-
-            size_t handleStringChar(uint8_t);
-            size_t handleMarkupChar(uint8_t);
-
-            size_t handleBlockClose(uint8_t);
-            size_t handleBlockOpen(uint8_t);
-            size_t handleColumn();
-            size_t handleComma();
-            size_t handleQuoteOpen();
-            size_t handleNormalChar(uint8_t);
-            size_t indentIfNeeded();
-            size_t unindentIfNeeded();
-        };
-    }
-}

JsonGenerator/JsonPrintable.cpp

@@ -1,35 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonPrintable.h"
-#include "JsonPrettyPrint.h"
-#include "StringBuilder.h"
-
-using namespace ArduinoJson::Generator;
-using namespace ArduinoJson::Internals;
-
-size_t JsonPrintable::printTo(char* buffer, size_t bufferSize) const
-{
-    StringBuilder sb(buffer, bufferSize);
-    return printTo(sb);
-}
-
-size_t JsonPrintable::prettyPrintTo(char* buffer, size_t bufferSize) const
-{
-    StringBuilder sb(buffer, bufferSize);
-    return prettyPrintTo(sb);
-}
-
-size_t JsonPrintable::prettyPrintTo(IndentedPrint& p) const
-{
-    JsonPrettyPrint prettyPrint(p);
-    return printTo(prettyPrint);
-}
-
-size_t JsonPrintable::prettyPrintTo(Print& p) const
-{
-    IndentedPrint indentedPrint(p);
-    return prettyPrintTo(indentedPrint);
-}

JsonGenerator/JsonPrintable.h

@@ -1,40 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "Print.h"
-#include "Printable.h"
-#include "IndentedPrint.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        // Contains methods to generate a JSON string.
-        // Implemented by both JsonObject and JsonArray
-        class JsonPrintable : public Printable
-        {
-        public:
-
-            // Generates the compact JSON string and sends it to a Print stream 
-            virtual size_t printTo(Print& p) const = 0;
-
-            // Generates the compact JSON string and writes it in a buffer
-            size_t printTo(char* buffer, size_t bufferSize) const;
-
-            // Generates the indented JSON string and sends it to a Print stream
-            size_t prettyPrintTo(Print& p) const;
-
-            // Generates the indented JSON string and sends it to a IndentedPrint stream
-            // This overload allows a finer control of the output because you can customize
-            // the IndentedPrint.
-            size_t prettyPrintTo(IndentedPrint& p) const;
-
-            // Generates the indented JSON string and writes it in a buffer
-            size_t prettyPrintTo(char* buffer, size_t bufferSize) const;
-        };
-    }
-}

JsonGenerator/JsonValue.cpp

@@ -1,33 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include "EscapedString.h"
-#include "JsonValue.h"
-
-using namespace ArduinoJson::Generator;
-using namespace ArduinoJson::Internals;
-
-size_t JsonValue::printBoolTo(const Content& c, Print& p)
-{
-    return p.print(c.asBool ? "true" : "false");
-}
-
-size_t JsonValue::printLongTo(const Content& c, Print& p)
-{
-    return p.print(c.asLong);
-}
-
-size_t JsonValue::printPrintableTo(const Content& c, Print& p)
-{
-    if (c.asPrintable)
-        return c.asPrintable->printTo(p);
-    else
-        return p.print("null");
-}
-
-size_t JsonValue::printStringTo(const Content& c, Print& p)
-{
-    return EscapedString::printTo(c.asString, p);
-}

JsonGenerator/JsonValue.h

@@ -1,135 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "EscapedString.h"
-#include "Printable.h"
-#include "StringBuilder.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        class JsonValue
-        {
-        public:
-
-            void operator=(bool value)
-            {
-                printToImpl = &printBoolTo;
-                content.asBool = value;
-            }
-
-            void operator=(long value)
-            {
-                printToImpl = &printLongTo;
-                content.asLong = value;
-            }
-
-            void operator=(int value)
-            {
-                printToImpl = &printLongTo;
-                content.asLong = value;
-            }
-
-            void operator=(const Printable& value)
-            {
-                printToImpl = &printPrintableTo;
-                content.asPrintable = &value;
-            }
-
-            void operator=(const char* value)
-            {
-                printToImpl = &printStringTo;
-                content.asString = value;
-            }
-
-            void operator=(double value)
-            {
-                set<2>(value);
-            }
-
-            template <int DIGITS>
-            void set(double value)
-            {
-                printToImpl = &printDoubleTo < DIGITS > ;
-                content.asDouble = value;
-            }
-
-            operator bool()
-            {
-                return content.asBool;
-            }
-
-            operator const char*()
-            {
-                return content.asString;
-            }
-
-            operator double()
-            {
-                return content.asDouble;
-            }
-
-            operator float()
-            {
-                return (float)content.asDouble;
-            }
-
-            operator int()
-            {
-                return content.asLong;
-            }
-
-            operator long()
-            {
-                return content.asLong;
-            }
-
-            operator const Printable&()
-            {
-                return *content.asPrintable;
-            }
-
-            size_t printTo(Print& p) const
-            {
-                // handmade polymorphism
-                return printToImpl(content, p);
-            }
-
-            void reset()
-            {
-                content.asDouble = 0;
-                printToImpl = printStringTo;
-            }
-
-        private:
-            union Content
-            {
-                bool                asBool;
-                double              asDouble;
-                long                asLong;
-                const Printable*    asPrintable;
-                const char*         asString;
-            };
-
-            Content content;
-
-            size_t(*printToImpl)(const Content&, Print&);
-
-            static size_t printBoolTo(const Content&, Print&);
-            static size_t printLongTo(const Content&, Print&);
-            static size_t printPrintableTo(const Content&, Print&);
-            static size_t printStringTo(const Content&, Print&);
-
-            template <int DIGITS>
-            static size_t printDoubleTo(const Content& c, Print& p)
-            {
-                return p.print(c.asDouble, DIGITS);
-            }
-        };
-    }
-}

JsonGenerator/Print.cpp

@@ -1,40 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#ifndef ARDUINO
-
-#include "Print.h"
-#include <cstdio>
-
-size_t Print::print(const char s[])
-{
-    size_t n = 0;
-    while (*s)
-    {
-        n += write(*s++);
-    }
-    return n;
-}
-
-size_t Print::print(double value, int digits)
-{
-    char tmp[32];
-    sprintf(tmp, "%.*lg", digits+1, value);
-    return print(tmp);
-}
-
-size_t Print::print(long value)
-{
-    char tmp[32];
-    sprintf(tmp, "%ld", value);
-    return print(tmp);
-}
-
-size_t Print::println()
-{
-    return write('\r') + write('\n');
-}
-
-#endif

JsonGenerator/Print.h

@@ -1,29 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#ifndef ARDUINO
-
-typedef unsigned char uint8_t;
-
-// This class reproduces Arduino's Print
-class Print
-{
-public:
-
-    virtual size_t write(uint8_t) = 0;
-
-    size_t print(const char[]);
-    size_t print(double, int = 2);
-    size_t print(long);
-    size_t println();
-};
-
-#else
-
-#include <Print.h>
-
-#endif

JsonGenerator/Printable.h

@@ -1,24 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#ifndef ARDUINO
-
-class Print;
-
-class Printable
-{
-public:
-
-    virtual size_t printTo(Print& p) const = 0;
-};
-
-#else
-
-#include <Printable.h>
-
-#endif
-

JsonGenerator/README.md

@@ -1,247 +0,0 @@
-Arduino JSON library - Generator
-================================
-
-*An elegant and efficient JSON encoder for embedded systems.*
-
-It's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
-
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
-
-
-Features
---------
-
-* Elegant API, very easy to use 
-* Fixed memory allocation (no malloc)
-* Small footprint
-* Supports nested objects
-* Supports indented output
-* Implements Arduino's `Printable interface
-* MIT License
-
-
-Example
--------
-
-    JsonArray<2> array;
-    array.add<6>(48.756080);  // <6> specifies the number of digits in the output
-    array.add<6>(2.302038);   // (the default is 2)
-
-    JsonObject<3> root;
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
-    root["data"] = array;
-
-    Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
-
-
-How to  use?
-------------
-
-### 1. Install the library
-
-Download the library and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJson
-
-### 2. Import in your sketch
-
-Just add the following lines at the top of your `.ino` file:
-
-    #include <JsonGenerator.h>
-
-    using namespace ArduinoJson::Generator;
-
-> ##### Having a namespace conflict?
-> To be able to use both `ArduinoJson::Generator` and `ArduinoJson::Parser` in the same file, you need to do one of the followings:
-> 
-> * Put the `using` statements into different functions
-> * `using namespace ArduinoJson`, then prefix the type names by `Generator::` or `Parser::`
-> * Create aliases for the namespaces or the types (C++11 only)
-   
-### 3. Create object tree
-
-In order to generate a JSON string, you need to build the equivalent object tree. You usually start by the root which can be either a JSON Array or a JSON Object.
-
-#### JSON Array
-
-You create an array with the following line:
-
-    JsonArray<8> array;
-
-See the little `<8>`? It's a template parameter that gives the capacity of the array, it's the maximum number of elements you can put in it. 
-
-> ##### About the capacity
-> As stated in the feature list, this library works with a fixed memory allocation.
-> This means that the size of the object must be know at the compilation time, therefore you can **not** use a variable to set the capacity of the array.
-
-Then you can add strings, integer, booleans, etc: 
-
-    array.add("bazinga!");
-    array.add(42);
-    array.add(true);
-
-There are two syntaxes for floating point values:
-
-	array.add<4>(3.1415);  // 4 digits: "3.1415" 
-    array.add(3.14);	   // 2 digits: "3.14"
-
-> ##### About floating point precision
-> The overload of `add()` with 2 parameters allows you to specify the number of decimals to save in the JSON string. 
-> When you use the overload with one parameter, you use the default number of decimals which is two.
-> Note that this behavior is the exact same as Arduino's `Print::print(double,int);` which is implemented by `Serial`. 
-> So you may already be familiar with it. 
-
-Finally you can add nested object to the array:
-
-    JsonArray<8> nestedArray;
-    array.add(nestedArray);
-
-or
-
-    JsonObject<8> nestedObject;
-    array.add(nestedObject);
-
-> ##### CAUTION! Nested objects must be in memory
-> Calling `add()` makes the `JsonArray` store a pointer to the nested object.
-> This is designed to avoid memory duplication.
-> But it can only work if the object is in memory when `printTo()` is executed.
-> For instance, don't do this:
-> 
->     void addNestedObject()
->     {
->         JsonObject<2> nestedObject;
->         // ...
->         array.add(nestedObject); // <- DON'T !!
->         
->         // array now contains a pointer to a local variable that will be
->         // discarded as soon as the function exits 
->     } 
->     
-> For the same reason, don't do this either:
-> 
->     for( int i=0; i<100; i++)
->     {
->         JsonObject<2> nestedObject;
->         // ...
->         array.add(nestedObject); // <- DON'T !!
->     }  
->     // array now contains 100 pointers to the same a local variable
->     // that is out of the scope anyway
-
-#### JSON Object
-
-You create a JSON object (ie hash-table/dictionary) with the following line:
-
-    JsonObject<8> object;
-
-Like with the array class, there is a template parameter that gives the capacity of the object.
-
-Then you can add strings, integer, booleans, etc: 
-
-    object["key1"] = "bazinga!";
-    object["key2"] = 42;
-    object["key3"] = true;
-
-As for the arrays, there are two syntaxes for the floating point values:
-
-	object["key4"].set<4>(3.1415);  // 4 digits "3.1415" 
-    object["key5"] = 3.1415;	    // default: 2 digits "3.14"
-
-Finally you can add nested objects:
-
-    JsonArray<8> nestedArray;
-    object["key6"] = nestedArray;
-
-or
-
-    JsonObject<8> nestedObject;
-    object["key7"] = nestedObject;
-
-> ##### Other JsonObject functions
-> * `object.add(key, value)` is a synonym for `object[key] = value`
-> * `object.containsKey(key)` returns `true` is the `key` is present in `object`
-> * `object.remove(key)` removes the `value` associated with `key`
-
-### 4. Get the JSON string
-
-There are two ways tho get the resulting JSON string.
-
-Depending on your project, you may need to dump the string in a classic `char[]` or send it to a stream like `Serial` or `EthernetClient `.
-
-Both ways are the easy way :-)
-
-#### Use a classic `char[]`
-
-Whether you have a `JsonArray` or a `JsonObject`, simply call `printTo()` with the destination buffer, like so:
-
-	char buffer[256];
-    array.printTo(buffer, sizeof(buffer));
-
-> ##### Want an indented output?
-> By default the generated JSON is as small as possible. It contains no extra space, nor line break.
-> But if you want an indented, more readable output, you can.
-> Simply call `prettyPrintTo` instead of `printTo()`:
-> 
->     array.prettyPrintTo(buffer, sizeof(buffer));
-
-#### Send to a stream
-
-It's very likely that the generated JSON will end up in a stream like `Serial` or `EthernetClient `, so you can save some time and memory by doing this:
-
-	Serial.print(array);
-
-or
-  
-    array.printTo(Serial);
-
-> ##### About the Printable interface
-> `JsonArray` and `JsonObject` implement Arduino's `Printable` interface.
-> This is why you can call `Serial.print()` like in the example above.
-> You can do the same with any other implementation of `Print`:  `HardwareSerial`,  `SoftwareSerial`, `LiquidCrystal`, `EthernetClient`, `WiFiClient`, `Wire`...
-   
-
-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.
-
-| Type                | Size in bytes |
-| --------------------| ------------- |
-| JsonArray&lt;N&gt;  | 8 + 6 x N     |
-| JsonObject&lt;N&gt; | 8 + 8 x N     |
-
-
-Code size
----------
-
-The following values has been obtained with Arduino IDE 1.0.5, targeting an Arduino Duelmilanove with an ATmega 328.
-
-### Minimum setup
-
-| Function                            | Size |
-| ----------------------------------- | ---- |
-| `JsonObjectBase::printTo()`         | 234  |
-| `EscapedString::printTo()`          | 196  |
-| `JsonArrayBase::printTo()`          | 164  |
-| `Print::print(char const*)`         | 146  |
-| `JsonObjectBase::operator[]`        | 114  |
-| `JsonObjectBase::getMatchingPair()` | 72   |
-| `JsonValue::printPrintableTo()`     | 40   |
-| `JsonValue::printStringTo()`        | 12   |
-
-### Additional space for integers
-
-| Function                     | Size |
-| ---------------------------- | ---- |
-| `Print::print(long, int)`    | 328  |
-| `JsonValue::printLongTo()`   | 22   |
-
-### Additional space for floating point
-
-| Function                       | Size |
-| ------------------------------ | ---- |
-| `Print::print(double, int)`    | 1548 |
-| `JsonValue::printDouleTo<2>()` | 22   |

JsonGenerator/StringBuilder.cpp

@@ -1,17 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include "StringBuilder.h"
-
-using namespace ArduinoJson::Internals;
-
-size_t StringBuilder::write(uint8_t c)
-{
-    if (length >= capacity) return 0;
-
-    buffer[length++] = c;
-    buffer[length] = 0;
-    return 1;
-}

JsonGenerator/StringBuilder.h

@@ -1,31 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "Print.h"
-
-namespace ArduinoJson
-{
-    namespace Internals
-    {
-        class StringBuilder : public Print
-        {
-        public:
-            StringBuilder(char* buf, int size)
-                : buffer(buf), capacity(size - 1), length(0)
-            {
-                buffer[0] = 0;
-            }
-
-            virtual size_t write(uint8_t c);
-
-        private:
-            char* buffer;
-            int capacity;
-            int length;
-        };
-    }
-}

JsonGeneratorTests/EscapedStringTests.cpp

@@ -1,95 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "EscapedString.h"
-#include "StringBuilder.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Internals;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(EscapedStringTests)
-    {
-        char buffer[1024];
-        size_t returnValue;
-        
-    public:
-
-        TEST_METHOD(Null)
-        {
-            whenInputIs(0);
-            outputMustBe("null");
-        }
-
-        TEST_METHOD(EmptyString)
-        {
-            whenInputIs("");
-            outputMustBe("\"\"");
-        }
-
-        TEST_METHOD(QuotationMark)
-        {
-            whenInputIs("\"");
-            outputMustBe("\"\\\"\"");
-        }
-
-        TEST_METHOD(ReverseSolidus)
-        {
-            whenInputIs("\\");
-            outputMustBe("\"\\\\\"");
-        }
-
-        TEST_METHOD(Solidus)
-        {
-            whenInputIs("/");
-            outputMustBe("\"/\""); // but the JSON format allows \/
-        }
-
-        TEST_METHOD(Backspace)
-        {
-            whenInputIs("\b");
-            outputMustBe("\"\\b\"");
-        }
-
-        TEST_METHOD(Formfeed)
-        {
-            whenInputIs("\f");
-            outputMustBe("\"\\f\"");
-        }
-
-        TEST_METHOD(Newline)
-        {
-            whenInputIs("\n");
-            outputMustBe("\"\\n\"");
-        }
-
-        TEST_METHOD(CarriageReturn)
-        {
-            whenInputIs("\r");
-            outputMustBe("\"\\r\"");
-        }
-
-        TEST_METHOD(HorizontalTab)
-        {
-            whenInputIs("\t");
-            outputMustBe("\"\\t\"");
-        }
-
-    private:
-        void whenInputIs(const char* input)
-        {
-            StringBuilder sb(buffer, sizeof(buffer));  
-            returnValue = EscapedString::printTo(input, sb);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), returnValue);
-        }
-    };
-}

JsonGeneratorTests/Issue10.cpp

@@ -1,73 +0,0 @@
-#include "CppUnitTest.h"
-#include "JsonArray.h"
-#include "JsonObject.h"
-
-using namespace ArduinoJson::Generator;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(Issue10)
-    {
-        struct Person {
-            int id;
-            char name[32];
-        };
-
-        Person persons[2];
-
-    public:
-
-        TEST_METHOD_INITIALIZE(Initialize)
-        {
-            Person boss;
-            boss.id = 1;
-            strcpy(boss.name, "Jeff");
-            Person employee;
-            employee.id = 2;
-            strcpy(employee.name, "John");
-            persons[0] = boss;
-            persons[1] = employee;
-        }
-
-        TEST_METHOD(WrongWayToAddObjectInAnArray)
-        {
-            JsonArray<2> json;
-
-            for (int i = 0; i < 2; i++)
-            {
-                JsonObject<2> object;
-                
-                object["id"] = persons[i].id;
-                object["name"] = persons[i].name;
-
-                json.add(object); // <- Adding a reference to a temporary variable
-            }
-
-            char buffer[256];
-            json.printTo(buffer, sizeof(buffer));
-
-            // the same values are repeated, that's normal
-            Assert::AreEqual("[{\"id\":2,\"name\":\"John\"},{\"id\":2,\"name\":\"John\"}]", buffer);  
-        }
-
-        TEST_METHOD(RightWayToAddObjectInAnArray)
-        {
-            JsonArray<2> json;
-            JsonObject<2> object[2];
-
-            for (int i = 0; i < 2; i++) 
-            {
-                object[i]["id"] = persons[i].id;
-                object[i]["name"] = persons[i].name;
-
-                json.add(object[i]);
-            }
-
-            char buffer[256];
-            json.printTo(buffer, sizeof(buffer));
-
-            Assert::AreEqual("[{\"id\":1,\"name\":\"Jeff\"},{\"id\":2,\"name\":\"John\"}]", buffer);
-        }
-    };
-}

JsonGeneratorTests/JsonArrayTests.cpp

@@ -1,162 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonArray.h"
-#include "JsonObject.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Generator;
-
-namespace JsonGeneratorTests
-{		
-    TEST_CLASS(JsonArrayTests)
-    {
-        JsonArray<2> array;
-        char buffer[256];
-
-    public:
-        
-        TEST_METHOD(Empty)
-        {
-            outputMustBe("[]");
-        }
-
-        TEST_METHOD(Null)
-        {
-            array.add((char*) 0);
-
-            outputMustBe("[null]");
-        }
-
-        TEST_METHOD(OneString)
-        {
-            array.add("hello");
-
-            outputMustBe("[\"hello\"]");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            array.add("hello");
-            array.add("world");
-
-            outputMustBe("[\"hello\",\"world\"]");
-        }
-
-        TEST_METHOD(OneStringOverCapacity)
-        {
-            array.add("hello");
-            array.add("world");
-            array.add("lost");
-
-            outputMustBe("[\"hello\",\"world\"]");
-        }
-
-        TEST_METHOD(OneDoubleDefaultDigits)
-        {
-            array.add(3.14159265358979323846);
-            outputMustBe("[3.14]");
-        }
-
-        TEST_METHOD(OneDoubleFourDigits)
-        {
-            array.add<4>(3.14159265358979323846);
-            outputMustBe("[3.1416]");
-        }
-
-        TEST_METHOD(OneInteger)
-        {
-            array.add(1);
-
-            outputMustBe("[1]");
-        }
-
-        TEST_METHOD(TwoIntegers)
-        {
-            array.add(1);
-            array.add(2);
-
-            outputMustBe("[1,2]");
-        }
-
-        TEST_METHOD(OneIntegerOverCapacity)
-        {
-            array.add(1);
-            array.add(2);
-            array.add(3);
-
-            outputMustBe("[1,2]");
-        }
-
-        TEST_METHOD(OneTrue)
-        {
-            array.add(true);
-
-            outputMustBe("[true]");
-        }
-
-        TEST_METHOD(OneFalse)
-        {
-            array.add(false);
-
-            outputMustBe("[false]");
-        }
-
-        TEST_METHOD(TwoBooleans)
-        {
-            array.add(false);
-            array.add(true);
-
-            outputMustBe("[false,true]");
-        }
-
-        TEST_METHOD(OneBooleanOverCapacity)
-        {
-            array.add(false);
-            array.add(true);
-            array.add(false);
-
-            outputMustBe("[false,true]");
-        }
-
-        TEST_METHOD(OneEmptyNestedArray)
-        {
-            JsonArray<1> nestedArray;
-            
-            array.add(nestedArray);
-
-            outputMustBe("[[]]");
-        }
-
-        TEST_METHOD(OneEmptyNestedHash)
-        {
-            JsonObject<1> nestedObject;
-
-            array.add(nestedObject);
-
-            outputMustBe("[{}]");
-        }
-
-        TEST_METHOD(OneNestedArrayWithOneInteger)
-        {
-            JsonArray<1> nestedArray;
-            nestedArray.add(1);
-
-            array.add(nestedArray);
-
-            outputMustBe("[[1]]");
-        }
-
-    private:
-
-        void outputMustBe(const char* expected)
-        {      
-            size_t n = array.printTo(buffer, sizeof(buffer));
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), n);
-        }
-    };
-}

JsonGeneratorTests/JsonGeneratorTests.vcxproj

@@ -1,107 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{B9545D97-E084-4A19-8E48-929157064360}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>JsonGeneratorTests</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir)/../JsonGenerator;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir)/../JsonGenerator;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>ARDUINO_JSON_NO_DEPRECATION_WARNING;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="EscapedStringTests.cpp" />
-    <ClCompile Include="PrettyPrint_Array_Tests.cpp" />
-    <ClCompile Include="PrettyPrint_Object_Tests.cpp" />
-    <ClCompile Include="PrettyPrint_String_Tests.cpp" />
-    <ClCompile Include="Issue10.cpp" />
-    <ClCompile Include="JsonArrayTests.cpp" />
-    <ClCompile Include="JsonObject_Indexer_Tests.cpp" />
-    <ClCompile Include="JsonObject_PrintTo_Tests.cpp" />
-    <ClCompile Include="JsonValue_Cast_Tests.cpp" />
-    <ClCompile Include="JsonValue_PrintTo_Tests.cpp" />
-    <ClCompile Include="StringBuilderTests.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\JsonGenerator\JsonGenerator.vcxproj">
-      <Project>{c6536d27-738d-4ceb-a2bc-e13c8897d894}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

JsonGeneratorTests/JsonGeneratorTests.vcxproj.filters

@@ -1,52 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="JsonArrayTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="StringBuilderTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="EscapedStringTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonObject_PrintTo_Tests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonObject_Indexer_Tests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonValue_PrintTo_Tests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonValue_Cast_Tests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Issue10.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="PrettyPrint_Array_Tests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="PrettyPrint_Object_Tests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="PrettyPrint_String_Tests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

JsonGeneratorTests/JsonObject_Indexer_Tests.cpp

@@ -1,73 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonArray.h"
-#include "JsonObject.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Generator;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(JsonObject_Indexer_Tests)
-    {
-        JsonObject<2> object;
-
-    public:
-
-        TEST_METHOD(Empty)
-        {
-            mustNotContain("key");
-        }
-        
-        TEST_METHOD(TwoStrings)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-
-            mustContain("key1", "value1");
-            mustContain("key2", "value2");
-        }
-
-        TEST_METHOD(RemoveFirst)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-            object.remove("key1");
-
-            mustNotContain("key1");
-            mustContain("key2", "value2");
-        }
-
-        TEST_METHOD(RemoveLast)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-            object.remove("key2");
-
-            mustContain("key1", "value1");
-            mustNotContain("key2");
-        }
-
-    private:
-
-        void mustContain(const char* key, const char* expected)
-        {
-            Assert::IsTrue(object.containsKey(key));
-
-            const char* actual = object[key];
-            Assert::AreEqual(expected, actual);
-        }
-
-        void mustNotContain(const char* key)
-        {
-            Assert::IsFalse(object.containsKey(key));
-
-            const char* actual = object[key];
-            Assert::IsNull(actual);
-        }
-    };
-}

JsonGeneratorTests/JsonObject_PrintTo_Tests.cpp

@@ -1,152 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonArray.h"
-#include "JsonObject.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Generator;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(JsonObject_PrintTo_Tests)
-    {
-        JsonObject<2> object;
-
-    public:
-
-        TEST_METHOD(Empty)
-        {
-            outputMustBe("{}");
-        }
-
-        TEST_METHOD(OneString)
-        {
-            object["key"] = "value";
-
-            outputMustBe("{\"key\":\"value\"}");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-
-            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
-        }
-
-        TEST_METHOD(RemoveFirst)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-            object.remove("key1");
-
-            outputMustBe("{\"key2\":\"value2\"}");
-        }
-
-        TEST_METHOD(RemoveLast)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-            object.remove("key2");
-
-            outputMustBe("{\"key1\":\"value1\"}");
-        }
-
-        TEST_METHOD(RemoveUnexistingKey)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-            object.remove("key3");
-
-            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
-        }
-
-        TEST_METHOD(ReplaceExistingKey)
-        {
-            object["key"] = "value1";
-            object["key"] = "value2";
-
-            outputMustBe("{\"key\":\"value2\"}");
-        }
-
-        TEST_METHOD(OneStringOverCapacity)
-        {
-            object["key1"] = "value1";
-            object["key2"] = "value2";
-            object["key3"] = "value3";
-
-            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
-        }
-
-        TEST_METHOD(OneInteger)
-        {
-            object["key"] = 1;
-            outputMustBe("{\"key\":1}");
-        }
-
-        TEST_METHOD(OneDoubleFourDigits)
-        {
-            object["key"].set<4>(3.14159265358979323846);
-            outputMustBe("{\"key\":3.1416}");
-        }
-
-        TEST_METHOD(OneDoubleDefaultDigits)
-        {
-            object["key"] = 3.14159265358979323846;
-            outputMustBe("{\"key\":3.14}");
-        }
-
-        TEST_METHOD(OneNull)
-        {
-            object["key"] = (char*) 0;
-            outputMustBe("{\"key\":null}");
-        }
-
-        TEST_METHOD(OneTrue)
-        {
-            object["key"] = true;
-            outputMustBe("{\"key\":true}");
-        }
-
-        TEST_METHOD(OneFalse)
-        {
-            object["key"] = false;
-            outputMustBe("{\"key\":false}");
-        }
-
-        TEST_METHOD(OneEmptyNestedArray)
-        {
-            auto nestedArray = JsonArray<1>();
-
-            object["key"] = nestedArray;
-            
-            outputMustBe("{\"key\":[]}");
-        }
-
-        TEST_METHOD(OneEmptyNestedObject)
-        {
-            auto nestedObject = JsonObject<1>();
-
-            object["key"] = nestedObject;
-
-            outputMustBe("{\"key\":{}}");
-        }
-
-    private:
-
-        void outputMustBe(const char* expected)
-        {
-            char buffer[256];
-            size_t result;
-            
-            result = object.printTo(buffer, sizeof(buffer));
-            
-            Assert::AreEqual(strlen(expected), result);
-            Assert::AreEqual(expected, buffer);
-        }
-    };
-}

JsonGeneratorTests/JsonValue_Cast_Tests.cpp

@@ -1,78 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "StringBuilder.h"
-#include "JsonValue.h"
-#include "JsonArray.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Generator;
-using namespace ArduinoJson::Internals;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(JsonValue_Cast_Tests)
-    {
-        JsonValue value;
-
-    public:
-
-        TEST_METHOD(Bool)
-        {
-            setValueAndCheckCast(true);
-            setValueAndCheckCast(false);
-        }
-
-        TEST_METHOD(Double)
-        {
-            setValueAndCheckCast(3.14156);
-        }
-
-        TEST_METHOD(Float)
-        {
-            setValueAndCheckCast(3.14f);
-        }
-
-        TEST_METHOD(Integer)
-        {
-            setValueAndCheckCast(42);
-        }
-
-        TEST_METHOD(Long)
-        {
-            setValueAndCheckCast(42L);
-        }
-
-        TEST_METHOD(Array)
-        {
-            JsonArray<2> array;
-            setValueAndCheckCast(array);
-        }
-
-        TEST_METHOD(String)
-        {
-            setValueAndCheckCast("hello");
-        }
-
-    private:
-
-        template<typename T>
-        void setValueAndCheckCast(T expected)
-        {
-            value = expected;
-            T actual = value;
-            Assert::AreEqual(expected, actual);
-        }
-
-        template<int N>
-        void setValueAndCheckCast(JsonArray<N>& expected)
-        {
-            value = expected;
-            const Printable& actual = value;
-            Assert::AreEqual((void*) &expected, (void*) &actual);
-        }
-    };
-}

JsonGeneratorTests/JsonValue_PrintTo_Tests.cpp

@@ -1,103 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "StringBuilder.h"
-#include "JsonValue.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Generator;
-using namespace ArduinoJson::Internals;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(JsonValue_PrintTo_Tests)
-    {
-        char buffer[1024];
-        size_t returnValue;
-
-    public:
-
-        TEST_METHOD(String)
-        {
-            setValueTo("hello");
-            outputMustBe("\"hello\"");
-        }
-
-        TEST_METHOD(Float)
-        {
-            setValueTo(3.1415f);
-            outputMustBe("3.14");
-        }
-
-        TEST_METHOD(DoubleZeroDigits)
-        {
-            setValueTo<0>(3.14159265358979323846);
-            outputMustBe("3");
-        }
-
-        TEST_METHOD(DoubleOneDigit)
-        {
-            setValueTo<1>(3.14159265358979323846);
-            outputMustBe("3.1");
-        }
-
-        TEST_METHOD(DoubleTwoDigits)
-        {
-            setValueTo<2>(3.14159265358979323846);
-            outputMustBe("3.14");
-        }
-        
-        TEST_METHOD(Integer)
-        {
-            setValueTo(314);
-            outputMustBe("314");
-        }
-
-        TEST_METHOD(Char)
-        {
-            setValueTo('A');
-            outputMustBe("65");
-        }
-
-        TEST_METHOD(Short)
-        {
-            setValueTo((short)314);
-            outputMustBe("314");
-        }
-
-        TEST_METHOD(Long)
-        {
-            setValueTo(314159265L);
-            outputMustBe("314159265");
-        }
-
-    private:
-
-        template<int DIGITS>
-        void setValueTo(double value)
-        {
-            StringBuilder sb(buffer, sizeof(buffer));
-            JsonValue jsonValue;
-            jsonValue.set<DIGITS>(value);
-            returnValue = jsonValue.printTo(sb);
-        }
-
-        template<typename T>
-        void setValueTo(T value)
-        {
-            StringBuilder sb(buffer, sizeof(buffer));
-            JsonValue jsonValue;
-            jsonValue = value;
-            returnValue = jsonValue.printTo(sb);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), returnValue);
-        }
-    };
-}

JsonGeneratorTests/PrettyPrint_Array_Tests.cpp

@@ -1,91 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonPrettyPrint.h"
-#include "StringBuilder.h"
-
-using namespace ArduinoJson::Internals;
-using namespace ArduinoJson::Generator;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(PrettyPrint_Array_Tests)
-    {
-        char buffer[1024];
-        size_t returnValue;
-
-    public:
-        
-        TEST_METHOD(EmptyArray)
-        {
-            whenInputIs("[]");
-            outputMustBe("[]");
-        }
-
-        TEST_METHOD(OneElement)
-        {
-            whenInputIs("[1]");
-            outputMustBe(
-                "[\r\n"
-                "  1\r\n"
-                "]");
-        }
-
-        TEST_METHOD(TwoElements)
-        {
-            whenInputIs("[1,2]");
-            outputMustBe(
-                "[\r\n"
-                "  1,\r\n"
-                "  2\r\n"
-                "]");
-        }
-
-        TEST_METHOD(EmptyNestedArrays)
-        {
-            whenInputIs("[[],[]]");
-            outputMustBe(
-                "[\r\n"
-                "  [],\r\n"
-                "  []\r\n"
-                "]");
-        }
-
-        TEST_METHOD(NestedArrays)
-        {
-            whenInputIs("[[1,2],[3,4]]");
-            outputMustBe(
-                "[\r\n"
-                "  [\r\n"
-                "    1,\r\n"
-                "    2\r\n"
-                "  ],\r\n"
-                "  [\r\n"
-                "    3,\r\n"
-                "    4\r\n"
-                "  ]\r\n"
-                "]");
-        }
-
-    private:
-
-        void whenInputIs(const char input[])
-        {
-            StringBuilder sb(buffer, sizeof(buffer));
-            IndentedPrint indentedPrint(sb);
-            JsonPrettyPrint decorator(indentedPrint);
-
-            returnValue = decorator.print(input);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), returnValue);
-        }
-    };
-}

JsonGeneratorTests/PrettyPrint_Object_Tests.cpp

@@ -1,89 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonPrettyPrint.h"
-#include "StringBuilder.h"
-
-using namespace ArduinoJson::Internals;
-using namespace ArduinoJson::Generator;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(PrettyPrint_Object_Tests)
-    {
-        char buffer[1024];
-        size_t returnValue;
-
-    public:
-
-        TEST_METHOD(EmptyObject)
-        {
-            whenInputIs("{}");
-            outputMustBe("{}");
-        }
-
-        TEST_METHOD(OneMember)
-        {
-            whenInputIs("{\"key\":\"value\"}");
-            outputMustBe(
-                "{\r\n"
-                "  \"key\": \"value\"\r\n"
-                "}");
-        }
-
-        TEST_METHOD(TwoMembers)
-        {
-            whenInputIs("{\"key1\":\"value1\",\"key2\":\"value2\"}");
-            outputMustBe(
-                "{\r\n"
-                "  \"key1\": \"value1\",\r\n"
-                "  \"key2\": \"value2\"\r\n"
-                "}");
-        }
-
-        TEST_METHOD(EmptyNestedObjects)
-        {
-            whenInputIs("{\"key1\":{},\"key2\":{}}");
-            outputMustBe(
-                "{\r\n"
-                "  \"key1\": {},\r\n"
-                "  \"key2\": {}\r\n"
-                "}");
-        }
-
-        TEST_METHOD(NestedObjects)
-        {
-            whenInputIs("{\"key1\":{\"a\":1},\"key2\":{\"b\":2}}");
-            outputMustBe(
-                "{\r\n"
-                "  \"key1\": {\r\n"
-                "    \"a\": 1\r\n"
-                "  },\r\n"
-                "  \"key2\": {\r\n"
-                "    \"b\": 2\r\n"
-                "  }\r\n"
-                "}");
-        }
-
-    private:
-
-        void whenInputIs(const char input[])
-        {
-            StringBuilder sb(buffer, sizeof(buffer));
-            IndentedPrint indentedPrint(sb);
-            JsonPrettyPrint decorator(indentedPrint);
-
-            returnValue = decorator.print(input);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), returnValue);
-        }
-    };
-}

JsonGeneratorTests/PrettyPrint_String_Tests.cpp

@@ -1,76 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonPrettyPrint.h"
-#include "StringBuilder.h"
-
-using namespace ArduinoJson::Internals;
-using namespace ArduinoJson::Generator;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(PrettyPrint_String_Tests)
-    {
-        char buffer[1024];
-        size_t returnValue;
-
-    public:
-        
-        TEST_METHOD(EmptyString)
-        {
-            whenInputIs("");
-            outputMustBe("");
-        }
-
-        TEST_METHOD(TrickyCharacters)
-        {
-            whenInputIs ("\":\\\"',\"");
-            outputMustBe("\":\\\"',\"");
-        }
-
-        TEST_METHOD(OpeningCurlyBrace)
-        {
-            whenInputIs ("\"{\"");
-            outputMustBe("\"{\"");
-        }
-
-        TEST_METHOD(OpeningSquareBrace)
-        {
-            whenInputIs("\"[\"");
-            outputMustBe("\"[\"");
-        }
-
-        TEST_METHOD(ClosingCurlyBrace)
-        {
-            whenInputIs("\"}\"");
-            outputMustBe("\"}\"");
-        }
-
-        TEST_METHOD(ClosingSquareBrace)
-        {
-            whenInputIs("\"]\"");
-            outputMustBe("\"]\"");
-        }
-               
-    private:
-
-        void whenInputIs(const char input[])
-        {
-            StringBuilder sb(buffer, sizeof(buffer));
-            IndentedPrint indentedPrint(sb);
-            JsonPrettyPrint decorator(indentedPrint);
-
-            returnValue = decorator.print(input);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), returnValue);
-        }
-    };
-}

JsonGeneratorTests/StringBuilderTests.cpp

@@ -1,85 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "StringBuilder.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Internals;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(StringBuilderTests)
-    {
-        char buffer[20];
-        Print* sb;
-        size_t returnValue;
-
-    public:
-        
-        TEST_METHOD_INITIALIZE(Initialize)
-        {
-            sb = new StringBuilder(buffer, sizeof(buffer));
-        }
-
-        TEST_METHOD(InitialState)
-        {
-            outputMustBe("");
-        }
-
-        TEST_METHOD(OverCapacity)
-        {
-            print("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
-            resultMustBe(19);
-
-            print("ABC");
-            resultMustBe(0);
-
-            outputMustBe("ABCDEFGHIJKLMNOPQRS");
-        }
-
-        TEST_METHOD(EmptyString)
-        {
-            print("");
-            resultMustBe(0);
-            outputMustBe("");
-        }
-
-        TEST_METHOD(OneString)
-        {
-            print("ABCD");
-            resultMustBe(4);
-            outputMustBe("ABCD");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            print("ABCD");
-            resultMustBe(4);
-
-            print("EFGH");
-            resultMustBe(4);
-
-            outputMustBe("ABCDEFGH");
-        }
-
-    private:
-
-        void print(const char* value)
-        {
-            returnValue = sb->print(value);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-        }
-
-        void resultMustBe(size_t expected)
-        {
-            Assert::AreEqual(expected, returnValue);
-        }
-    };
-}

JsonParser.cpp

@@ -1,13 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-// This file is here to help the Arduino IDE find the .cpp files
-
-#include "JsonParser/JsonArray.cpp"
-#include "JsonParser/JsonObject.cpp"
-#include "JsonParser/JsonParserBase.cpp"
-#include "JsonParser/JsonValue.cpp"
-#include "JsonParser/JsonToken.cpp"
-#include "JsonParser/jsmn.cpp"

JsonParser.h

@@ -1,6 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonParser/JsonParser.h"

JsonParser/JsonArray.cpp

@@ -1,14 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonObject.h"
-
-using namespace ArduinoJson::Parser;
-
-DEPRECATED JsonObject JsonArray::getHashTable(int index)
-{
-    return operator[](index);
-}

JsonParser/JsonArray.h

@@ -1,103 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonValue.h"
-#include "JsonArrayIterator.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        class JsonObject;
-                
-        // A JSON array
-        class JsonArray : JsonValue
-        {          
-        public:
-
-            // Create an invalid array
-            JsonArray() 
-            {            
-            }
-
-            // Convert a JsonValue into a JsonArray
-            JsonArray(JsonValue value)
-                : JsonValue(value)
-            {
-            }
-
-            // Tell if the array is valid
-            bool success()
-            {
-                return isArray();
-            }
-
-            // Get the JsonValue at specified index
-            JsonValue operator[](int index)
-            {
-                return JsonValue::operator[](index);
-            }
-
-            // Get the size of the array
-            int size()
-            {
-                return isArray() ? childrenCount() : 0;
-            }
-
-            // Get an iterator pointing to the beginning of the array
-            JsonArrayIterator begin()
-            {
-                return isArray() ? firstChild() : null();
-            }
-
-            // Gets an iterator pointing to the end of the array
-            JsonArrayIterator end()
-            {
-                return isArray() ? nextSibling() : null();
-            }
-
-            // Obsolete: Use size() instead
-            DEPRECATED int getLength()
-            {
-                return size();
-            }
-                   
-            // Obsolete: Use operator[] instead
-            DEPRECATED JsonArray getArray(int index)
-            {
-                return operator[](index);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED bool getBool(int index)
-            {
-                return operator[](index);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED double getDouble(int index)
-            {
-                return operator[](index);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED JsonObject getHashTable(int index);
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED long getLong(int index)
-            {
-                return operator[](index);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED char* getString(int index)
-            {
-                return operator[](index);
-            }
-        };
-    }
-}

JsonParser/JsonArrayIterator.h

@@ -1,46 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonValue.h"
-#include "JsonToken.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        // An iterator for JsonArray
-        class JsonArrayIterator : JsonToken
-        {
-        public:
-
-            // Create an iterator pointing at the specified JsonToken
-            JsonArrayIterator(JsonToken token)
-                : JsonToken(token)
-            {
-
-            }
-
-            // Move iterator forward
-            void operator++()
-            {
-                *this = JsonArrayIterator(nextSibling());
-            }
-
-            // Get the value pointed by the iterator
-            JsonValue operator*() const
-            {
-                return JsonValue(*this);
-            }
-
-            // Test iterator equality
-            bool operator!= (const JsonArrayIterator& other) const
-            {
-                return JsonToken::operator!=(other);
-            }
-        };
-    }
-}

JsonParser/JsonObject.cpp

@@ -1,15 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonObject.h"
-#include "JsonValue.h"
-
-using namespace ArduinoJson::Parser;
-
-DEPRECATED JsonArray JsonObject::getArray(const char* key)
-{
-    return operator[](key);
-}

JsonParser/JsonObject.h

@@ -1,102 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonValue.h"
-#include "JsonObjectIterator.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        class JsonArray;
-
-        // A JSON Object (ie hash-table/dictionary)
-        class JsonObject : JsonValue
-        {
-        public:
-
-            // Create an invalid JsonObject
-            JsonObject()
-            {
-
-            }
-
-            // Convert a JsonValue into a JsonObject
-            JsonObject(JsonValue value)
-                : JsonValue(value)
-            {
-
-            }
-
-            // Tell if the object is valid
-            bool success()
-            {
-                return isObject();
-            }           
-
-            // Get the value associated with the specified key.
-            JsonValue operator[](const char* key)
-            {
-                return JsonValue::operator[](key);
-            }
-
-            // Tell if the specified key exists in the object.
-            bool containsKey(const char* key)
-            {
-                return operator[](key).success();
-            }
-
-            // Get an iterator pointing at the beginning of the object
-            JsonObjectIterator begin()
-            {
-                return isObject() ? firstChild() : null();
-            }
-
-            // Get an iterator pointing at the end of the object
-            JsonObjectIterator end()
-            {
-                return isObject() ? nextSibling() : null();
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED JsonArray getArray(const char* key);
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED bool getBool(const char* key)
-            {
-                return operator[](key);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED double getDouble(const char* key)
-            {
-                return operator[](key);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED JsonObject getHashTable(const char* key)
-            {
-                return operator[](key);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED long getLong(const char* key)
-            {
-                return operator[](key);
-            }
-
-            // Obsolete: Use operator[] instead
-            DEPRECATED char* getString(const char* key)
-            {
-                return operator[](key);
-            }
-        };
-
-        // Obsolete: Use JsonObject instead
-        DEPRECATED typedef JsonObject JsonHashTable;
-    }
-}

JsonParser/JsonObjectIterator.h

@@ -1,58 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonValue.h"
-#include "JsonPair.h"
-#include "JsonToken.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        // An iterator for JsonObject
-        class JsonObjectIterator : JsonToken
-        {
-        public:
-
-            // Create an iterator pointing at the specified token
-            JsonObjectIterator(JsonToken token)
-                : JsonToken(token)
-            {
-            }
-
-            // Move to the next JsonPair
-            void operator++()
-            {
-                *this = JsonObjectIterator(nextSibling().nextSibling());
-            }
-
-            // Get the JsonPair pointed by the iterator
-            JsonPair operator*() const
-            {
-                return JsonPair(*this);
-            }
-
-            // Test iterator equality
-            bool operator!= (const JsonObjectIterator& other) const
-            {
-                return JsonToken::operator!=(other);
-            }
-
-            // Get the key of the JsonPair pointed by the iterator
-            const char* key() const
-            {
-                return operator*().key();
-            }
-
-            // Get the key of the JsonPair pointed by the iterator
-            JsonValue value() const
-            {
-                return operator*().value();
-            }
-        };
-    }
-}

JsonParser/JsonPair.h

@@ -1,37 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonValue.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        // A JSON key-value pair, as a part of a JSON object
-        class JsonPair : JsonToken
-        {
-        public:
-            // Convert a JsonToken to a JsonPair
-            JsonPair(JsonToken token)
-                : JsonToken(token)
-            {
-            }
-
-            // Get the key
-            const char* key()
-            {
-                return getText();
-            }
-
-            // Get the value
-            JsonValue value()
-            {
-                return nextSibling();
-            }
-        };
-    }
-}

JsonParser/JsonParser.h

@@ -1,35 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonParserBase.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        // The JSON parser.
-        //
-        // You need to specifiy the number of token to be allocated for that parser.
-        //
-        // CAUTION: JsonArray, JsonObject and JsonValue 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, JsonObject or JsonValue that have a
-        // longer life that the JsonParser.
-        template <int MAX_TOKENS>
-        class JsonParser : public JsonParserBase
-        {
-        public:
-            JsonParser()
-                : JsonParserBase(tokens, MAX_TOKENS)
-            {
-            }
-
-        private:
-            jsmntok_t tokens[MAX_TOKENS];
-        };
-    }
-}

JsonParser/JsonParser.vcxproj

@@ -1,96 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{C15274DE-2695-4DFE-8520-4424223FE6DA}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>JsonParser</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup />
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClInclude Include="jsmn.h" />
-    <ClInclude Include="JsonArray.h" />
-    <ClInclude Include="JsonArrayIterator.h" />
-    <ClInclude Include="JsonObject.h" />
-    <ClInclude Include="JsonObjectIterator.h" />
-    <ClInclude Include="JsonPair.h" />
-    <ClInclude Include="JsonParser.h" />
-    <ClInclude Include="JsonParserBase.h" />
-    <ClInclude Include="JsonToken.h" />
-    <ClInclude Include="JsonValue.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="jsmn.cpp" />
-    <ClCompile Include="JsonArray.cpp" />
-    <ClCompile Include="JsonObject.cpp" />
-    <ClCompile Include="JsonParserBase.cpp" />
-    <ClCompile Include="JsonToken.cpp" />
-    <ClCompile Include="JsonValue.cpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

JsonParser/JsonParser.vcxproj.filters

@@ -1,69 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="JsonParserBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonToken.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonValue.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonParser.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="jsmn.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonArrayIterator.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonObject.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonObjectIterator.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="JsonPair.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="jsmn.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonArray.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonObject.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonParserBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonToken.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonValue.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

JsonParser/JsonParserBase.cpp

@@ -1,20 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonParserBase.h"
-#include "JsonToken.h"
-
-using namespace ArduinoJson::Parser;
-
-JsonValue JsonParserBase::parse(char* json)
-{
-    jsmn_parser parser;
-    jsmn_init(&parser);
-
-    if (JSMN_SUCCESS != jsmn_parse(&parser, json, tokens, maxTokens))
-        return JsonToken::null();
-
-    return JsonToken(json, tokens);
-}

JsonParser/JsonParserBase.h

@@ -1,49 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonArray.h"
-#include "JsonObject.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        // Base class for the JSON parser, in case you want to provide your own buffer
-        class JsonParserBase
-        {
-        public:
-
-            // Create a JSON parser using the provided buffer
-            JsonParserBase(jsmntok_t* tokens, int maxTokens)
-                : tokens(tokens), maxTokens(maxTokens)
-            {
-            }
-
-            // 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            
-            JsonValue parse(char* json);
-
-            // Obsolete: use parse() instead
-            DEPRECATED JsonArray parseArray(char* json)
-            {
-                return parse(json);
-            }
-
-            // Obsolete: use parse() instead
-            DEPRECATED JsonObject parseHashTable(char* json)
-            {
-                return parse(json);
-            }
-
-        private:
-            jsmntok_t* tokens;
-            int maxTokens;
-        };
-    }
-}

JsonParser/JsonToken.cpp

@@ -1,27 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonToken.h"
-
-using namespace ArduinoJson::Parser;
-
-JsonToken JsonToken::nextSibling() const
-{
-    // start with current token
-    jsmntok_t* t = token;
-
-    // count the number of token to skip
-    int yetToVisit = 1;
-    
-    // skip all nested tokens
-    while (yetToVisit)
-    {
-        yetToVisit += t->size - 1;
-        t++;
-    }
-
-    // build a JsonToken at the new location
-    return JsonToken(json, t);
-}

JsonParser/JsonToken.h

@@ -1,100 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "jsmn.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        // A pointer to a JSON token
-        class JsonToken
-        {
-        public:
-
-            // Create a "null" pointer
-            JsonToken()
-                : token(0)
-            {
-            }
-
-            // Create a pointer to the specified JSON token
-            JsonToken(char* json, jsmntok_t* token)
-                : json(json), token(token)
-            {
-            }
-
-            // Get content of the JSON token
-            char* getText()
-            {
-                json[token->end] = 0;
-                return json + token->start;
-            }
-
-            // Get the number of children tokens
-            int childrenCount()
-            {
-                return token->size;
-            }
-
-            // Get a pointer to the first child of the current token
-            JsonToken firstChild() const
-            {
-                return JsonToken(json, token + 1);
-            }
-
-            // Get a pointer to the next sibling token (ie skiping the children tokens)
-            JsonToken nextSibling() const;
-
-            // Test equality
-            bool operator!=(const JsonToken& other) const
-            {
-                return token != other.token;
-            }
-
-            // Tell if the pointer is "null"
-            bool isValid()
-            {
-                return token != 0;
-            }
-
-            // Tell if the JSON token is a JSON object
-            bool isObject()
-            {
-                return token != 0 && token->type == JSMN_OBJECT;
-            }
-
-            // Tell if the JSON token is a JSON array
-            bool isArray()
-            {
-                return token != 0 && token->type == JSMN_ARRAY;
-            }
-
-            // Tell if the JSON token is a primitive
-            bool isPrimitive()
-            {
-                return token != 0 && token->type == JSMN_PRIMITIVE;
-            }
-
-            // Tell if the JSON token is a string
-            bool isString()
-            {
-                return token != 0 && token->type == JSMN_STRING;
-            }
-
-            // Explicit wait to create a "null" JsonToken
-            static JsonToken null()
-            {
-                return JsonToken();
-            }
-
-        private:
-            char* json;
-            jsmntok_t* token;
-        };
-    }
-}

JsonParser/JsonValue.cpp

@@ -1,110 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include <stdlib.h> // for strtol, strtod
-#include <string.h> // for strcmp()
-#include "JsonArray.h"
-#include "JsonObject.h"
-#include "JsonValue.h"
-
-using namespace ArduinoJson::Parser;
-
-// Convert the JsonValue to a bool.
-// Returns false if the JsonValue is not a primitve.
-JsonValue::operator bool()
-{
-    if (!isPrimitive()) return 0;
-
-    char *text = getText();
-
-    // "true"
-    if (text[0] == 't') return true;
-
-    // "false"
-    if (text[0] == 'f') return false;
-
-    // "null"
-    if (text[0] == 'n') return false;
-
-    // number
-    return strtol(text, 0, 0) != 0;
-}
-
-// Convert the JsonValue to a floating point value.
-// Returns false if the JsonValue is not a number.
-JsonValue::operator double()
-{
-    return isPrimitive() ? strtod(getText(), 0) : 0;
-}
-
-// Convert the JsonValue to a floating point value.
-// Returns false if the JsonValue is not a number.
-JsonValue::operator long()
-{
-    return isPrimitive() ? strtol(getText(), 0, 0) : 0;
-}
-
-// Convert the JsonValue to a string.
-// Returns 0 if the JsonValue is not a string.
-JsonValue::operator char*()
-{
-    return isString() || isPrimitive() ? getText() : 0;
-}
-
-// Get the nested value at the specified index.            
-// Returns an invalid JsonValue if the current value is not an array.
-JsonValue JsonValue::operator[](int index)
-{
-    // sanity check
-    if (index < 0 || !isArray() || index >= childrenCount())
-        return null();
-
-    // skip first token, it's the whole object
-    JsonToken runningToken = firstChild();
-
-    // skip all tokens before the specified index
-    for (int i = 0; i < index; i++)
-    {
-        // move forward: current + nested tokens
-        runningToken = runningToken.nextSibling();
-    }
-
-    return runningToken;
-}
-
-// Get the nested value matching the specified index.            
-// Returns an invalid JsonValue if the current value is not an object.
-JsonValue JsonValue::operator[](const char* desiredKey)
-{
-    // sanity check
-    if (desiredKey == 0 || !isObject())
-        return null();
-
-    // skip first token, it's the whole object
-    JsonToken runningToken = firstChild();
-
-    // scan each keys
-    for (int i = 0; i < childrenCount() / 2; i++)
-    {
-        // get 'key' token string
-        char* key = runningToken.getText();
-
-        // move to the 'value' token
-        runningToken = runningToken.nextSibling();
-
-        // compare with desired name
-        if (strcmp(desiredKey, key) == 0)
-        {
-            // return the value token that follows the key token
-            return runningToken;
-        }
-
-        // skip nested tokens
-        runningToken = runningToken.nextSibling();
-    }
-
-    // nothing found, return NULL
-    return null();
-}

JsonParser/JsonValue.h

@@ -1,72 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonToken.h"
-
-#ifndef ARDUINO_JSON_NO_DEPRECATION_WARNING
-#ifdef __GNUC__
-#define DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#define DEPRECATED __declspec(deprecated)
-#endif
-#else
-#define DEPRECATED
-#endif
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        // A JSON value
-        // Can be converted to string, double, bool, array or object.
-        class JsonValue : protected JsonToken
-        {
-        public:
-
-            // Create a invalid value
-            JsonValue()
-            {
-            }
-
-            // Convert a JsonToken to a JsonValue
-            JsonValue(JsonToken token)
-                : JsonToken(token)
-            {
-            }
-
-            // Tell is the JsonValue is valid
-            bool success()
-            {
-                return isValid();
-            }
-
-            // Convert the JsonValue to a bool.
-            // Returns false if the JsonValue is not a primitve.
-            operator bool();
-
-            // Convert the JsonValue to a floating point value.
-            // Returns false if the JsonValue is not a number.
-            operator double();
-
-            // Convert the JsonValue to a long integer.
-            // Returns 0 if the JsonValue is not a number.
-            operator long();
-
-            // Convert the JsonValue to a string.
-            // Returns 0 if the JsonValue is not a string.
-            operator char*();            
-            
-            // Get the nested value at the specified index.            
-            // Returns an invalid JsonValue if the current value is not an array.
-            JsonValue operator[](int index);
-
-            // Get the nested value matching the specified index.            
-            // Returns an invalid JsonValue if the current value is not an object.
-            JsonValue operator[](const char* key);
-        };
-    }
-}

JsonParser/README.md

@@ -1,250 +0,0 @@
-Arduino JSON library - Parser
-=============================
-
-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.
-
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
-
-
-Features
---------
-
-* Based on the well-proven [jsmn](http://zserge.com/jsmn.html) tokenizer
-* Supports nested objects
-* Elegant API, very easy to use 
-* Fixed memory allocation (no malloc)
-* Small footprint
-* MIT License
-
-
-Example
--------
-
-	JsonParser<32> parser;
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";   
-
-    JsonObject root = parser.parse(json);
-
-    char*  sensor    = root["sensor"];
-    long   time      = root["time"];
-    double latitude  = root["data"][0];
-    double longitude = root["data"][1];
-
-
-How to  use ?
--------------
-
-### 1. Install the library
-
-Download the library and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJson
-
-### 2. Import in your sketch
-
-Just add the following lines at the top of your `.ino` file:
-
-    #include <JsonParser.h>
-
-    using namespace ArduinoJson::Parser;
-
-> ##### Having a namespace conflict?
-> To be able to use both `ArduinoJson::Generator` and `ArduinoJson::Parser` in the same file, you need to do one of the followings:
-> 
-> * Put the `using` statements into different functions
-> * `using namespace ArduinoJson`, then prefix the type names by `Generator::` or `Parser::`
-> * Create aliases for the namespaces or the types (C++11 only)
-    
-### 3. Create a parser
-
-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:
-
-    JsonParser<32> parser;
-    
-> #### How to choose the number of tokens ?
-
-> A token is an element of the JSON object: either a key, a value, an object 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.
-
-> 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 an object (like `{"key":"value"}`) or an array (like `[1,2]`). 
-
-The nested objects can be either arrays, booleans, objects, numbers or strings.
-If you need other type, you can get the string value and parse it yourself.
-
-#### Object
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    {
-        "sensor":"gps",
-		"time":1351824120,
-		"data":[48.756080,2.302038]
-    }
-
-In this case the string contains a JSON object, so you need to extract a `JsonObject`:
-   
-    JsonObject root = parser.parse(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*  sensor    = root["sensor"];
-    long   time      = root["time"];
-    double latitude  = root["data"][0];
-    double longitude = root["data"][1];
-
-You can also iterate through the key-value pairs of the object:
-
-    for (JsonObjectIterator i=root.begin(); i!=root.end(); ++i)
-    {
-      Serial.println(i.key());
-      Serial.println((char*)i.value());
-    }
-    
-#### 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.parse(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:
-    
-    double a = root[0][0];
-	double b = root[0][1];
-	double c = root[1][0];
-	double d = root[1][1];
-
-You can also iterate through the key-value pairs of the object:
-
-    for (JsonArrayIterator i=array.begin(); i!=array.end(); ++i)
-    {
-      Serial.println((char*)*i);
-    }
-	
-Common pitfalls
----------------
-
-### 1. Not enough tokens
-
-By design, the library has no way to tell you why `JsonParser::parse()` 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, `JsonValue`, `JsonArray` and `JsonObject` 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::parse()`, 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.
-
-| Type         | Size in bytes |
-| ------------ | ------------- |
-| `Parser<N>`  | 4 + 8 x N     |
-| `JsonArray`  | 4             |
-| `JsonObject` | 4             |
-| `JsonValue`  | 4             |
-
-Code size
----------
-
-The sizes have been obtained with Arduino IDE 1.0.5 for a Duemilanove.
-
-### Minimum setup
-
-| Function                             | Size |
-| ------------------------------------ | ---- |
-| `jsmn_parse()`                       | 962  |
-| `JsonValue::operator[](char const*)` | 218  | 
-| `JsonParserBase::parse()`            | 116  | 
-| `JsonValue::operator[](int)`         | 108  |
-| `strcmp()`                           | 18   | 
-
-### Additional space for integers
-
-| Function                     | Size |
-| ---------------------------- | ---- |
-| `strtol()`                   | 606  |
-| `JsonValue::operator long()` | 94   |
-
-### Additional space for floating points
-
-| Function                         | Size  |
-| -------------------------------- | ----- |
-| `strtod()`                       | 1369  |
-| `JsonValue::operator double()`   | 82    |

JsonParser/jsmn.cpp

@@ -1,255 +0,0 @@
-#include <stdlib.h>
-
-#include "jsmn.h"
-
-/**
- * Allocates a fresh unused token from the token pull.
- */
-static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser, 
-		jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *tok;
-	if (parser->toknext >= num_tokens) {
-		return NULL;
-	}
-	tok = &tokens[parser->toknext++];
-	tok->start = tok->end = -1;
-	tok->size = 0;
-#ifdef JSMN_PARENT_LINKS
-	tok->parent = -1;
-#endif
-	return tok;
-}
-
-/**
- * Fills token type and boundaries.
- */
-static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type, 
-                            int start, int end) {
-	token->type = type;
-	token->start = start;
-	token->end = end;
-	token->size = 0;
-}
-
-/**
- * Fills next available token with JSON primitive.
- */
-static jsmnerr_t jsmn_parse_primitive(jsmn_parser *parser, const char *js,
-		jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *token;
-	int start;
-
-	start = parser->pos;
-
-	for (; js[parser->pos] != '\0'; parser->pos++) {
-		switch (js[parser->pos]) {
-#ifndef JSMN_STRICT
-			/* In strict mode primitive must be followed by "," or "}" or "]" */
-			case ':':
-#endif
-			case '\t' : case '\r' : case '\n' : case ' ' :
-			case ','  : case ']'  : case '}' :
-				goto found;
-		}
-		if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
-			parser->pos = start;
-			return JSMN_ERROR_INVAL;
-		}
-	}
-#ifdef JSMN_STRICT
-	/* In strict mode primitive must be followed by a comma/object/array */
-	parser->pos = start;
-	return JSMN_ERROR_PART;
-#endif
-
-found:
-	token = jsmn_alloc_token(parser, tokens, num_tokens);
-	if (token == NULL) {
-		parser->pos = start;
-		return JSMN_ERROR_NOMEM;
-	}
-	jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
-#ifdef JSMN_PARENT_LINKS
-	token->parent = parser->toksuper;
-#endif
-	parser->pos--;
-	return JSMN_SUCCESS;
-}
-
-/**
- * Filsl next token with JSON string.
- */
-static jsmnerr_t jsmn_parse_string(jsmn_parser *parser, const char *js,
-		jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *token;
-
-	int start = parser->pos;
-
-	parser->pos++;
-
-	/* Skip starting quote */
-	for (; js[parser->pos] != '\0'; parser->pos++) {
-		char c = js[parser->pos];
-
-		/* Quote: end of string */
-		if (c == '\"') {
-			token = jsmn_alloc_token(parser, tokens, num_tokens);
-			if (token == NULL) {
-				parser->pos = start;
-				return JSMN_ERROR_NOMEM;
-			}
-			jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
-#ifdef JSMN_PARENT_LINKS
-			token->parent = parser->toksuper;
-#endif
-			return JSMN_SUCCESS;
-		}
-
-		/* Backslash: Quoted symbol expected */
-		if (c == '\\') {
-			parser->pos++;
-			switch (js[parser->pos]) {
-				/* Allowed escaped symbols */
-				case '\"': case '/' : case '\\' : case 'b' :
-				case 'f' : case 'r' : case 'n'  : case 't' :
-					break;
-				/* Allows escaped symbol \uXXXX */
-				case 'u':
-					/* TODO */
-					break;
-				/* Unexpected symbol */
-				default:
-					parser->pos = start;
-					return JSMN_ERROR_INVAL;
-			}
-		}
-	}
-	parser->pos = start;
-	return JSMN_ERROR_PART;
-}
-
-/**
- * Parse JSON string and fill tokens.
- */
-jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js, jsmntok_t *tokens, 
-		unsigned int num_tokens) {
-	jsmnerr_t r;
-	int i;
-	jsmntok_t *token;
-
-	for (; js[parser->pos] != '\0'; parser->pos++) {
-		char c;
-		jsmntype_t type;
-
-		c = js[parser->pos];
-		switch (c) {
-			case '{': case '[':
-				token = jsmn_alloc_token(parser, tokens, num_tokens);
-				if (token == NULL)
-					return JSMN_ERROR_NOMEM;
-				if (parser->toksuper != -1) {
-					tokens[parser->toksuper].size++;
-#ifdef JSMN_PARENT_LINKS
-					token->parent = parser->toksuper;
-#endif
-				}
-				token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
-				token->start = parser->pos;
-				parser->toksuper = parser->toknext - 1;
-				break;
-			case '}': case ']':
-				type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
-#ifdef JSMN_PARENT_LINKS
-				if (parser->toknext < 1) {
-					return JSMN_ERROR_INVAL;
-				}
-				token = &tokens[parser->toknext - 1];
-				for (;;) {
-					if (token->start != -1 && token->end == -1) {
-						if (token->type != type) {
-							return JSMN_ERROR_INVAL;
-						}
-						token->end = parser->pos + 1;
-						parser->toksuper = token->parent;
-						break;
-					}
-					if (token->parent == -1) {
-						break;
-					}
-					token = &tokens[token->parent];
-				}
-#else
-				for (i = parser->toknext - 1; i >= 0; i--) {
-					token = &tokens[i];
-					if (token->start != -1 && token->end == -1) {
-						if (token->type != type) {
-							return JSMN_ERROR_INVAL;
-						}
-						parser->toksuper = -1;
-						token->end = parser->pos + 1;
-						break;
-					}
-				}
-				/* Error if unmatched closing bracket */
-				if (i == -1) return JSMN_ERROR_INVAL;
-				for (; i >= 0; i--) {
-					token = &tokens[i];
-					if (token->start != -1 && token->end == -1) {
-						parser->toksuper = i;
-						break;
-					}
-				}
-#endif
-				break;
-			case '\"':
-				r = jsmn_parse_string(parser, js, tokens, num_tokens);
-				if (r < 0) return r;
-				if (parser->toksuper != -1)
-					tokens[parser->toksuper].size++;
-				break;
-			case '\t' : case '\r' : case '\n' : case ':' : case ',': case ' ': 
-				break;
-#ifdef JSMN_STRICT
-			/* In strict mode primitives are: numbers and booleans */
-			case '-': case '0': case '1' : case '2': case '3' : case '4':
-			case '5': case '6': case '7' : case '8': case '9':
-			case 't': case 'f': case 'n' :
-#else
-			/* In non-strict mode every unquoted value is a primitive */
-			default:
-#endif
-				r = jsmn_parse_primitive(parser, js, tokens, num_tokens);
-				if (r < 0) return r;
-				if (parser->toksuper != -1)
-					tokens[parser->toksuper].size++;
-				break;
-
-#ifdef JSMN_STRICT
-			/* Unexpected char in strict mode */
-			default:
-				return JSMN_ERROR_INVAL;
-#endif
-
-		}
-	}
-
-	for (i = parser->toknext - 1; i >= 0; i--) {
-		/* Unmatched opened object or array */
-		if (tokens[i].start != -1 && tokens[i].end == -1) {
-			return JSMN_ERROR_PART;
-		}
-	}
-
-	return JSMN_SUCCESS;
-}
-
-/**
- * Creates a new parser based over a given  buffer with an array of tokens 
- * available.
- */
-void jsmn_init(jsmn_parser *parser) {
-	parser->pos = 0;
-	parser->toknext = 0;
-	parser->toksuper = -1;
-}
-

JsonParser/jsmn.h

@@ -1,67 +0,0 @@
-#ifndef __JSMN_H_
-#define __JSMN_H_
-
-/**
- * JSON type identifier. Basic types are:
- * 	o Object
- * 	o Array
- * 	o String
- * 	o Other primitive: number, boolean (true/false) or null
- */
-typedef enum {
-	JSMN_PRIMITIVE = 0,
-	JSMN_OBJECT = 1,
-	JSMN_ARRAY = 2,
-	JSMN_STRING = 3
-} jsmntype_t;
-
-typedef enum {
-	/* Not enough tokens were provided */
-	JSMN_ERROR_NOMEM = -1,
-	/* Invalid character inside JSON string */
-	JSMN_ERROR_INVAL = -2,
-	/* The string is not a full JSON packet, more bytes expected */
-	JSMN_ERROR_PART = -3,
-	/* Everything was fine */
-	JSMN_SUCCESS = 0
-} jsmnerr_t;
-
-/**
- * JSON token description.
- * @param		type	type (object, array, string etc.)
- * @param		start	start position in JSON data string
- * @param		end		end position in JSON data string
- */
-typedef struct {
-	jsmntype_t type;
-	int start;
-	int end;
-	int size;
-#ifdef JSMN_PARENT_LINKS
-	int parent;
-#endif
-} jsmntok_t;
-
-/**
- * JSON parser. Contains an array of token blocks available. Also stores
- * the string being parsed now and current position in that string
- */
-typedef struct {
-	unsigned int pos; /* offset in the JSON string */
-	int toknext; /* next token to allocate */
-	int toksuper; /* superior token node, e.g parent object or array */
-} jsmn_parser;
-
-/**
- * Create JSON parser over an array of tokens
- */
-void jsmn_init(jsmn_parser *parser);
-
-/**
- * Run JSON parser. It parses a JSON data string into and array of tokens, each describing
- * a single JSON object.
- */
-jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js, 
-		jsmntok_t *tokens, unsigned int num_tokens);
-
-#endif /* __JSMN_H_ */

JsonParserTests/GbathreeBug.cpp

@@ -1,244 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-#include <string>
-
-using namespace std;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(GbathreeBug)
-	{
-		char json[1024];
-		JsonParser<200> parser;
-		JsonHashTable root;
-		
-
-	public:
-
-		TEST_METHOD_INITIALIZE(Initialize)
-		{
-			// BUG described here:
-			// http://forum.arduino.cc/index.php?topic=172578.msg1608219#msg1608219
-			strcpy(json, "{ \"protocol_name\":\"fluorescence\",\"repeats\":1,\"wait\":0,\"averages\":1,\"measurements\":3,\"meas2_light\":15,\"meas1_baseline\":0,\"act_light\":20,\"pulsesize\":25,\"pulsedistance\":10000,\"actintensity1\":50,\"actintensity2\":255,\"measintensity\":255,\"calintensity\":255,\"pulses\":[50,50,50],\"act\":[2,1,2,2],\"red\":[2,2,2,2],\"detectors\":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]],\"alta\":[2,2,2,2],\"altb\":[2,2,2,2],\"measlights\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]],\"measlights2\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]],\"altc\":[2,2,2,2],\"altd\":[2,2,2,2]}");
-			root = parser.parseHashTable(json);
-		}
-
-		TEST_METHOD(Root)
-		{
-			Assert::IsTrue(root.success());
-		}
-
-		TEST_METHOD(ProtocolName)
-		{
-			string protocol_name = root.getString("protocol_name");
-			Assert::AreEqual(string("fluorescence"), protocol_name);
-		}
-
-		TEST_METHOD(Repeats)
-		{
-			Assert::AreEqual(1L, root.getLong("repeats"));
-		}
-
-		TEST_METHOD(Wait)
-		{
-			Assert::AreEqual(0L, root.getLong("wait"));
-		}
-
-		TEST_METHOD(Measurements)
-		{
-			Assert::AreEqual(3L, root.getLong("measurements"));
-		}
-
-		TEST_METHOD(Meas2_Light)
-		{
-			Assert::AreEqual(15L, root.getLong("meas2_light"));
-		}
-
-		TEST_METHOD(Meas1_Baseline)
-		{
-			Assert::AreEqual(0L, root.getLong("meas1_baseline"));
-		}
-
-		TEST_METHOD(Act_Light)
-		{
-			Assert::AreEqual(20L, root.getLong("act_light"));
-		}
-
-		TEST_METHOD(Pulsesize)
-		{
-			Assert::AreEqual(25L, root.getLong("pulsesize"));
-		}
-
-		TEST_METHOD(Pulsedistance)
-		{
-			Assert::AreEqual(10000L, root.getLong("pulsedistance"));
-		}
-
-		TEST_METHOD(Actintensity1)
-		{
-			Assert::AreEqual(50L, root.getLong("actintensity1"));
-		}
-				
-		TEST_METHOD(Actintensity2)
-		{
-			Assert::AreEqual(255L, root.getLong("actintensity2"));
-		}
-		
-		TEST_METHOD(Measintensity)
-		{
-			Assert::AreEqual(255L, root.getLong("measintensity"));
-		}
-		
-		TEST_METHOD(Calintensity)
-		{
-			Assert::AreEqual(255L, root.getLong("calintensity"));
-		}
-
-		TEST_METHOD(Pulses)
-		{
-			// "pulses":[50,50,50]
-
-			JsonArray array = root.getArray("pulses");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(3, array.getLength());
-
-			for (int i = 0; i < 3; i++)
-			{
-				Assert::AreEqual(50L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Act)
-		{
-			// "act":[2,1,2,2]
-
-			JsonArray array = root.getArray("act");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-			Assert::AreEqual(2L, array.getLong(0));
-			Assert::AreEqual(1L, array.getLong(1));
-			Assert::AreEqual(2L, array.getLong(2));
-			Assert::AreEqual(2L, array.getLong(3));			
-		}
-
-		TEST_METHOD(Detectors)
-		{
-			// "detectors":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]]
-
-			JsonArray array = root.getArray("detectors");
-			Assert::IsTrue(array.success());
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(4, array.getArray(i).getLength());
-
-				for (int j = 0; j < 4; j++)
-					Assert::AreEqual(34L, array.getArray(i).getLong(j));
-			}
-		}
-
-		TEST_METHOD(Alta)
-		{
-			// alta:[2,2,2,2]
-
-			JsonArray array = root.getArray("alta");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Altb)
-		{
-			// altb:[2,2,2,2]
-
-			JsonArray array = root.getArray("altb");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Measlights)
-		{
-			// "measlights":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
-
-			JsonArray array = root.getArray("measlights");
-			Assert::IsTrue(array.success());
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(4, array.getArray(i).getLength());
-
-				for (int j = 0; j < 4; j++)
-					Assert::AreEqual(15L, array.getArray(i).getLong(j));
-			}
-		}
-
-		TEST_METHOD(Measlights2)
-		{
-			// "measlights2":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
-
-			JsonArray array = root.getArray("measlights2");
-			Assert::IsTrue(array.success());
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(4, array.getArray(i).getLength());
-
-				for (int j = 0; j < 4; j++)
-					Assert::AreEqual(15L, array.getArray(i).getLong(j));
-			}
-		}
-
-		TEST_METHOD(Altc)
-		{
-			// altc:[2,2,2,2]
-
-			JsonArray array = root.getArray("altc");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Altd)
-		{
-			// altd:[2,2,2,2]
-
-			JsonArray array = root.getArray("altd");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-	};
-}

JsonParserTests/JsonArrayIteratorTests.cpp

@@ -1,67 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace JsonParserTests
-{
-    TEST_CLASS(JsonArrayIteratorTests)
-    {
-    public:
-
-        TEST_METHOD(EmptyJson)
-        {
-            char json[] = "";
-            JsonParser<1> parser;
-
-            JsonArray a = parser.parse(json);
-
-            int loopCount = 0;
-
-            for (long i : a)
-            {
-                loopCount++;
-            }
-
-            Assert::AreEqual(0, loopCount);
-        }
-
-        TEST_METHOD(ThreeIntegers)
-        {
-            char json [] = "[1,2,3]";
-            long expected [] = {1, 2, 3};
-            JsonParser<4> parser;
-
-            JsonArray a = parser.parse(json);
-
-            int index = 0;
-
-            for (long i : a)
-            {
-                Assert::AreEqual(expected[index++], i);
-            }
-        }
-
-        TEST_METHOD(ThreeStrings)
-        {
-            char json[] = "[\"1\",\"2\",\"3\"]";
-            char* expected[] = {"1", "2", "3"};
-            JsonParser<4> parser;
-
-            JsonArray a = parser.parse(json);
-
-            int index = 0;
-
-            for (const char* i : a)
-            {
-                Assert::AreEqual(expected[index++], i);
-            }
-        }
-    };
-}

JsonParserTests/JsonArrayTests.cpp

@@ -1,195 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(JsonArrayTests)
-	{
-        JsonArray array;
-        char json[256];
-        jsmntok_t tokens[32];
-        JsonParserBase parser = JsonParserBase(tokens, 32);
-
-	public:
-		
-		TEST_METHOD(EmptyString)
-		{
-            whenInputIs("");
-            parseMustFail();             
-		}
-
-		TEST_METHOD(TooFewClosingBrackets)
-		{
-            whenInputIs("[[]");
-            parseMustFail();
-		}
-
-		TEST_METHOD(TooManyClosingBrackets)
-		{
-            whenInputIs("[]]");
-            parseMustFail();
-		}
-		
-        TEST_METHOD(EmptyArray)
-        {
-            whenInputIs("[]");
-            parseMustSucceed();
-            lengthMustBe(0);
-        }
-
-        TEST_METHOD(NotEnoughTokens)
-        {
-            setTokenCountTo(2);
-
-            whenInputIs("[1,2]");
-
-            parseMustFail();
-            itemMustNotExist(0);
-        }
-
-		TEST_METHOD(TwoIntegers)
-		{
-            setTokenCountTo(3);
-
-            whenInputIs("[1,2]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, 1L);
-            itemMustBe(1, 2L);
-            itemMustNotExist(2);
-		}
-
-        TEST_METHOD(TwoBooleans)
-        {
-            setTokenCountTo(3);
-
-            whenInputIs("[true,false]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, true);
-            itemMustBe(1, false);
-            itemMustNotExist(2);
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            setTokenCountTo(3);
-
-            whenInputIs("[\"hello\",\"world\"]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, "hello");
-            itemMustBe(1, "world");
-            itemMustNotExist(2);
-        }
-
-		TEST_METHOD(TwoDimensionsArray)
-		{
-            setTokenCountTo(7);
-
-            whenInputIs("[[1,2],[3,4]]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, 0, 1L);
-            itemMustBe(0, 1, 2L);
-            itemMustBe(1, 0, 3L);
-            itemMustBe(1, 1, 4L);
-            itemMustNotExist(2);
-		}
-
-        TEST_METHOD(ThreeDimensionsArray)
-        {
-            setTokenCountTo(15);
-
-            whenInputIs("[[[1,2],[3,4]],[[5,6],[7,8]]]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, 0, 0, 1L);
-            itemMustBe(0, 0, 1, 2L);
-            itemMustBe(0, 1, 0, 3L);
-            itemMustBe(0, 1, 1, 4L);
-            itemMustBe(1, 0, 0, 5L);
-            itemMustBe(1, 0, 1, 6L);
-            itemMustBe(1, 1, 0, 7L);
-            itemMustBe(1, 1, 1, 8L);
-            itemMustNotExist(2);
-        }        
-		
-    private:
-
-        void setTokenCountTo(int n)
-        {
-            parser = JsonParserBase(tokens, n);
-        }
-
-        void whenInputIs(const char* input)
-        {
-            strcpy(json, input);
-            array = parser.parseArray(json);
-        }
-
-        void parseMustFail()
-        {
-            Assert::IsFalse(array.success());
-            lengthMustBe(0);
-        }
-
-        void parseMustSucceed()
-        {
-            Assert::IsTrue(array.success());
-        }
-
-        void lengthMustBe(int expected)
-        {
-            Assert::AreEqual(expected, array.getLength());
-        }
-
-        void itemMustBe(int index, long expected)
-        {
-            Assert::AreEqual(expected, array.getLong(index));
-        }
-
-        void itemMustBe(int index, bool expected)
-        {
-            Assert::AreEqual(expected, array.getBool(index));
-        }
-
-        void itemMustBe(int index, const char* expected)
-        {
-            Assert::AreEqual(expected, array.getString(index));
-        }
-
-        void itemMustBe(int index0, int index1, long expected)
-        {
-            Assert::AreEqual(expected, array.getArray(index0).getLong(index1));
-        }
-
-        void itemMustBe(int index0, int index1, int index2, long expected)
-        {
-            Assert::AreEqual(expected, array.getArray(index0).getArray(index1).getLong(index2));
-        }
-
-        void itemMustNotExist(int index)
-        {
-            Assert::IsFalse(array.getHashTable(index).success());
-            Assert::IsFalse(array.getArray(index).success());
-            Assert::IsFalse(array.getBool(index));
-            Assert::AreEqual(0.0, array.getDouble(index));
-            Assert::AreEqual(0L, array.getLong(index));
-            Assert::IsNull(array.getString(index));
-        }
-	};
-}

JsonParserTests/JsonObjectIteratorTests.cpp

@@ -1,71 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace JsonParserTests
-{
-    TEST_CLASS(JsonObjectIteratorTests)
-    {
-    public:
-
-        TEST_METHOD(EmptyObject)
-        {
-            char json [] = "{}";
-            JsonParser<1> parser;
-
-            JsonHashTable a = parser.parse(json);
-
-            int loopCount = 0;
-
-            for (auto i : a)
-            {
-                loopCount++;
-            }
-
-            Assert::AreEqual(0, loopCount);
-        }
-
-        TEST_METHOD(EmptyJson)
-        {
-            char json[] = "";
-            JsonParser<1> parser;
-
-            JsonHashTable a = parser.parse(json);
-
-            int loopCount = 0;
-
-            for (auto i : a)
-            {
-                loopCount++;
-            }
-
-            Assert::AreEqual(0, loopCount);
-        }
-
-        TEST_METHOD(ThreeStrings)
-        {
-            char json[] = "{\"key1\":\"value1\",\"key2\":\"value2\",\"key3\":\"value3\"}";
-            char* expectedKeys[] = {"key1", "key2", "key3"};
-            char* expectedValues[] = {"value1", "value2", "value3"};
-            JsonParser<7> parser;
-
-            JsonHashTable a = parser.parse(json);
-
-            int index = 0;
-
-            for (auto i : a)
-            {
-                Assert::AreEqual(expectedKeys[index], i.key());
-                Assert::AreEqual(expectedValues[index], (const char*) i.value());
-                index++;
-            }
-        }
-    };
-}

JsonParserTests/JsonObjectTests.cpp

@@ -1,171 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-#include <string>
-
-using namespace std;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace ArduinoJsonParserTests
-{
-    TEST_CLASS(JsonHashTableTests)
-    {
-        JsonHashTable hashTable;
-        JsonArray nestedArray;
-        char json[256];
-        jsmntok_t tokens[32];
-        JsonParserBase parser = JsonParserBase(tokens, 32);
-
-    public:
-
-        TEST_METHOD(EmptyString)
-        {
-            whenInputIs("");
-            parseMustFail();
-        }
-
-        TEST_METHOD(EmptyHashTable)
-        {
-            whenInputIs("{}");
-            parseMustSucceed();
-        }
-
-        TEST_METHOD(NotEnoughTokens)
-        {
-            setTokenCountTo(2);
-
-            whenInputIs("{\"key\":0}");
-
-            parseMustFail();
-            itemMustNotExist("key");
-        }
-
-        TEST_METHOD(TwoIntegers)
-        {
-            setTokenCountTo(5);
-
-            whenInputIs("{\"key1\":1,\"key2\":2}");
-
-            parseMustSucceed();
-            itemMustBe("key1", 1L);
-            itemMustBe("key2", 2L);
-            itemMustNotExist("key3");
-        }
-
-        TEST_METHOD(TwoBooleans)
-        {
-            setTokenCountTo(5);
-
-            whenInputIs("{\"key1\":true,\"key2\":false}");
-
-            parseMustSucceed();
-            itemMustBe("key1", true);
-            itemMustBe("key2", false);
-            itemMustNotExist("key3");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            setTokenCountTo(5);
-
-            whenInputIs("{\"key1\":\"hello\",\"key2\":\"world\"}");
-
-            parseMustSucceed();
-            itemMustBe("key1", "hello");
-            itemMustBe("key2", "world");
-            itemMustNotExist("key3");
-        }
-
-        TEST_METHOD(TwoNestedArrays)
-        {
-            setTokenCountTo(9);
-
-            whenInputIs("{\"key1\":[1,2],\"key2\":[3,4]}");
-            parseMustSucceed();
-
-            itemMustBeAnArray("key1");
-            arrayLengthMustBe(2);
-            arrayItemMustBe(0, 1L);
-            arrayItemMustBe(1, 2L);
-            arrayItemMustBe(2, 0L);
-
-            itemMustBeAnArray("key2");
-            arrayLengthMustBe(2);
-            arrayItemMustBe(0, 3L);
-            arrayItemMustBe(1, 4L);
-            arrayItemMustBe(2, 0L);
-
-            itemMustNotExist("key3");
-        }
-
-    private:
-
-        void setTokenCountTo(int n)
-        {
-            parser = JsonParserBase(tokens, n);
-        }
-
-        void whenInputIs(const char* input)
-        {
-            strcpy(json, input);
-            hashTable = parser.parseHashTable(json);
-        }
-
-        void parseMustFail()
-        {
-            Assert::IsFalse(hashTable.success());
-        }
-
-        void parseMustSucceed()
-        {
-            Assert::IsTrue(hashTable.success());
-        }
-
-        void itemMustBe(const char* key, long expected)
-        {
-            Assert::AreEqual(expected, hashTable.getLong(key));
-        }
-
-        void itemMustBe(const char* key, bool expected)
-        {
-            Assert::AreEqual(expected, hashTable.getBool(key));
-        }
-
-        void itemMustBe(const char* key, const char* expected)
-        {
-            Assert::AreEqual(expected, hashTable.getString(key));
-        }
-
-        void itemMustNotExist(const char* key)
-        {
-            Assert::IsFalse(hashTable.containsKey(key));
-            Assert::IsFalse(hashTable.getHashTable(key).success());
-            Assert::IsFalse(hashTable.getArray(key).success());
-            Assert::IsFalse(hashTable.getBool(key));
-            Assert::AreEqual(0.0, hashTable.getDouble(key));
-            Assert::AreEqual(0L, hashTable.getLong(key));
-            Assert::IsNull(hashTable.getString(key));
-        }
-
-        void itemMustBeAnArray(const char* key)
-        {
-            nestedArray = hashTable.getArray(key);
-            Assert::IsTrue(nestedArray.success());
-        }
-
-        void arrayLengthMustBe(int expected)
-        {
-            Assert::AreEqual(expected, nestedArray.getLength());
-        }
-
-        void arrayItemMustBe(int index, long expected)
-        {
-            Assert::AreEqual(expected, nestedArray.getLong(index));
-        }
-    };
-}

JsonParserTests/JsonParserTests.vcxproj

@@ -1,102 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{4DD596EF-0185-4AB4-A3C2-F20C496F7806}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>ArduinoJsonParserTests</RootNamespace>
-    <ProjectName>JsonParserTests</ProjectName>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);..</IncludePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>ARDUINO_JSON_NO_DEPRECATION_WARNING;_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="JsonObjectIteratorTests.cpp" />
-    <ClCompile Include="JsonArrayTests.cpp" />
-    <ClCompile Include="JsonArrayIteratorTests.cpp" />
-    <ClCompile Include="JsonObjectTests.cpp" />
-    <ClCompile Include="GbathreeBug.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\JsonParser\JsonParser.vcxproj">
-      <Project>{c15274de-2695-4dfe-8520-4424223fe6da}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

JsonParserTests/JsonParserTests.vcxproj.filters

@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="JsonArrayTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="GbathreeBug.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonObjectTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonArrayIteratorTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonObjectIteratorTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

JsonParserTests/TestHashGenerator.cpp

@@ -1,25 +0,0 @@
-#include "stdafx.h"
-#include "CppUnitTest.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(TestHashGenerator)
-	{
-	public:
-		
-		TEST_METHOD(TestMethod1)
-		{
-            JsonArray<5> arr;
-            arr.Add(1);
-            arr.Add("Hi!");
-
-            JsonHashTable<4> hash;
-            hash.Add("key1", 1);
-            hash.Add("key2", "Hello!");
-            hash.Add("key3", arr);
-		}
-
-	};
-}

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,58 +1,114 @@
-Arduino JSON library
-====================
+![ArduinoJson](banner.svg)
 
-*An elegant and efficient JSON library for embedded systems.*
+---
 
-It's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
+[![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=6.13.0)](https://www.ardu-badge.com/ArduinoJson/6.13.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)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/arduinojson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
+[![Coverage Status](https://coveralls.io/repos/github/bblanchon/ArduinoJson/badge.svg?branch=6.x)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
+[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat)](https://github.com/bblanchon/ArduinoJson/stargazers)
 
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
+ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
 
-Features
---------
+## Features
 
-* JSON decoding: [more details here](/JsonParser/)
-* JSON encoding: [more details here](/JsonGenerator/)
-* Elegant API, very easy to use 
-* Fixed memory allocation (no malloc)
+* 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
-* MIT License
+* Input and output streams
+* [100% code coverage](https://coveralls.io/github/bblanchon/ArduinoJson)
+* [Header-only library](https://en.wikipedia.org/wiki/Header-only)
+* [MIT License](https://en.wikipedia.org/wiki/MIT_License)
+* [Comprehensive documentation](https://arduinojson.org?utm_source=github&utm_medium=readme)
 
-Feature comparison
-------------------
+## Compatibility
 
-| Library      | Memory allocation | Nested objects | Parser size | Encoder size  |
-| ------------ | ----------------- | -------------- | ----------- | ------------- |
-| Arduino JSON | static            | yes            | 2642 Bytes  | 862 bytes     |
-| json-arduino | dynamic           | no             | 3348 (+27%) | not supported |
-| aJson        | dynamic           | yes            | 5088 (+93%) | 4678 (+540%)  |
+ArduinoJson works on the following hardware:
 
-"Parser size" was measured with a program parsing `{"sensor":"outdoor","value":25.6}`.
-For each library, I wrote a program that extracts a string and a float. I subtracted the size of a program doing the same without any JSON parsing involved. [Source files are here](https://gist.github.com/bblanchon/e8ba914a7109f3642c0f).
+* <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)...
 
-"Encoder size" was measured with a program generating `{"sensor":"outdoor","value":25.6}`.
-[Source files are here](https://gist.github.com/bblanchon/60224e9dcfeab4ddc7e9).
+ArduinoJson compiles with zero warning on the following compilers, IDEs, and platforms:
 
-In each case the target platform was an Arduino Duemilanove and Arduino IDE 1.0.5 was used. 
+* <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/)
 
-Links: [json-arduino](https://github.com/not404/json-arduino), [aJson](https://github.com/interactive-matter/aJson) 
+## Quickstart
 
-Testimonials
-------------
+### Deserialization
 
-From Arduino's Forum user `jflaplante`:
-> I tried the  [aJson and json-arduino] before trying your library. I always ran into memory problem after a while. 
-> I have no such problem so far with your library. It is working perfectly with my web services.
+Here is a program that parses a JSON document with ArduinoJson.
 
-From Arduino's Forum user `gbathree`:
-> Thanks so much - this is an awesome library!  If you want to see what we're doing with it - the project is located at www.photosynq.org.
+```c++
+char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-From StackOverflow user `thegreendroid`:
-> It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
+DynamicJsonDocument doc(1024);
+deserializeJson(doc, json);
 
-Related blog posts
------
+const char* sensor = doc["sensor"];
+long time          = doc["time"];
+double latitude    = doc["data"][0];
+double longitude   = doc["data"][1];
+```
 
-* [The project I originally wrote this library for](http://blog.benoitblanchon.fr/rfid-payment-terminal/)
-* [Motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
-* [Release of version 2](http://blog.benoitblanchon.fr/arduino-json-v2-0/)
-* [Release of version 3](http://blog.benoitblanchon.fr/arduino-json-v3-0/)
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
+
+### Serialization
+
+Here is a program that generates a JSON document with ArduinoJson:
+
+```c++
+DynamicJsonDocument doc(1024);
+
+doc["sensor"] = "gps";
+doc["time"]   = 1351824120;
+
+JsonArray data = doc.createNestedArray("data");
+data.add(48.756080);
+data.add(2.302038);
+
+serializeJson(doc, Serial);
+// This prints:
+// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+```
+
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme)
+
+## Documentation
+
+The documentation is available on [arduinojson.org](https://arduinojson.org/?utm_source=github&utm_medium=readme), here are some shortcuts:
+
+* 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!
+
+---
+
+Do you like this library? Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)!
+
+What? You don't like it but you *love* it?
+We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time!

SUPPORT.md

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

appveyor.yml

@@ -0,0 +1,20 @@
+version: 6.13.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 .

component.mk

@@ -0,0 +1 @@
+COMPONENT_ADD_INCLUDEDIRS := src

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -1,43 +0,0 @@
-/*
- * Arduino JSON library - IndentedPrint example
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include <JsonGenerator.h>
-
-using namespace ArduinoJson::Generator;
-
-void setup()
-{
-    Serial.begin(9600);
-    
-    JsonObject<1> json;
-    json["key"] = "value";
-    
-    IndentedPrint serial(Serial);    
-    serial.setTabSize(4);
-    
-    serial.println("This is at indentation 0");
-    serial.indent();
-    serial.println("This is at indentation 1");
-    serial.println("This is also at indentation 1");
-    serial.indent();
-    serial.println("This is at indentation 2");
-    
-    serial.println("You can print JSON here, as usual:");
-    serial.println(json);
-    serial.println();
-        
-    serial.println("But you can also prettyPrint JSON here:");
-    json.prettyPrintTo(serial);  
-    serial.println();
-    
-    serial.unindent();
-    serial.unindent();
-    serial.println("This is back at indentation 0");
-}
-
-void loop()
-{
-
-}

examples/JsonConfigFile/JsonConfigFile.ino

@@ -0,0 +1,154 @@
+// 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
+// }
+//
+// To run this program, you need an SD card connected to the SPI bus as follows:
+// * MOSI <-> pin 11
+// * MISO <-> pin 12
+// * CLK  <-> pin 13
+// * CS   <-> pin 4
+//
+// 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
+  const int chipSelect = 4;
+  while (!SD.begin(chipSelect)) {
+    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

@@ -1,32 +1,77 @@
-/*
- * Arduino JSON library - Generator example
- * Benoit Blanchon 2014 - MIT License
- */
+// 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 <JsonGenerator.h>
+#include <ArduinoJson.h>
 
-using namespace ArduinoJson::Generator;
+void setup() {
+  // Initialize Serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
 
-void setup()
-{
-    Serial.begin(9600);
+  // 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;
 
-    JsonArray<2> array;
-    array.add<6>(48.756080); // 6 is the number of decimals to print
-    array.add<6>(2.302038);  // if not specified, 2 digits are printed
+  // StaticJsonObject allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument  doc(200);
 
-    JsonObject<3> root; 
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
-    root["data"] = array;
+  // Add values in the document
+  //
+  doc["sensor"] = "gps";
+  doc["time"] = 1351824120;
 
-    Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+  // Add an array.
+  //
+  JsonArray data = doc.createNestedArray("data");
+  data.add(48.756080);
+  data.add(2.302038);
 
-    Serial.println();
-    root.prettyPrintTo(Serial); // same string indented
+  // 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()
-{
+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,40 +1,80 @@
-/*
-* Arduino JSON library - Parser Example
-* Benoit Blanchon 2014 - MIT License
-*/
+// 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 <JsonParser.h>
+#include <ArduinoJson.h>
 
-using namespace ArduinoJson::Parser;
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
 
-void setup()
-{
-    Serial.begin(9600);
+  // 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;
 
-    char json [] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+  // StaticJsonDocument<N> allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument doc(200);
 
-    JsonParser<16> parser;
+  // 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]}";
 
-    JsonObject root = parser.parse(json);
+  // Deserialize the JSON document
+  DeserializationError error = deserializeJson(doc, json);
 
-    if (!root.success())
-    {
-        Serial.println("JsonParser.parse() failed");
-        return;
-    }
+  // Test if parsing succeeds.
+  if (error) {
+    Serial.print(F("deserializeJson() failed: "));
+    Serial.println(error.c_str());
+    return;
+  }
 
-    char*  sensor    = root["sensor"];
-    long   time      = root["time"];
-    double latitude  = root["data"][0];
-    double longitude = root["data"][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];
 
-    Serial.println(sensor);
-    Serial.println(time);
-    Serial.println(latitude, 6);
-    Serial.println(longitude, 6);
+  // Print values.
+  Serial.println(sensor);
+  Serial.println(time);
+  Serial.println(latitude, 6);
+  Serial.println(longitude, 6);
 }
 
-void loop()
-{
+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 ❤❤❤❤❤

extras/ci/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

extras/ci/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 .

extras/ci/coverage.sh

@@ -0,0 +1,9 @@
+#!/bin/sh -eux
+
+cmake -DCOVERAGE=true .
+make 
+make test
+
+pip install --user cpp-coveralls 'requests[security]'
+pwd
+coveralls --include 'src' --gcov-options '\-lp'