Set version to 5.5.1

Moved all build settings to `ArduinoJson/Configuration.hpp`
Added AppVeyor settings in source tree

.clang-format

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

.gitattributes

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

.gitignore

@@ -3,3 +3,6 @@
 /build
 /bin
 /lib
+/sftp-config.json
+.tags
+.tags_sorted_by_file

.travis.yml

@@ -1,6 +1,118 @@
-language: c++
-compiler:
-  - gcc
-  - clang
-before_script: cmake .
-script: make && make test
+sudo: false
+language: cpp
+matrix:
+  include:
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.4']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.4
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.5']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.5
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.6']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.6
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.7']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.7
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.8']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.8
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.9']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.9
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-5']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-5
+    - compiler: clang
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++
+    # - compiler: clang
+    #   addons:
+    #     apt:
+    #       sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.5']
+    #       packages: ['clang-3.5']
+    #   env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.5
+    # - compiler: clang
+    #   addons:
+    #     apt:
+    #       sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.6']
+    #       packages: ['clang-3.6']
+    #   env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.6
+    # - compiler: clang
+    #   addons:
+    #     apt:
+    #       sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.7']
+    #       packages: ['clang-3.7']
+    #   env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.7
+    # - compiler: clang
+    #   addons:
+    #     apt:
+    #       sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
+    #       packages: ['clang-3.8']
+    #   env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.8
+    - compiler: gcc
+      env: SCRIPT=coverage
+    - os: osx
+      osx_image: beta-xcode6.1
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: beta-xcode6.2
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: beta-xcode6.3
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode6.4
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7.1
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7.2
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - env: SCRIPT=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
+    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
+    - env: SCRIPT=arduino VERSION=1.6.8 BOARD=arduino:avr:uno
+    - env: SCRIPT=arduino VERSION=1.6.9 BOARD=arduino:avr:uno
+    - env: SCRIPT=platformio BOARD=uno
+    - env: SCRIPT=platformio BOARD=due
+    - env: SCRIPT=platformio BOARD=esp01
+    - env: SCRIPT=platformio BOARD=teensy31
+cache:
+  directories:
+    - "~/.platformio"
+script: scripts/travis/$SCRIPT.sh

ArduinoJson.h

@@ -0,0 +1,14 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+// About this file
+// ---------------
+// This file is here for [PlatformIO](http://platformio.org/).
+// It must be present in the root for the tool to find it.
+// Feel free to ignore this file if your working in another environment.
+
+#include "include/ArduinoJson.h"

CHANGELOG.md

@@ -1,5 +1,169 @@
-Arduino JSON: change log
-========================
+ArduinoJson: change log
+=======================
+
+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**:
+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**:
+- `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**:
+- `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!
+
+v4.6
+----
+
+* Fixed segmentation fault in `DynamicJsonBuffer` when memory allocation fails (issue #92)
+
+v4.5
+----
+
+* Fixed buffer overflow when input contains a backslash followed by a terminator (issue #81)
+
+**Upgrading is recommended** since previous versions contain a potential security risk.
+
+Special thanks to [Giancarlo Canales Barreto](https://github.com/gcanalesb) for finding this nasty bug.
+
+v4.4
+----
+
+* Added `JsonArray::measureLength()` and `JsonObject::measureLength()` (issue #75)
+
+v4.3
+----
+
+* Added `JsonArray::removeAt()` to remove an element of an array (issue #58)
+* Fixed stack-overflow in `DynamicJsonBuffer` when parsing huge JSON files (issue #65)
+* Fixed wrong return value of `parseArray()` and `parseObject()` when allocation fails (issue #68)
+
+v4.2
+----
+
+* Switched back to old library layout (issues #39, #43 and #45)
+* Removed global new operator overload (issue #40, #45 and #46)
+* Added an example with EthernetServer
+
+v4.1
+----
+
+* Added DynamicJsonBuffer (issue #19)
 
 v4.0
 ----
@@ -7,14 +171,14 @@ v4.0
 * Unified parser and generator API (issue #23)
 * Updated library layout, now requires Arduino 1.0.6 or newer
 
-**BREAKING CHANGE**: API changed significantly, see `doc/Migrating to the new API.md`.
+**BREAKING CHANGE**: API changed significantly, see [Migrating code to the new API](https://github.com/bblanchon/ArduinoJson/wiki/Migrating-code-to-the-new-API).
 
 
 v3.4
 ----
 
 * Fixed escaped char parsing (issue #16)
-  
+
 
 v3.3
 ----
@@ -109,4 +273,4 @@ v1.1
 v1.0 
 ----
 
-Initial release
+Initial release

CMakeLists.txt

@@ -1,4 +1,11 @@
-cmake_minimum_required(VERSION 2.8.4)
+# Copyright Benoit Blanchon 2014-2016
+# MIT License
+# 
+# Arduino JSON library
+# https://github.com/bblanchon/ArduinoJson
+# If you like this project, please add a star!
+
+cmake_minimum_required(VERSION 2.8.12)
 project(ArduinoJson)
 
 enable_testing()
@@ -7,9 +14,9 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
 
-if(MSVC)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS -W4)
+if(${COVERAGE})
+	set(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
 endif()
 
 add_subdirectory(src)
-add_subdirectory(test)
+add_subdirectory(test)

LICENSE.md

@@ -1,10 +1,10 @@
 The MIT License (MIT)
 ---------------------
 
-Copyright © 2014 Benoit BLANCHON
+Copyright © 2014-2016 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.
+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,65 +1,88 @@
 Arduino JSON library
 ====================
 
-[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson)
+[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master) [![Star this project](http://githubbadges.com/star.svg?user=bblanchon&repo=ArduinoJson&style=flat&color=fff&background=007ec6)](https://github.com/bblanchon/ArduinoJson)
 
 *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).
+It's designed 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
 --------
 
-* JSON decoding
+* JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
-* Elegant API, very easy to use 
-* Fixed memory allocation (no malloc)
+* Elegant API, very easy to use
+* Fixed memory allocation (zero malloc)
+* No data duplication (zero copy)
+* Portable (written in C++98)
+* Self-contained (no external dependency)
 * Small footprint
 * MIT License
 
+Works on
+--------
+
+* All Arduino boards (Uno, Due, Mini, Micro, Yun...)
+* ESP8266
+* Teensy
+* Intel Edison and Galileo
+* PlatformIO
+* Energia
+* RedBearLab boards (BLE Nano...)
+* Computers (Windows, Linux, OSX...)
+
+See [FAQ: Compatibility issues](https://github.com/bblanchon/ArduinoJson/wiki/Compatibility-issues)
+
 Quick start
 -----------
 
 #### Decoding / Parsing
-   
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    StaticJsonBuffer<200> jsonBuffer;
+```c++
+char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    JsonObject& root = jsonBuffer.parseObject(json);
+StaticJsonBuffer<200> jsonBuffer;
 
-    const char* sensor = root["sensor"];
-    long time          = root["time"];
-    double latitude    = root["data"][0];
-    double longitude   = root["data"][1];
+JsonObject& root = jsonBuffer.parseObject(json);
 
-[See complete guide](/doc/Decoding JSON.md)
+const char* sensor = root["sensor"];
+long time          = root["time"];
+double latitude    = root["data"][0];
+double longitude   = root["data"][1];
+```
 
 #### Encoding / Generating
-   
-    StaticJsonBuffer<200> jsonBuffer;
 
-    JsonObject& root = jsonBuffer.createObject();
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
+```c++
+StaticJsonBuffer<200> jsonBuffer;
 
-    JsonArray& data = root.createNestedArray("data");
-    data.add(48.756080, 6);  // 6 is the number of decimals to print
-    data.add(2.302038, 6);   // if not specified, 2 digits are printed
+JsonObject& root = jsonBuffer.createObject();
+root["sensor"] = "gps";
+root["time"] = 1351824120;
 
-    root.printTo(Serial);
-    // This prints:
-    // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+JsonArray& data = root.createNestedArray("data");
+data.add(48.756080, 6);  // 6 is the number of decimals to print
+data.add(2.302038, 6);   // if not specified, 2 digits are printed
 
-[See complete guide](/doc/Encoding JSON.md)
+root.printTo(Serial);
+// This prints:
+// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+```
+
+
+Documentation
+-------------
+
+The documentation is available online in the [Arduino JSON wiki](https://github.com/bblanchon/ArduinoJson/wiki)
 
 Testimonials
 ------------
 
 From Arduino's Forum user `jflaplante`:
-> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while. 
+> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while.
 > I have no such problem so far with your library. It is working perfectly with my web services.
 
 From Arduino's Forum user `gbathree`:
@@ -69,11 +92,38 @@ From StackOverflow user `thegreendroid`:
 > It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
 
 From GitHub user `zacsketches`:
-
 > Thanks for a great library!!!
 > I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
 > ArduinoJson saved me a week's worth of time!!
 
+[From Reddit user `erm_what_`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusjk8c):
+> This is a great library and I wouldn't be able to do the project I'm doing without it. I completely recommend it.
+
+[From Reddit user `makerhacks`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusqg7b):
+> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.
+
+[From Twitter user `@hemalchevli`](https://twitter.com/hemalchevli/status/715788439397011456):
+> ArduinoJson library should be used as a benchmark/reference for making libraries. Truly elegant.
+
+Donators
+--------
+
+Special thanks to the following persons and companies who made generous donations to the library author:
+
+* Robert Murphy <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Surge Communications <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Alex Scott <img alt='United Kingdom' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1e7.svg' width='18' height='18'>
+* Firepick Services LLC <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* A B Doodkorte <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
+* Scott Smith <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Johann Stieger <img alt='Austria' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e6-1f1f9.svg' width='18' height='18'>
+* Gustavo Donizeti Gini <img alt='Brazil' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e7-1f1f7.svg' width='18' height='18'>
+* Charles-Henri Hallard <img alt='France' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1eb-1f1f7.svg' width='18' height='18'>
+* Martijn van den Burg <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
+* Nick Koumaris <img alt='Greece' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1f7.svg' width='18' height='18'>
+* Jon Williams <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Kestutis Liaugminas <img alt='Lithuania' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f1-1f1f9.svg' width='18' height='18'>
+
 ---
 
-Found this library useful? [Help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:
+Found this library useful? Please star this project or [help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:

appveyor.yml

@@ -0,0 +1,16 @@
+version: 5.5.1.{build}
+environment:
+  matrix:
+  - CMAKE_GENERATOR: Visual Studio 14 2015
+  - 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 -V .

doc/Avoiding pitfalls.md

@@ -1,102 +0,0 @@
-Avoiding common pitfalls in Arduino JSON
-========================================
-
-As `StaticJsonBuffer` is the corner stone of this library, you'll see that every pitfall listed here are related to a wrong understanding of the memory model.
-
-Make sure you read [Arduino JSON memory model](Memory model.md) before going further.
-
-## 1. Make `StaticJsonBuffer` big enough
-
-By design, the library has no way to tell you why `parseArray()` or `parseObject()` failed.
-
-There are basically two reasons why they may fail:
-
-1. the JSON string is invalid,
-2. the JSON string contains more values that the buffer can store.
-
-So, if you are sure the JSON string is correct and you still can't parse it, you should try to increase the size of the `StaticJsonBuffer`.
-
-## 2. Make sure everything fits in 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
-    StaticJsonBuffer<512> buffer;   // 514 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. Keep the `StaticJsonBuffer` in memory long enough
-
-Remember that `StaticJsonBuffer`'s function return references.
-References don't contain data, they are just pointer to the actual.
-So they can only work if the actual data is in memory.
-
-For example, don't do this:
-
-    JsonArray& getArray(char* json)
-    {
-        StaticJsonBuffer<200> buffer;
-        return buffer.parseArray(json); 
-    }
-
-because the local variable `buffer` will be *removed* from memory when the function `parseArray()` returns, and the `JsonArray&` will point to an invalid location.
-
-## 4. Don't reuse the same `StaticJsonBuffer`
-
-During is lifetime a `StaticJsonBuffer` growth until it's discarded. If you try to reuse the same instance several time, it will rapidly get full.
-
-For this reason, you should not use a global variable for your `StaticJsonBuffer`. I don't think there is any scenario in which a global `StaticJsonBuffer` would be a valid option.
-
-The best practice is to declare it in a local scope, so that it's discarded as soon as possible. My advice it to declare it in a function which unique role is to handle the JSON serialization.
-
-## 5. Keep the JSON string in memory long enough
-
-The library never make memory duplication.
-This has an important implication on string values, it means that the library will return pointer to chunks of the string.
-
-For instance, let's imagine that you parse `["hello","world"]`, like this:
-
-    char[] json = "[\"hello\",\"world\"]";
-    StaticJsonBuffer<32> buffer;
-    JsonArray& array = buffer.parseArray(json);
-
-    const char* first = array[0];
-    const char* second = array[1];
-
-In that case, both `first` and `second` are pointers to the content of the original string `json`.
-So this will only work if `json` is still in memory.
-
-## 6. JSON string is altered
-
-If you read carefully the previous section, you may have come to the conclusion that the JSON parser modifies the JSON string.
-
-Indeed, the parser modifies the string for two reasons:
-
-1. it inserts `\0` to terminate substrings,
-2. it translate escaped characters like `\n` or `\t`.
-
-Most of the time this wont be an issue, but there are some corner cases that can be problematic.
-
-Let take the example bellow:
-
-    char[] json = "[\"hello\",\"world\"]";
-    StaticJsonBuffer<32> buffer;
-    JsonArray& array = buffer.parseArray(json);
-
-If you replace it by:
-
-    char* json = "[\"hello\",\"world\"]";
-    StaticJsonBuffer<32> buffer;
-    JsonArray& array = buffer.parseArray(json);
-
-Depending on your platform, you may have an exception because the parser tries to write at a location that is read-only.
-In the first case `char json[]` declares an array of `char` initialized to the specified string.
-In the second case `char* json` declares a pointer to a read-only string, in fact it should be a `const char*` instead of a `char*`.
-

doc/Contributing.md

@@ -1,15 +0,0 @@
-Contributing to Arduino JSON
-============================
-
-If you want to contribute to the project, please:
-
-1. Use GitHub pull request feature
-2. Follow the coding conventions
-3. Write tests
-
-About the coding conventions: I try to follow the [Google C++ Style Guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.html) with few variations to match the Arduino conventions.
-
-I use [ClangFormat](http://clang.llvm.org/docs/ClangFormat.html) to format the code for me.
-I use [CppLint](http://google-styleguide.googlecode.com/svn/trunk/cpplint/cpplint.py) to detect non-compliant stuff.
-
-You should have a look at the `scripts/` folder as it contains a few helpers scripts.

doc/Decoding JSON.md

@@ -1,148 +0,0 @@
-Decoding JSON with Arduino JSON
-===============================
-
-Before writing any code, don't forget to include the header:
-
-    #include <ArduinoJson.h>
-
-For instructions on how to install the library, please read [Using the library with Arduino](Using the library with Arduino.md) or [Using the library without Arduino](Using the library without Arduino.md).
-
-## Example
-
-Here an example that parse the string `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`:
-
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-    
-    //
-    // Step 1: Reserve memory space
-    //
-    StaticJsonBuffer<200> jsonBuffer;
-    
-    //
-    // Step 2: Deserialize the JSON string
-    //
-    JsonObject& root = jsonBuffer.parseObject(json);
-
-    if (!root.success())
-    {
-      Serial.println("parseObject() failed");
-      return;
-    }
-
-    //
-    // Step 3: Retrieve the values
-    //
-    const char* sensor    = root["sensor"];
-    long        time      = root["time"];
-    double      latitude  = root["data"][0];
-    double      longitude = root["data"][1];
-
-## Step 1: Reserve memory space
-
-Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer`.
-
-Before continuing please read the page [Arduino JSON memory model](Memory model.md) that explains everything you need to know about `StaticJsonBuffer`.
-
-## Step 2: Parse the JSON string
-
-You invoke the JSON parser through the instance of `StaticJsonBuffer`.
-It exposes two functions for parsing JSON:
-
-1. `parseArray()` that returns a reference to a `JsonArray`
-2. `parseObject()` that returns a reference to a `JsonObject`
-
-Let's see an example.
-Say we want to parse `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`, it's an object so we call `parseObject()` as follows:
-
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-
-    JsonObject& root = jsonBuffer.parseObject(json);
-
-As you can see `parseObject()` takes a `char*` as a parameter.
-Be careful, it's not a `const char*`, the memory must be writable.
-Indeed, the parser will modify the string in two cases:
-
-1. to insert string endings (character `\0`),
-2. to translate escaped characters (like `\n` or `\t`).
-
-Another thing that you must keep in mind is that the string (`char json[]` in the example above) must stay in memory during the whole parsing process.
-That is because the in memory object tree will store pointer to chunks of the string, so as to avoid any memory duplication. 
-
-Now, to check if the parsing was successful, you can call `JsonObject::success()`:
-
-    if (!root.success())
-    {
-        // Parsing fail
-    }
-
-The result can be `false` for tree reasons:
-
-1. the JSON string is invalid,
-2. the JSON string doesn't represent an object,
-3. the `StaticJsonBuffer` is too small.
-
-We just saw how to parse an object, there is nothing more to say for arrays, the procedure is exactly the same.
-
-## Step 3: Retrieve the values
-
-Now that the object or array is in memory, you can extract the data very easily.
-
-In this section, we'll see how to do it with a `JsonObject`.
-Once again, there is nothing more to say about arrays, `JsonArray` works exactly the same as `JsonObject`.
-
-#### Subscript operator
-
-The simplest way is to use the subscript operator of `JsonObject`:
-    
-    const char* sensor = root["sensor"];
-    long time = root["time"];
-
-You can chain the subscript operator if you have nested arrays or objects:
-
-    double latitude  = root["data"][0];
-    double longitude = root["data"][1];
-
-But alternatively, you can get a reference to the nested array:
-
-    JsonArray& nestedArray = root["data"];
-
-#### Casting values
-
-In the previous examples, the values were implicitly casted to the target type.
-You can also do this explicitly
-
-    const char* sensor = root["sensor"].asString();
-    long time = root["time"].as<long>();
-    JsonArray& nestedArray = root["data"].asArray();
-
-If the actual value doesn't match the target type, a default value will be return:
-
-1. `false` for boolean values
-2. `0` for integer values
-3. `NULL` for string values
-4. `JsonArray::invalid()` for nested arrays
-5. `JsonObject::invalid()` for nested object
-
-#### Check values
-
-If you want to know if some value is present, call `containsKey()`:
-
-    if (root.contains("extra"))
-    {
-        // root["extra"] is valid
-    }
-
-If you want to check the type value has a certain type, call `is<T>()`:
-
-    if (root["extra"].is<JsonArray&>())
-    {
-        // root["extra"] is an array
-    }
-
-You can also iterate through the key-value pairs of the object:
-
-    for (JsonObject::itertor it=root.begin(); it!=root.end(); ++it)
-    {
-      Serial.println(it->key);
-      Serial.println(i->value.asString());
-    }

doc/Encoding JSON.md

@@ -1,140 +0,0 @@
-Encoding JSON with Arduino JSON
-===============================
-
-Before writing any code, don't forget to include the header:
-
-    #include <ArduinoJson.h>
-
-For instructions on how to install the library, please read [Using the library with Arduino](Using the library with Arduino.md) or [Using the library without Arduino](Using the library without Arduino.md).
-
-## Example
-
-Here is an example to generate `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`
-
-    //
-    // Step 1: Reserve memory space
-    //
-    StaticJsonBuffer<200> jsonBuffer;
-
-    //
-    // Step 2: Build object tree in memory
-    //
-    JsonObject& root = jsonBuffer.createObject();
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
-
-    JsonArray& data = root.createNestedArray("data");
-    data.add(48.756080, 6);  // 6 is the number of decimals to print
-    data.add(2.302038, 6);   // if not specified, 2 digits are printed
-
-    //
-    // Step 3: Generate the JSON string
-    //
-    root.printTo(Serial);
-
-## Step 1: Reserve memory space
-
-Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer`.
-
-Before continuing please read the page [Arduino JSON memory model](Memory model.md) that explains everything you need to know about `StaticJsonBuffer`.
-
-## Step 2: Build object tree in memory
-
-Now that you have enough memory hold by the `StaticJsonBuffer`, you can use it to build your in-memory representation of the JSON string.
-
-#### Arrays
-
-You create an array like this:
-
-    JsonArray& array = jsonBuffer.createArray();
-
-Don't forget the `&` after `JsonArray`, it needs to be a reference to 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(3.1415, 4);  // 4 digits: "3.1415"
-    array.add(3.1415);	   // 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 2.
-> 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 this behavior.
-
-You can add a nested array or object if you have a reference to it.
-Or simpler, you can create nested array or nested objects from the array:
-
-    JsonArray&  nestedArray  = array.createNestedArray();
-    JsonObject& nestedObject = array.createNestedObject();
-
-#### Objects
-
-You create an object like this:
-
-    JsonObject& object = jsonBuffer.createObject();
-
-Again, don't forget the `&` after `JsonObject`, it needs to be a reference to 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(3.1415, 4);  // 4 digits "3.1415"
-    object["key5"] = 3.1415;	    // default: 2 digits "3.14"
-
-You can add a nested array or object if you have a reference to it.
-Or simpler, you can create nested array or nested objects from the object:
-
-    JsonArray&  nestedArray  = object.createNestedArray("key6");
-    JsonObject& nestedObject = object.createNestedObject("key7");
-
-> ##### 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`
-
-## Step 3: Generate 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 `Print` implementation 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 `Print` implementation
-
-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:
-
-    array.printTo(Serial);
-
-And, of course if you need an indented JSON string:
-
-    array.prettyPrintTo(Serial);
-
-> ##### About the Print interface
-> The library is designed to send the JSON string to an implementation of the `Print` interface that is part of Arduino.
-> In the example above we used `Serial`, but they are many other implementations that would work as well, including: `HardwareSerial`,  `SoftwareSerial`, `LiquidCrystal`, `EthernetClient`, `WiFiClient`, `Wire`...
-> When you use this library out of the Arduino environment, it will use it's own implementation of `Print` and everything will be the same.

doc/Memory model.md

@@ -1,58 +0,0 @@
-Arduino JSON memory model
-=========================
-
-## Fixed memory allocation
-
-### Introducing `StaticJsonBuffer`
-
-Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer` class.
-
-Before using any function of the library you need to create a `StaticJsonBuffer`. Then you can use this instance to create arrays and objects, or parse a JSON string.
-
-`StaticJsonBuffer` has a template parameter that determines its capacity. For example, the following line create a `StaticJsonBuffer` with a capacity of 200 bytes:
-
-    StaticJsonBuffer<200> jsonBuffer;
-
-The bigger the buffer is, the more complex the object tree can be, but also the more memory you need.
-
-### How to determine the buffer size?
-
-So the big question you should have in mind right now is *How can I determine the size?*.
-
-There are basically two approaches here:
-
-1. either you can predict the content of the object tree,
-2. or, you know how much memory is available.
-
-In the first case, you know some constraints on the object tree. For instance, let's say that your know in advance (and by that I mean "at compilation time") that you want to generate an object with 3 values, one of them being an array with 2 values, like the following:
-
-    {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
-
-To determine the memory usage of this object tree, you use the two macros `JSON_ARRAY_SIZE(n)` and `JSON_OBJECT_SIZE(n)`, both take the number of elements as an argument.
-For the example above, it would be:
-
-    const int BUFFER_SIZE = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2);
-    StaticJsonBuffer<BUFFER_SIZE> jsonBuffer;
-
-In the second case, let's say you dynamically generate a JSON object tree of a random complexity so you can't put a limit based on that. But on the other hand, you don't want your program to crash because the object tree doesn't fit in memory.
-The solution here is to determine how much memory is available, or in other words how much memory you can afford for the JSON object tree.
-
-### Why choosing fixed allocation?
-
-This fixed allocation approach may seem a bit strange, especially if your a desktop application developer used to dynamic allocation, but it make a lot of sense in an embedded context:
-
-1. the code is smaller
-2. it uses less memory
-3. it doesn't create memory fragmentation
-4. it predictable
-
-Don't forget that the memory is "freed" as soon as the `StaticJsonBuffer` is out of scope, like any other variable. It only hold the memory for a short amount of time.
-
-## Memory usage
-
-#### Object size for 8-bit AVR
-
-| Type                    | Size       |
-|-------------------------|------------|
-| JsonArray of N element  | 4 + 8 * N  |
-| JsonObject of N element | 4 + 10 * N |

doc/Migrating code to new API.md

@@ -1,80 +0,0 @@
-Migrating code written for Arduino JSON v3 to v4
-================================================
-
-Arduino JSON v4 was a major rewrite of the library, and the API changed significantly.
-
-## Includes
-
-Arduino JSON v3 had two include files:
-
-    #include <JsonParser.h>
-    #include <JsonGenerator.h>
-
-Arduino JSON v4 only has one:
-
-	#include <ArduinoJson.h>
-
-## Namespaces
-
-Arduino JSON v3 had two namespaces:
-
-	using namespace ArduinoJson::Parser;
-	using namespace ArduinoJson::Generator;
-
-Arduino JSON v4 doesn't require the `using namespace` statement.
-It has a namespace but the `using namespace` is done in the header file.
-
-## StaticJsonBuffer
-
-Arduino JSON v3 had different memory allocation models for the parser:
-
-	JsonParser<16> parser; // 16 being the capacity in "tokens"
-
-and for the generator:
-
-	JsonArray<4> array; // 4 being the number of element
-	JsonObject<4> object;
-
-Arduino JSON v4 only has one memory allocation model:
-
-	StaticJsonBuffer<128> buffer; // 128 being the capacity in bytes
-
-## Return values for the parser
-
-Arduino JSON v3 returned value types:
-
-	JsonArray array = parser.parseArray(json);
-	JsonObject object = parser.parseObject(json);
-
-Arduino JSON v4 returns references types:
-
-	JsonArray& array = buffer.parseArray(json);
-	JsonObject& object = buffer.parseObject(json);
-
-Everything else is compatible
-
-## Creating arrays and objects
-
-Arduino JSON v3 allowed to create `JsonArray` and `JsonObject` directly:
-
-	JsonArray<4> array;
-	JsonObject<4> object;
-
-Arduino JSON v4 requires that you use a `StaticJsonBuffer` for that:
-
-	JsonArray& array = buffer.createArray();
-	JsonObject& object = buffer.createObject();
-
-Note: you don't have to specify the capacity anymore.
-
-## Printable interface
-
-Arduino JSON v3 used to implement the Printable interface, which allowed statements like:
-
-    Serial.print(array);
-
-But Arduino JSON v4 doesn't, instead you need to write this:
-
-	array.printTo(Serial);
-
-Note: there was a good reason for removing that feature, and it's reducing the size of `JsonArray` and `JsonObject`.

doc/Using the library with Arduino.md

@@ -1,30 +0,0 @@
-Using the library with Arduino
-==============================
-
-This library is primarily design to be used with the Arduino IDE and therefore has a simplified setup procedure for that environment.
-If you don't use the Arduino IDE, please read [Using the library without Arduino](Using the library without Arduino.md).
-
-## Install the library
-
-[Download the zip package](https://github.com/bblanchon/ArduinoJson/releases) and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJson
-
-Then restart the Arduino IDE.
-
-## Run the examples sketches
-
-Click `File` / `Example` / `ArduinoJson`.
-
-![Screen capture of Arduino IDE](http://i.imgur.com/g5UwkVh.png)
-
-## Use the library in your sketches
-
-Just add the following line at the top of your program:
-
-    #include <ArduinoJson.h>
-
-Then follow the instructions:
-
-1. [Parsing JSON](Parsin JSON.md)
-2. [Generating JSON](Generating JSON.md)

doc/Using the library without Arduino.md

@@ -1,37 +0,0 @@
-Using the library without Arduino
-=================================
-
-This library is primarily design to be used with the Arduino IDE and therefore has a simplified setup procedure for that environment.
-If you use the Arduino IDE, please read [Using the library with Arduino](Using the library with Arduino.md).
-
-However, it can be used without Arduino IDE with very little effort.
-
-## Compiling the library
-
-Step 1: Download source code:
-
-    git clone https://github.com/bblanchon/ArduinoJson.git
-
-Step 2: Generate the `Makefile` for your environment
-
-    cd ArduinoJson
-    cmake .
-
-Step 3: Build
-
-	make
-
-## File paths
-
-Assuming you installed the library into `<arduino-json>`, you need to add:
-
-1. `<arduino-json>/include` to your include path
-2. `<arduino-json>/lib` to your library path
-
-
-----------
-
-You are now ready to follow the instructions:
-
-1. [Parsing JSON](Parsin JSON.md)
-2. [Generating JSON](Generating JSON.md)

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -1,7 +1,9 @@
-/*
- * Arduino JSON library - IndentedPrint example
- * Benoit Blanchon 2014 - MIT License
- */
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #include <ArduinoJson.h>
 
@@ -9,6 +11,9 @@ using namespace ArduinoJson::Internals;
 
 void setup() {
   Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
   IndentedPrint serial(Serial);
   serial.setTabSize(4);
@@ -27,4 +32,4 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,23 +1,51 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #include <ArduinoJson.h>
 
 void setup() {
   Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
+  // Memory pool for JSON object tree.
+  //
+  // Inside the brackets, 200 is the size of the pool in bytes.
+  // If the JSON object is more complex, you need to increase that value.
   StaticJsonBuffer<200> jsonBuffer;
 
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
+  // It's simpler but less efficient.
+  //
+  // DynamicJsonBuffer  jsonBuffer;
+
+  // Create the root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
   JsonObject& root = jsonBuffer.createObject();
+
+  // Add values in the object
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do root.set<long>("time", 1351824120);
   root["sensor"] = "gps";
   root["time"] = 1351824120;
 
+  // Add a nested array.
+  //
+  // It's also possible to create the array separately and add it to the
+  // JsonObject but it's less efficient.
   JsonArray& data = root.createNestedArray("data");
-  data.add(48.756080, 6);  // 6 is the number of decimals to print
-  data.add(2.302038, 6);   // if not specified, 2 digits are printed
+  data.add(double_with_n_digits(48.756080, 6));
+  data.add(double_with_n_digits(2.302038, 6));
 
   root.printTo(Serial);
   // This prints:
@@ -39,4 +67,4 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}

examples/JsonHttpClient/JsonHttpClient.ino

@@ -0,0 +1,195 @@
+// Sample Arduino Json Web Client
+// Downloads and parse http://jsonplaceholder.typicode.com/users/1
+//
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <SPI.h>
+#include <Ethernet.h>
+
+EthernetClient client;
+
+const char* server = "jsonplaceholder.typicode.com";  // server's address
+const char* resource = "/users/1";                    // http resource
+const unsigned long BAUD_RATE = 9600;                 // serial connection speed
+const unsigned long HTTP_TIMEOUT = 10000;  // max respone time from server
+const size_t MAX_CONTENT_SIZE = 512;       // max size of the HTTP response
+
+// The type of data that we want to extract from the page
+struct UserData {
+  char name[32];
+  char company[32];
+};
+
+// ARDUINO entry point #1: runs once when you press reset or power the board
+void setup() {
+  initSerial();
+  initEthernet();
+}
+
+// ARDUINO entry point #2: runs over and over again forever
+void loop() {
+  if (connect(server)) {
+    if (sendRequest(server, resource) && skipResponseHeaders()) {
+      char response[MAX_CONTENT_SIZE];
+      readReponseContent(response, sizeof(response));
+
+      UserData userData;
+      if (parseUserData(response, &userData)) {
+        printUserData(&userData);
+      }
+    }
+    disconnect();
+  }
+  wait();
+}
+
+// Initialize Serial port
+void initSerial() {
+  Serial.begin(BAUD_RATE);
+  while (!Serial) {
+    ;  // wait for serial port to initialize
+  }
+  Serial.println("Serial ready");
+}
+
+// Initialize Ethernet library
+void initEthernet() {
+  byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+  if (!Ethernet.begin(mac)) {
+    Serial.println("Failed to configure Ethernet");
+    return;
+  }
+  Serial.println("Ethernet ready");
+  delay(1000);
+}
+
+// Open connection to the HTTP server
+bool connect(const char* hostName) {
+  Serial.print("Connect to ");
+  Serial.println(hostName);
+
+  bool ok = client.connect(hostName, 80);
+
+  Serial.println(ok ? "Connected" : "Connection Failed!");
+  return ok;
+}
+
+// Send the HTTP GET request to the server
+bool sendRequest(const char* host, const char* resource) {
+  Serial.print("GET ");
+  Serial.println(resource);
+
+  client.print("GET ");
+  client.print(resource);
+  client.println(" HTTP/1.1");
+  client.print("Host: ");
+  client.println(server);
+  client.println("Connection: close");
+  client.println();
+
+  return true;
+}
+
+// Skip HTTP headers so that we are at the beginning of the response's body
+bool skipResponseHeaders() {
+  // HTTP headers end with an empty line
+  char endOfHeaders[] = "\r\n\r\n";
+
+  client.setTimeout(HTTP_TIMEOUT);
+  bool ok = client.find(endOfHeaders);
+
+  if (!ok) {
+    Serial.println("No response or invalid response!");
+  }
+
+  return ok;
+}
+
+// Read the body of the response from the HTTP server
+void readReponseContent(char* content, size_t maxSize) {
+  size_t length = client.readBytes(content, maxSize);
+  content[length] = 0;
+  Serial.println(content);
+}
+
+// Parse the JSON from the input string and extract the interesting values
+// Here is the JSON we need to parse
+// {
+//   "id": 1,
+//   "name": "Leanne Graham",
+//   "username": "Bret",
+//   "email": "Sincere@april.biz",
+//   "address": {
+//     "street": "Kulas Light",
+//     "suite": "Apt. 556",
+//     "city": "Gwenborough",
+//     "zipcode": "92998-3874",
+//     "geo": {
+//       "lat": "-37.3159",
+//       "lng": "81.1496"
+//     }
+//   },
+//   "phone": "1-770-736-8031 x56442",
+//   "website": "hildegard.org",
+//   "company": {
+//     "name": "Romaguera-Crona",
+//     "catchPhrase": "Multi-layered client-server neural-net",
+//     "bs": "harness real-time e-markets"
+//   }
+// }
+bool parseUserData(char* content, struct UserData* userData) {
+  // Compute optimal size of the JSON buffer according to what we need to parse.
+  // This is only required if you use StaticJsonBuffer.
+  const size_t BUFFER_SIZE =
+      JSON_OBJECT_SIZE(8)     // the root object has 8 elements
+      + JSON_OBJECT_SIZE(5)   // the "address" object has 5 elements
+      + JSON_OBJECT_SIZE(2)   // the "geo" object has 2 elements
+      + JSON_OBJECT_SIZE(3);  // the "company" object has 3 elements
+
+  // Allocate a temporary memory pool on the stack
+  StaticJsonBuffer<BUFFER_SIZE> jsonBuffer;
+  // If the memory pool is too big for the stack, use this instead:
+  // DynamicJsonBuffer jsonBuffer;
+
+  JsonObject& root = jsonBuffer.parseObject(content);
+
+  if (!root.success()) {
+    Serial.println("JSON parsing failed!");
+    return false;
+  }
+
+  // Here were copy the strings we're interested in
+  strcpy(userData->name, root["name"]);
+  strcpy(userData->company, root["company"]["name"]);
+  // It's not mandatory to make a copy, you could just use the pointers
+  // Since, they are pointing inside the "content" buffer, so you need to make
+  // sure it's still in memory when you read the string
+
+  return true;
+}
+
+// Print the data extracted from the JSON
+void printUserData(const struct UserData* userData) {
+  Serial.print("Name = ");
+  Serial.println(userData->name);
+  Serial.print("Company = ");
+  Serial.println(userData->company);
+}
+
+// Close the connection with the HTTP server
+void disconnect() {
+  Serial.println("Disconnect");
+  client.stop();
+}
+
+// Pause for a 1 minute
+void wait() {
+  Serial.println("Wait 60 seconds");
+  delay(60000);
+}

examples/JsonParserExample/JsonParserExample.ino

@@ -1,31 +1,61 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #include <ArduinoJson.h>
 
 void setup() {
   Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
+  // Memory pool for JSON object tree.
+  //
+  // Inside the brackets, 200 is the size of the pool in bytes,
+  // If the JSON object is more complex, you need to increase that value.
   StaticJsonBuffer<200> jsonBuffer;
 
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
+  // It's simpler but less efficient.
+  //
+  // DynamicJsonBuffer  jsonBuffer;
+
+  // JSON input string.
+  //
+  // It's better to use a char[] as shown here.
+  // If you use a const char* or a String, ArduinoJson will
+  // have to make a copy of the input in the JsonBuffer.
   char json[] =
       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
+  // Root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
   JsonObject& root = jsonBuffer.parseObject(json);
 
+  // Test if parsing succeeds.
   if (!root.success()) {
     Serial.println("parseObject() failed");
     return;
   }
 
+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do root["time"].as<long>();
   const char* sensor = root["sensor"];
   long time = root["time"];
   double latitude = root["data"][0];
   double longitude = root["data"][1];
 
+  // Print values.
   Serial.println(sensor);
   Serial.println(time);
   Serial.println(latitude, 6);
@@ -34,4 +64,4 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}

examples/JsonServer/JsonServer.ino

@@ -0,0 +1,74 @@
+// Sample Arduino Json Web Server
+// Created by Benoit Blanchon.
+// Heavily inspired by "Web Server" from David A. Mellis and Tom Igoe
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <ArduinoJson.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+IPAddress ip(192, 168, 0, 177);
+EthernetServer server(80);
+
+bool readRequest(EthernetClient& client) {
+  bool currentLineIsBlank = true;
+  while (client.connected()) {
+    if (client.available()) {
+      char c = client.read();
+      if (c == '\n' && currentLineIsBlank) {
+        return true;
+      } else if (c == '\n') {
+        currentLineIsBlank = true;
+      } else if (c != '\r') {
+        currentLineIsBlank = false;
+      }
+    }
+  }
+  return false;
+}
+
+JsonObject& prepareResponse(JsonBuffer& jsonBuffer) {
+  JsonObject& root = jsonBuffer.createObject();
+
+  JsonArray& analogValues = root.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    int value = analogRead(pin);
+    analogValues.add(value);
+  }
+
+  JsonArray& digitalValues = root.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    int value = digitalRead(pin);
+    digitalValues.add(value);
+  }
+
+  return root;
+}
+
+void writeResponse(EthernetClient& client, JsonObject& json) {
+  client.println("HTTP/1.1 200 OK");
+  client.println("Content-Type: application/json");
+  client.println("Connection: close");
+  client.println();
+
+  json.prettyPrintTo(client);
+}
+
+void setup() {
+  Ethernet.begin(mac, ip);
+  server.begin();
+}
+
+void loop() {
+  EthernetClient client = server.available();
+  if (client) {
+    bool success = readRequest(client);
+    if (success) {
+      StaticJsonBuffer<500> jsonBuffer;
+      JsonObject& json = prepareResponse(jsonBuffer);
+      writeResponse(client, json);
+    }
+    delay(1);
+    client.stop();
+  }
+}

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -0,0 +1,55 @@
+// Send a JSON object on UDP at regular interval
+//
+// You can easily test this program with netcat:
+// $ nc -ulp 8888
+//
+// by Benoit Blanchon, MIT License 2015-2016
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <ArduinoJson.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+IPAddress localIp(192, 168, 0, 177);
+IPAddress remoteIp(192, 168, 0, 109);
+unsigned int remotePort = 8888;
+unsigned localPort = 8888;
+EthernetUDP udp;
+
+JsonObject& buildJson(JsonBuffer& jsonBuffer) {
+  JsonObject& root = jsonBuffer.createObject();
+
+  JsonArray& analogValues = root.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    int value = analogRead(pin);
+    analogValues.add(value);
+  }
+
+  JsonArray& digitalValues = root.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    int value = digitalRead(pin);
+    digitalValues.add(value);
+  }
+
+  return root;
+}
+
+void sendJson(JsonObject& json) {
+  udp.beginPacket(remoteIp, remotePort);
+  json.printTo(udp);
+  udp.println();
+  udp.endPacket();
+}
+
+void setup() {
+  Ethernet.begin(mac, localIp);
+  udp.begin(localPort);
+}
+
+void loop() {
+  delay(1000);
+
+  StaticJsonBuffer<300> jsonBuffer;
+  JsonObject& json = buildJson(jsonBuffer);
+  sendJson(json);
+}

include/ArduinoJson.h

@@ -1,11 +1,13 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
-#include "../include/ArduinoJson/JsonArray.hpp"
-#include "../include/ArduinoJson/JsonObject.hpp"
-#include "../include/ArduinoJson/StaticJsonBuffer.hpp"
+#include "ArduinoJson/DynamicJsonBuffer.hpp"
+#include "ArduinoJson/JsonArray.hpp"
+#include "ArduinoJson/JsonObject.hpp"
+#include "ArduinoJson/StaticJsonBuffer.hpp"
 
 using namespace ArduinoJson;

include/ArduinoJson/Arduino/Print.hpp

@@ -1,31 +0,0 @@
-// Copyright Benoit Blanchon 2014
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#pragma once
-
-#ifndef ARDUINO
-
-#include <stddef.h>
-#include <stdint.h>
-
-// This class reproduces Arduino's Print
-class Print {
- public:
-  virtual ~Print() {}
-
-  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

include/ArduinoJson/Configuration.hpp

@@ -0,0 +1,89 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#ifdef ARDUINO  // assume this is an embedded platform
+
+// store using float instead of double to reduce the memory usage (issue #134)
+#ifndef ARDUINOJSON_USE_DOUBLE
+#define ARDUINOJSON_USE_DOUBLE 0
+#endif
+
+// store using a long because it usually match the size of a float.
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#define ARDUINOJSON_USE_LONG_LONG 0
+#endif
+#ifndef ARDUINOJSON_USE_INT64
+#define ARDUINOJSON_USE_INT64 0
+#endif
+
+// arduino has its own implementation of String to replace std::string
+#ifndef ARDUINOJSON_USE_ARDUINO_STRING
+#define ARDUINOJSON_USE_ARDUINO_STRING 1
+#endif
+
+// arduino doesn't support STL stream
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#define ARDUINOJSON_ENABLE_STD_STREAM 0
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+#ifdef ARDUINO_ARCH_AVR
+// alignment isn't needed for 8-bit AVR
+#define ARDUINOJSON_ENABLE_ALIGNMENT 0
+#else
+// but must processor needs pointer to be align on word size
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+#endif
+
+#else  // assume this is a computer
+
+// on a computer we have plenty of memory so we can use doubles
+#ifndef ARDUINOJSON_USE_DOUBLE
+#define ARDUINOJSON_USE_DOUBLE 1
+#endif
+
+// use long long when available
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
+#define ARDUINOJSON_USE_LONG_LONG 1
+#else
+#define ARDUINOJSON_USE_LONG_LONG 0
+#endif
+#endif
+
+// use _int64 on old versions of Visual Studio
+#ifndef ARDUINOJSON_USE_INT64
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#define ARDUINOJSON_USE_INT64 1
+#else
+#define ARDUINOJSON_USE_INT64 0
+#endif
+#endif
+
+// on a computer, we can use std::string
+#ifndef ARDUINOJSON_USE_ARDUINO_STRING
+#define ARDUINOJSON_USE_ARDUINO_STRING 0
+#endif
+
+// on a computer, we can assume that the STL is there
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#define ARDUINOJSON_ENABLE_STD_STREAM 1
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+// even if not required, most cpu's are faster with aligned pointers
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+
+#endif
+
+#if ARDUINOJSON_USE_LONG_LONG && ARDUINOJSON_USE_INT64
+#error ARDUINOJSON_USE_LONG_LONG and ARDUINOJSON_USE_INT64 cannot be set together
+#endif

include/ArduinoJson/DynamicJsonBuffer.hpp

@@ -0,0 +1,18 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Internals/BlockJsonBuffer.hpp"
+
+namespace ArduinoJson {
+// Implements a JsonBuffer with dynamic memory allocation.
+// You are strongly encouraged to consider using StaticJsonBuffer which is much
+// more suitable for embedded systems.
+typedef Internals::BlockJsonBuffer<Internals::DefaultAllocator>
+    DynamicJsonBuffer;
+}

include/ArduinoJson/Internals/BlockJsonBuffer.hpp

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

include/ArduinoJson/Internals/Comments.hpp

@@ -0,0 +1,14 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+const char *skipSpacesAndComments(const char *ptr);
+}
+}

include/ArduinoJson/Internals/DummyPrint.hpp

@@ -0,0 +1,21 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A dummy Print implementation used in JsonPrintable::measureLength()
+class DummyPrint : public Print {
+ public:
+  virtual size_t write(uint8_t) { return 1; }
+};
+}
+}

include/ArduinoJson/Internals/DynamicStringBuilder.hpp

@@ -0,0 +1,33 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Print.hpp"
+#include "../String.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A Print implementation that allows to write in a String
+class DynamicStringBuilder : public Print {
+ public:
+  DynamicStringBuilder(String &str) : _str(str) {}
+
+  virtual size_t write(uint8_t c) {
+    // Need to cast to char, otherwise String will print a number (issue #120)
+    _str += static_cast<char>(c);
+    return 1;
+  }
+
+ private:
+  DynamicStringBuilder &operator=(const DynamicStringBuilder &);
+
+  String &_str;
+};
+}
+}

include/ArduinoJson/Internals/Encoding.hpp

@@ -0,0 +1,40 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+class Encoding {
+ public:
+  // Optimized for code size on a 8-bit AVR
+  static char escapeChar(char c) {
+    const char *p = _escapeTable;
+    while (p[0] && p[1] != c) {
+      p += 2;
+    }
+    return p[0];
+  }
+
+  // Optimized for code size on a 8-bit AVR
+  static char unescapeChar(char c) {
+    const char *p = _escapeTable + 4;
+    for (;;) {
+      if (p[0] == '\0') return c;
+      if (p[0] == c) return p[1];
+      p += 2;
+    }
+  }
+
+ private:
+  static const char _escapeTable[];
+};
+}
+}

include/ArduinoJson/Internals/ForceInline.hpp

@@ -0,0 +1,14 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#ifdef _MSC_VER
+#define FORCE_INLINE __forceinline
+#else
+#define FORCE_INLINE __attribute__((always_inline))
+#endif

include/ArduinoJson/Internals/IndentedPrint.hpp

@@ -1,12 +1,13 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"
 
 namespace ArduinoJson {
 namespace Internals {

include/ArduinoJson/Internals/JsonBufferAllocated.hpp

@@ -0,0 +1,25 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+class JsonBufferAllocated {
+ public:
+  void *operator new(size_t n, JsonBuffer *jsonBuffer) throw() {
+    if (!jsonBuffer) return NULL;
+    return jsonBuffer->alloc(n);
+  }
+
+  void operator delete(void *, JsonBuffer *) throw() {}
+};
+}
+}

include/ArduinoJson/Internals/JsonFloat.hpp

@@ -0,0 +1,21 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+#if ARDUINOJSON_USE_DOUBLE
+typedef double JsonFloat;
+#else
+typedef float JsonFloat;
+#endif
+}
+}

include/ArduinoJson/Internals/JsonInteger.hpp

@@ -0,0 +1,26 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+#if ARDUINOJSON_USE_LONG_LONG
+typedef long long JsonInteger;
+typedef unsigned long long JsonUInt;
+#elif ARDUINOJSON_USE_INT64
+typedef __int64 JsonInteger;
+typedef unsigned _int64 JsonUInt;
+#else
+typedef long JsonInteger;
+typedef unsigned long JsonUInt;
+#endif
+}
+}

include/ArduinoJson/Internals/JsonParser.hpp

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
@@ -18,24 +19,34 @@ namespace Internals {
 class JsonParser {
  public:
   JsonParser(JsonBuffer *buffer, char *json, uint8_t nestingLimit)
-      : _buffer(buffer), _ptr(json), _nestingLimit(nestingLimit) {}
+      : _buffer(buffer),
+        _readPtr(json ? json : ""),
+        _writePtr(json),
+        _nestingLimit(nestingLimit) {}
 
   JsonArray &parseArray();
   JsonObject &parseObject();
 
+  JsonVariant parseVariant() {
+    JsonVariant result;
+    parseAnythingTo(&result);
+    return result;
+  }
+
  private:
   bool skip(char charToSkip);
-  bool skip(const char *wordToSkip);
-  void skipSpaces();
 
-  void parseAnythingTo(JsonVariant &destination);
-  inline void parseBooleanTo(JsonVariant &destination);
-  inline void parseNullTo(JsonVariant &destination);
-  inline void parseNumberTo(JsonVariant &destination);
-  inline const char *parseString();
+  const char *parseString();
+  bool parseAnythingTo(JsonVariant *destination);
+  FORCE_INLINE bool parseAnythingToUnsafe(JsonVariant *destination);
+
+  inline bool parseArrayTo(JsonVariant *destination);
+  inline bool parseObjectTo(JsonVariant *destination);
+  inline bool parseStringTo(JsonVariant *destination);
 
   JsonBuffer *_buffer;
-  char *_ptr;
+  const char *_readPtr;
+  char *_writePtr;
   uint8_t _nestingLimit;
 };
 }

include/ArduinoJson/Internals/JsonPrintable.hpp

@@ -1,15 +1,23 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
+#include "../Configuration.hpp"
+#include "DummyPrint.hpp"
 #include "IndentedPrint.hpp"
 #include "JsonWriter.hpp"
 #include "Prettyfier.hpp"
-#include "StringBuilder.hpp"
+#include "StaticStringBuilder.hpp"
+#include "DynamicStringBuilder.hpp"
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#include "StreamPrintAdapter.hpp"
+#endif
 
 namespace ArduinoJson {
 namespace Internals {
@@ -27,8 +35,21 @@ class JsonPrintable {
     return writer.bytesWritten();
   }
 
+#if ARDUINOJSON_ENABLE_STD_STREAM
+  std::ostream &printTo(std::ostream &os) const {
+    StreamPrintAdapter adapter(os);
+    printTo(adapter);
+    return os;
+  }
+#endif
+
   size_t printTo(char *buffer, size_t bufferSize) const {
-    StringBuilder sb(buffer, bufferSize);
+    StaticStringBuilder sb(buffer, bufferSize);
+    return printTo(sb);
+  }
+
+  size_t printTo(String &str) const {
+    DynamicStringBuilder sb(str);
     return printTo(sb);
   }
 
@@ -38,7 +59,7 @@ class JsonPrintable {
   }
 
   size_t prettyPrintTo(char *buffer, size_t bufferSize) const {
-    StringBuilder sb(buffer, bufferSize);
+    StaticStringBuilder sb(buffer, bufferSize);
     return prettyPrintTo(sb);
   }
 
@@ -47,8 +68,30 @@ class JsonPrintable {
     return prettyPrintTo(indentedPrint);
   }
 
+  size_t prettyPrintTo(String &str) const {
+    DynamicStringBuilder sb(str);
+    return prettyPrintTo(sb);
+  }
+
+  size_t measureLength() const {
+    DummyPrint dp;
+    return printTo(dp);
+  }
+
+  size_t measurePrettyLength() const {
+    DummyPrint dp;
+    return prettyPrintTo(dp);
+  }
+
  private:
   const T &downcast() const { return *static_cast<const T *>(this); }
 };
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+template <typename T>
+inline std::ostream &operator<<(std::ostream &os, const JsonPrintable<T> &v) {
+  return v.printTo(os);
+}
+#endif
 }
 }

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -1,11 +1,15 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
+#include "JsonFloat.hpp"
+#include "JsonInteger.hpp"
+
 namespace ArduinoJson {
 
 // Forward declarations
@@ -13,13 +17,11 @@ class JsonArray;
 class JsonObject;
 
 namespace Internals {
-
 // A union that defines the actual content of a JsonVariant.
 // The enum JsonVariantType determines which member is in use.
 union JsonVariantContent {
-  bool asBoolean;
-  double asDouble;       // asDouble is also used for float
-  long asLong;           // asLong is also used for char, short and int
+  JsonFloat asFloat;     // used for double and float
+  JsonUInt asInteger;    // used for bool, char, short, int and longs
   const char* asString;  // asString can be null
   JsonArray* asArray;    // asArray cannot be null
   JsonObject* asObject;  // asObject cannot be null

include/ArduinoJson/Internals/JsonVariantType.hpp

@@ -1,32 +1,38 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
 namespace ArduinoJson {
+class JsonArray;
+class JsonObject;
+
 namespace Internals {
 
 // Enumerated type to know the current type of a JsonVariant.
 // The value determines which member of JsonVariantContent is used.
 enum JsonVariantType {
-  JSON_INVALID,    // a special state for JsonVariant::invalid()
-  JSON_UNDEFINED,  // the JsonVariant has not been initialized
-  JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
-  JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject
-  JSON_BOOLEAN,    // the JsonVariant stores a bool
-  JSON_STRING,     // the JsonVariant stores a const char*
-  JSON_LONG,       // the JsonVariant stores a long
+  JSON_UNDEFINED,         // JsonVariant has not been initialized
+  JSON_UNPARSED,          // JsonVariant contains an unparsed string
+  JSON_STRING,            // JsonVariant stores a const char*
+  JSON_BOOLEAN,           // JsonVariant stores a bool
+  JSON_POSITIVE_INTEGER,  // JsonVariant stores an unsigned long
+  JSON_NEGATIVE_INTEGER,  // JsonVariant stores an unsigned long that must be
+                          // negated
+  JSON_ARRAY,             // JsonVariant stores a pointer to a JsonArray
+  JSON_OBJECT,            // JsonVariant stores a pointer to a JsonObject
 
-  // The following values are reserved for double values
+  // The following values are reserved for float values
   // Multiple values are used for double, depending on the number of decimal
   // digits that must be printed in the JSON output.
   // This little trick allow to save one extra member in JsonVariant
-  JSON_DOUBLE_0_DECIMALS
-  // JSON_DOUBLE_1_DECIMAL
-  // JSON_DOUBLE_2_DECIMALS
+  JSON_FLOAT_0_DECIMALS
+  // JSON_FLOAT_1_DECIMAL
+  // JSON_FLOAT_2_DECIMALS
   // ...
 };
 }

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -1,13 +1,20 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
-#include "QuotedString.hpp"
+#include "../Polyfills/isInfinity.hpp"
+#include "../Polyfills/isNaN.hpp"
+#include "../Polyfills/normalize.hpp"
+#include "../Print.hpp"
+#include "Encoding.hpp"
+#include "ForceInline.hpp"
+#include "JsonFloat.hpp"
+#include "JsonInteger.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -26,34 +33,109 @@ class JsonWriter {
   // Returns the number of bytes sent to the Print implementation.
   // This is very handy for implementations of printTo() that must return the
   // number of bytes written.
-  size_t bytesWritten() { return _length; }
+  size_t bytesWritten() const { return _length; }
 
-  void beginArray() { write('['); }
-  void endArray() { write(']'); }
+  void beginArray() { writeRaw('['); }
+  void endArray() { writeRaw(']'); }
 
-  void beginObject() { write('{'); }
-  void endObject() { write('}'); }
+  void beginObject() { writeRaw('{'); }
+  void endObject() { writeRaw('}'); }
 
-  void writeColon() { write(':'); }
-  void writeComma() { write(','); }
+  void writeColon() { writeRaw(':'); }
+  void writeComma() { writeRaw(','); }
+
+  void writeBoolean(bool value) { writeRaw(value ? "true" : "false"); }
 
   void writeString(const char *value) {
-    _length += QuotedString::printTo(value, _sink);
+    if (!value) {
+      writeRaw("null");
+    } else {
+      writeRaw('\"');
+      while (*value) writeChar(*value++);
+      writeRaw('\"');
+    }
   }
 
-  void writeLong(long value) { _length += _sink.print(value); }
+  void writeChar(char c) {
+    char specialChar = Encoding::escapeChar(c);
+    if (specialChar) {
+      writeRaw('\\');
+      writeRaw(specialChar);
+    } else {
+      writeRaw(c);
+    }
+  }
 
-  void writeBoolean(bool value) {
-    _length += _sink.print(value ? "true" : "false");
+  void writeFloat(JsonFloat value, int digits = 2) {
+    if (Polyfills::isNaN(value)) return writeRaw("NaN");
+
+    if (value < 0.0) {
+      writeRaw('-');
+      value = -value;
+    }
+
+    if (Polyfills::isInfinity(value)) return writeRaw("Infinity");
+
+    short powersOf10;
+    if (value > 1000 || value < 0.001) {
+      powersOf10 = Polyfills::normalize(value);
+    } else {
+      powersOf10 = 0;
+    }
+
+    // Round correctly so that print(1.999, 2) prints as "2.00"
+    JsonFloat rounding = 0.5;
+    for (uint8_t i = 0; i < digits; ++i) rounding /= 10.0;
+
+    value += rounding;
+
+    // Extract the integer part of the value and print it
+    JsonUInt int_part = static_cast<JsonUInt>(value);
+    JsonFloat remainder = value - static_cast<JsonFloat>(int_part);
+    writeInteger(int_part);
+
+    // Print the decimal point, but only if there are digits beyond
+    if (digits > 0) {
+      writeRaw('.');
+    }
+
+    // Extract digits from the remainder one at a time
+    while (digits-- > 0) {
+      remainder *= 10.0;
+      JsonUInt toPrint = JsonUInt(remainder);
+      writeInteger(JsonUInt(remainder));
+      remainder -= static_cast<JsonFloat>(toPrint);
+    }
+
+    if (powersOf10 < 0) {
+      writeRaw("e-");
+      writeInteger(-powersOf10);
+    }
+
+    if (powersOf10 > 0) {
+      writeRaw('e');
+      writeInteger(powersOf10);
+    }
   }
-  void writeDouble(double value, uint8_t decimals) {
-    _length += _sink.print(value, decimals);
+
+  void writeInteger(JsonUInt value) {
+    char buffer[22];
+
+    uint8_t i = 0;
+    do {
+      buffer[i++] = static_cast<char>(value % 10 + '0');
+      value /= 10;
+    } while (value);
+
+    while (i > 0) {
+      writeRaw(buffer[--i]);
+    }
   }
 
+  void writeRaw(const char *s) { _length += _sink.print(s); }
+  void writeRaw(char c) { _length += _sink.write(c); }
+
  protected:
-  void write(char c) { _length += _sink.write(c); }
-  void write(const char *s) { _length += _sink.print(s); }
-
   Print &_sink;
   size_t _length;
 

include/ArduinoJson/Internals/List.hpp

@@ -1,15 +1,15 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
 #include "../JsonBuffer.hpp"
 #include "ListConstIterator.hpp"
 #include "ListIterator.hpp"
-#include "PlacementNew.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -40,7 +40,7 @@ class List {
 
   // Returns the numbers of elements in the list.
   // For a JsonObject, it would return the number of key-value pairs
-  int size() const;
+  size_t size() const;
 
   iterator begin() { return iterator(_firstNode); }
   iterator end() { return iterator(NULL); }
@@ -49,22 +49,7 @@ class List {
   const_iterator end() const { return const_iterator(NULL); }
 
  protected:
-  node_type *createNode() {
-    if (!_buffer) return NULL;
-    void *ptr = _buffer->alloc(sizeof(node_type));
-    return ptr ? new (ptr) node_type() : NULL;
-  }
-
-  void addNode(node_type *nodeToAdd) {
-    if (_firstNode) {
-      node_type *lastNode = _firstNode;
-      while (lastNode->next) lastNode = lastNode->next;
-      lastNode->next = nodeToAdd;
-    } else {
-      _firstNode = nodeToAdd;
-    }
-  }
-
+  node_type *addNewNode();
   void removeNode(node_type *nodeToRemove);
 
   JsonBuffer *_buffer;

include/ArduinoJson/Internals/ListConstIterator.hpp

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 

include/ArduinoJson/Internals/ListIterator.hpp

@@ -1,12 +1,14 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
 #include "ListNode.hpp"
+#include "ListConstIterator.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -33,6 +35,8 @@ class ListIterator {
     return *this;
   }
 
+  operator ListConstIterator<T>() const { return ListConstIterator<T>(_node); }
+
  private:
   ListNode<T> *_node;
 };

include/ArduinoJson/Internals/ListNode.hpp

@@ -1,23 +1,26 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
 #include <stddef.h>  // for NULL
 
+#include "JsonBufferAllocated.hpp"
+
 namespace ArduinoJson {
 namespace Internals {
 
 // A node for a singly-linked list.
 // Used by List<T> and its iterators.
 template <typename T>
-struct ListNode {
+struct ListNode : public Internals::JsonBufferAllocated {
   ListNode() : next(NULL) {}
 
-  ListNode<T>* next;
+  ListNode<T> *next;
   T content;
 };
 }

include/ArduinoJson/Internals/Parse.hpp

@@ -0,0 +1,66 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include <stdlib.h>
+
+namespace ArduinoJson {
+namespace Internals {
+template <typename TFloat>
+TFloat parse(const char *);
+
+template <>
+inline float parse<float>(const char *s) {
+  return static_cast<float>(strtod(s, NULL));
+}
+
+template <>
+inline double parse<double>(const char *s) {
+  return strtod(s, NULL);
+}
+
+template <>
+inline long parse<long>(const char *s) {
+  return strtol(s, NULL, 10);
+}
+
+template <>
+inline unsigned long parse<unsigned long>(const char *s) {
+  return strtoul(s, NULL, 10);
+}
+
+template <>
+inline int parse<int>(const char *s) {
+  return atoi(s);
+}
+
+#if ARDUINOJSON_USE_LONG_LONG
+template <>
+inline long long parse<long long>(const char *s) {
+  return strtoll(s, NULL, 10);
+}
+
+template <>
+inline unsigned long long parse<unsigned long long>(const char *s) {
+  return strtoull(s, NULL, 10);
+}
+#endif
+
+#if ARDUINOJSON_USE_INT64
+template <>
+inline __int64 parse<__int64>(const char *s) {
+  return _strtoi64(s, NULL, 10);
+}
+
+template <>
+inline unsigned __int64 parse<unsigned __int64>(const char *s) {
+  return _strtoui64(s, NULL, 10);
+}
+#endif
+}
+}

include/ArduinoJson/Internals/PlacementNew.hpp

@@ -1,19 +0,0 @@
-// Copyright Benoit Blanchon 2014
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#pragma once
-
-#ifdef ARDUINO
-
-// Declares the placement new as in <new>.
-// This is required for Arduino IDE because it doesn't include the <new> header.
-inline void *operator new(size_t, void *p) throw() { return p; }
-
-#else
-
-#include <new>
-
-#endif

include/ArduinoJson/Internals/Prettyfier.hpp

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
@@ -31,7 +32,7 @@ class Prettyfier : public Print {
 
   size_t handleBlockClose(uint8_t);
   size_t handleBlockOpen(uint8_t);
-  size_t handleColumn();
+  size_t handleColon();
   size_t handleComma();
   size_t handleQuoteOpen();
   size_t handleNormalChar(uint8_t);

include/ArduinoJson/Internals/QuotedString.hpp

@@ -1,29 +0,0 @@
-// Copyright Benoit Blanchon 2014
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#pragma once
-
-#include "../Arduino/Print.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-
-// An helper class to print and extract doubly-quoted strings
-class QuotedString {
- public:
-  // Writes a doubly-quote string to a Print implementation.
-  // It adds the double quotes (") at the beginning and the end of the string.
-  // It escapes the special characters as required by the JSON specifications.
-  static size_t printTo(const char *, Print &);
-
-  // Reads a doubly-quoted string from a buffer.
-  // It removes the double quotes (").
-  // It unescapes the special character as required by the JSON specification,
-  // with the exception of the Unicode characters (\u0000).
-  static char *extractFrom(char *input, char **end);
-};
-}
-}

include/ArduinoJson/Internals/ReferenceType.hpp

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 

include/ArduinoJson/Internals/StaticStringBuilder.hpp

@@ -1,20 +1,21 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
 
 // A Print implementation that allows to write in a char[]
-class StringBuilder : public Print {
+class StaticStringBuilder : public Print {
  public:
-  StringBuilder(char *buf, int size)
+  StaticStringBuilder(char *buf, size_t size)
       : buffer(buf), capacity(size - 1), length(0) {
     buffer[0] = '\0';
   }
@@ -23,8 +24,8 @@ class StringBuilder : public Print {
 
  private:
   char *buffer;
-  int capacity;
-  int length;
+  size_t capacity;
+  size_t length;
 };
 }
 }

include/ArduinoJson/Internals/StreamPrintAdapter.hpp

@@ -0,0 +1,39 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+
+#include "../Print.hpp"
+
+#include <ostream>
+
+namespace ArduinoJson {
+namespace Internals {
+
+class StreamPrintAdapter : public Print {
+ public:
+  explicit StreamPrintAdapter(std::ostream& os) : _os(os) {}
+
+  virtual size_t write(uint8_t c) {
+    _os << static_cast<char>(c);
+    return 1;
+  }
+
+ private:
+  // cannot be assigned
+  StreamPrintAdapter& operator=(const StreamPrintAdapter&);
+
+  std::ostream& _os;
+};
+}
+}
+
+#endif  // ARDUINOJSON_ENABLE_STD_STREAM

include/ArduinoJson/JsonArray.hpp

@@ -1,15 +1,21 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
+#include "Internals/JsonBufferAllocated.hpp"
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonVariant.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsReference.hpp"
+#include "TypeTraits/IsSame.hpp"
 
 // Returns the size (in bytes) of an array with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@@ -21,6 +27,7 @@ namespace ArduinoJson {
 // Forward declarations
 class JsonObject;
 class JsonBuffer;
+class JsonArraySubscript;
 
 // An array of JsonVariant.
 //
@@ -30,36 +37,110 @@ class JsonBuffer;
 // It can also be deserialized from a JSON string via JsonBuffer::parseArray().
 class JsonArray : public Internals::JsonPrintable<JsonArray>,
                   public Internals::ReferenceType,
-                  public Internals::List<JsonVariant> {
-  // JsonBuffer is a friend because it needs to call the private constructor.
-  friend class JsonBuffer;
-
+                  public Internals::List<JsonVariant>,
+                  public Internals::JsonBufferAllocated {
  public:
-  // Returns the JsonVariant at the specified index (synonym for operator[])
-  JsonVariant &at(int index) const;
+  // A meta-function that returns true if type T can be used in
+  // JsonArray::set()
+  template <typename T>
+  struct CanSet {
+    static const bool value = JsonVariant::IsConstructibleFrom<T>::value ||
+                              TypeTraits::IsSame<T, String &>::value ||
+                              TypeTraits::IsSame<T, const String &>::value;
+  };
 
-  // Returns the JsonVariant at the specified index (synonym for at())
-  JsonVariant &operator[](int index) const { return at(index); }
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  // You should not call this constructor directly.
+  // Instead, use JsonBuffer::createArray() or JsonBuffer::parseArray().
+  explicit JsonArray(JsonBuffer *buffer)
+      : Internals::List<JsonVariant>(buffer) {}
 
-  // Adds an uninitialized JsonVariant at the end of the array.
-  // Return a reference or JsonVariant::invalid() if allocation fails.
-  JsonVariant &add();
+  // Gets the value at the specified index
+  FORCE_INLINE JsonVariant operator[](size_t index) const;
+
+  // Gets or sets the value at specified index
+  FORCE_INLINE JsonArraySubscript operator[](size_t index);
 
   // Adds the specified value at the end of the array.
+  //
+  // bool add(bool);
+  // bool add(char);
+  // bool add(long);
+  // bool add(int);
+  // bool add(short);
+  // bool add(float value);
+  // bool add(double value);
+  // bool add(const char*);
   template <typename T>
-  void add(T value) {
-    add().set(value);
+  FORCE_INLINE bool add(
+      T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+    return addNode<T>(value);
+  }
+  // bool add(const String&)
+  // bool add(const JsonVariant&);
+  // bool add(JsonArray&);
+  // bool add(JsonObject&);
+  template <typename T>
+  FORCE_INLINE bool add(
+      const T &value,
+      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+    return addNode<T &>(const_cast<T &>(value));
+  }
+  // bool add(float value, uint8_t decimals);
+  // bool add(double value, uint8_t decimals);
+  template <typename T>
+  FORCE_INLINE bool add(
+      T value, uint8_t decimals,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
+          * = 0) {
+    return addNode<JsonVariant>(JsonVariant(value, decimals));
   }
 
-  // Adds the specified double value at the end of the array.
-  // The value will be printed with the specified number of decimal digits.
-  void add(double value, uint8_t decimals) { add().set(value, decimals); }
+  // Sets the value at specified index.
+  //
+  // bool set(size_t index, bool value);
+  // bool set(size_t index, long value);
+  // bool set(size_t index, int value);
+  // bool set(size_t index, short value);
+  template <typename T>
+  FORCE_INLINE bool set(
+      size_t index, T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+    return setNodeAt<T>(index, value);
+  }
+  // bool set(size_t index, const String&)
+  // bool set(size_t index, const JsonVariant&);
+  // bool set(size_t index, JsonArray&);
+  // bool set(size_t index, JsonObject&);
+  template <typename T>
+  FORCE_INLINE bool set(
+      size_t index, const T &value,
+      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+    return setNodeAt<T &>(index, const_cast<T &>(value));
+  }
+  // bool set(size_t index, float value, uint8_t decimals = 2);
+  // bool set(size_t index, double value, uint8_t decimals = 2);
+  template <typename T>
+  FORCE_INLINE bool set(
+      size_t index, T value, uint8_t decimals,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
+          * = 0) {
+    return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
+  }
 
-  // Adds a reference to the specified JsonArray at the end of the array.
-  void add(JsonArray &array) { add().set(array); }
+  // Gets the value at the specified index.
+  FORCE_INLINE JsonVariant get(size_t index) const;
 
-  // Adds a reference to the specified JsonObject at the end of the array.
-  void add(JsonObject &obejct) { add().set(obejct); }
+  // Gets the value at the specified index.
+  template <typename T>
+  FORCE_INLINE T get(size_t index) const;
+
+  // Check the type of the value at specified index.
+  template <typename T>
+  FORCE_INLINE bool is(size_t index) const;
 
   // Creates a JsonArray and adds a reference at the end of the array.
   // It's a shortcut for JsonBuffer::createArray() and JsonArray::add()
@@ -69,6 +150,9 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   // It's a shortcut for JsonBuffer::createObject() and JsonArray::add()
   JsonObject &createNestedObject();
 
+  // Removes element at specified index.
+  void removeAt(size_t index);
+
   // Returns a reference an invalid JsonArray.
   // This object is meant to replace a NULL pointer.
   // This is used when memory allocation or JSON parsing fail.
@@ -77,12 +161,74 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   // Serialize the array to the specified JsonWriter.
   void writeTo(Internals::JsonWriter &writer) const;
 
+  // Imports a 1D array
+  template <typename T, size_t N>
+  bool copyFrom(T(&array)[N]) {
+    return copyFrom(array, N);
+  }
+
+  // Imports a 1D array
+  template <typename T>
+  bool copyFrom(T *array, size_t len) {
+    bool ok = true;
+    for (size_t i = 0; i < len; i++) {
+      ok &= add(array[i]);
+    }
+    return ok;
+  }
+
+  // Imports a 2D array
+  template <typename T, size_t N1, size_t N2>
+  bool copyFrom(T(&array)[N1][N2]) {
+    bool ok = true;
+    for (size_t i = 0; i < N1; i++) {
+      JsonArray &nestedArray = createNestedArray();
+      for (size_t j = 0; j < N2; j++) {
+        ok &= nestedArray.add(array[i][j]);
+      }
+    }
+    return ok;
+  }
+
+  // Exports a 1D array
+  template <typename T, size_t N>
+  size_t copyTo(T(&array)[N]) const {
+    return copyTo(array, N);
+  }
+
+  // Exports a 1D array
+  template <typename T>
+  size_t copyTo(T *array, size_t len) const {
+    size_t i = 0;
+    for (const_iterator it = begin(); it != end() && i < len; ++it)
+      array[i++] = *it;
+    return i;
+  }
+
+  // Exports a 2D array
+  template <typename T, size_t N1, size_t N2>
+  void copyTo(T(&array)[N1][N2]) const {
+    size_t i = 0;
+    for (const_iterator it = begin(); it != end() && i < N1; ++it) {
+      it->asArray().copyTo(array[i++]);
+    }
+  }
+
  private:
-  // Create an empty JsonArray attached to the specified JsonBuffer.
-  explicit JsonArray(JsonBuffer *buffer)
-      : Internals::List<JsonVariant>(buffer) {}
+  node_type *getNodeAt(size_t index) const;
+
+  template <typename TValue>
+  bool setNodeAt(size_t index, TValue value);
+
+  template <typename TValue>
+  bool addNode(TValue);
+
+  template <typename T>
+  FORCE_INLINE bool setNodeValue(node_type *, T value);
 
   // The instance returned by JsonArray::invalid()
   static JsonArray _invalid;
 };
 }
+
+#include "JsonArray.ipp"

include/ArduinoJson/JsonArray.ipp

@@ -0,0 +1,101 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "JsonArray.hpp"
+#include "JsonObject.hpp"
+#include "JsonArraySubscript.hpp"
+
+namespace ArduinoJson {
+
+inline JsonArraySubscript JsonArray::operator[](size_t index) {
+  return JsonArraySubscript(*this, index);
+}
+
+inline JsonVariant JsonArray::operator[](size_t index) const {
+  return get(index);
+}
+
+template <typename TValue>
+inline bool JsonArray::addNode(TValue value) {
+  node_type *node = addNewNode();
+  return node != NULL && setNodeValue<TValue>(node, value);
+}
+
+template <typename TValue>
+inline bool JsonArray::setNodeAt(size_t index, TValue value) {
+  node_type *node = getNodeAt(index);
+  return node != NULL && setNodeValue<TValue>(node, value);
+}
+
+template <typename TValue>
+inline bool JsonArray::setNodeValue(node_type *node, TValue value) {
+  node->content = value;
+  return true;
+}
+
+template <>
+inline bool JsonArray::setNodeValue(node_type *node, String &value) {
+  const char *copy = _buffer->strdup(value);
+  if (!copy) return false;
+  node->content = copy;
+  return true;
+}
+
+inline JsonVariant JsonArray::get(size_t index) const {
+  node_type *node = getNodeAt(index);
+  return node ? node->content : JsonVariant();
+}
+
+template <typename T>
+inline T JsonArray::get(size_t index) const {
+  node_type *node = getNodeAt(index);
+  return node ? node->content.as<T>() : JsonVariant::defaultValue<T>();
+}
+
+template <typename T>
+inline bool JsonArray::is(size_t index) const {
+  node_type *node = getNodeAt(index);
+  return node ? node->content.is<T>() : false;
+}
+
+template <typename TImplem>
+inline const JsonArraySubscript JsonVariantBase<TImplem>::operator[](
+    int index) const {
+  return asArray()[index];
+}
+
+template <>
+inline JsonArray &JsonVariant::defaultValue<JsonArray &>() {
+  return JsonArray::invalid();
+}
+
+template <>
+inline JsonArray const &JsonVariant::defaultValue<JsonArray const &>() {
+  return JsonArray::invalid();
+}
+
+inline JsonArray &JsonVariant::asArray() const {
+  if (_type == Internals::JSON_ARRAY) return *_content.asArray;
+  return JsonArray::invalid();
+}
+
+inline JsonArray &JsonArray::createNestedArray() {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  add(array);
+  return array;
+}
+
+inline JsonArray &JsonObject::createNestedArray(JsonObjectKey key) {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  setNodeAt<const JsonVariant &>(key, array);
+  return array;
+}
+}

include/ArduinoJson/JsonArraySubscript.hpp

@@ -0,0 +1,84 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Configuration.hpp"
+#include "JsonVariantBase.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+
+namespace ArduinoJson {
+class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
+ public:
+  FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
+      : _array(array), _index(index) {}
+
+  JsonArraySubscript& operator=(const JsonArraySubscript& src) {
+    _array.set<const JsonVariant&>(_index, src);
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonArray::CanSet<T&>::value,
+                                JsonArraySubscript>::type&
+  operator=(const T& src) {
+    _array.set<T&>(_index, const_cast<T&>(src));
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonArray::CanSet<T>::value,
+                                JsonArraySubscript>::type&
+  operator=(T src) {
+    _array.set<T>(_index, src);
+    return *this;
+  }
+
+  FORCE_INLINE bool success() const { return _index < _array.size(); }
+
+  FORCE_INLINE operator JsonVariant() const { return _array.get(_index); }
+
+  template <typename T>
+  FORCE_INLINE T as() const {
+    return _array.get<T>(_index);
+  }
+
+  template <typename T>
+  FORCE_INLINE bool is() const {
+    return _array.is<T>(_index);
+  }
+
+  void writeTo(Internals::JsonWriter& writer) const {
+    _array.get(_index).writeTo(writer);
+  }
+
+  template <typename TValue>
+  void set(TValue value) {
+    _array.set(_index, value);
+  }
+
+ private:
+  JsonArray& _array;
+  const size_t _index;
+};
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream& operator<<(std::ostream& os,
+                                const JsonArraySubscript& source) {
+  return source.printTo(os);
+}
+#endif
+
+}  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

include/ArduinoJson/JsonBuffer.hpp

@@ -1,13 +1,28 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
 #include <stddef.h>  // for size_t
 #include <stdint.h>  // for uint8_t
+#include <string.h>
+
+#include "JsonVariant.hpp"
+#include "String.hpp"
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic push
+#endif
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
 
 namespace ArduinoJson {
 class JsonArray;
@@ -49,6 +64,17 @@ class JsonBuffer {
   // allocation fails.
   JsonArray &parseArray(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
 
+  // Same with a const char*.
+  // With this overload, the JsonBuffer will make a copy of the string
+  JsonArray &parseArray(const char *json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parseArray(strdup(json), nesting);
+  }
+
+  // Same as above with a String class
+  JsonArray &parseArray(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parseArray(json.c_str(), nesting);
+  }
+
   // Allocates and populate a JsonObject from a JSON string.
   //
   // The First argument is a pointer to the JSON string, the memory must be
@@ -61,21 +87,77 @@ class JsonBuffer {
   // allocation fails.
   JsonObject &parseObject(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
 
+  // Same with a const char*.
+  // With this overload, the JsonBuffer will make a copy of the string
+  JsonObject &parseObject(const char *json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parseObject(strdup(json), nesting);
+  }
+
+  // Same as above with a String class
+  JsonObject &parseObject(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parseObject(json.c_str(), nesting);
+  }
+
+  // Generalized version of parseArray() and parseObject(), also works for
+  // integral types.
+  JsonVariant parse(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+
+  // Same with a const char*.
+  // With this overload, the JsonBuffer will make a copy of the string
+  JsonVariant parse(const char *json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parse(strdup(json), nesting);
+  }
+
+  // Same as above with a String class
+  JsonVariant parse(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parse(json.c_str(), nesting);
+  }
+
+  // Duplicate a string
+  char *strdup(const char *src) {
+    return src ? strdup(src, strlen(src)) : NULL;
+  }
+  char *strdup(const String &src) { return strdup(src.c_str(), src.length()); }
+
   // Allocates n bytes in the JsonBuffer.
   // Return a pointer to the allocated memory or NULL if allocation fails.
   virtual void *alloc(size_t size) = 0;
 
+ protected:
+  // Preserve aligment if nessary
+  static FORCE_INLINE size_t round_size_up(size_t bytes) {
+#if ARDUINOJSON_ENABLE_ALIGNMENT
+    const size_t x = sizeof(void *) - 1;
+    return (bytes + x) & ~x;
+#else
+    return bytes;
+#endif
+  }
+
+ private:
+  char *strdup(const char *, size_t);
+
   // Default value of nesting limit of parseArray() and parseObject().
   //
-  // The nesting limit is a contain on the level of nesting allowed in the JSON
+  // The nesting limit is a contain on the level of nesting allowed in the
+  // JSON
   // string.
   // If set to 0, only a flat array or objects can be parsed.
   // If set to 1, the object can contain nested arrays or objects but only 1
   // level deep.
   // And bigger values will allow more level of nesting.
   //
-  // The purpose of this feature is to prevent stack overflow that could lead to
+  // The purpose of this feature is to prevent stack overflow that could
+  // lead to
   // a security risk.
   static const uint8_t DEFAULT_LIMIT = 10;
 };
 }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic pop
+#endif
+#endif

include/ArduinoJson/JsonObject.hpp

@@ -1,15 +1,22 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
+#include "String.hpp"
+#include "Internals/JsonBufferAllocated.hpp"
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonPair.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsReference.hpp"
+#include "TypeTraits/IsSame.hpp"
 
 // Returns the size (in bytes) of an object with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@@ -30,76 +37,118 @@ class JsonBuffer;
 // It can also be deserialized from a JSON string via JsonBuffer::parseObject().
 class JsonObject : public Internals::JsonPrintable<JsonObject>,
                    public Internals::ReferenceType,
-                   public Internals::List<JsonPair> {
-  // JsonBuffer is a friend because it needs to call the private constructor.
-  friend class JsonBuffer;
-
+                   public Internals::List<JsonPair>,
+                   public Internals::JsonBufferAllocated {
  public:
-  typedef const char *key_type;
-  typedef JsonPair value_type;
-
-  // Gets the JsonVariant associated with the specified key.
-  // Returns a reference or JsonVariant::invalid() if not found.
-  JsonVariant &at(key_type key);
-
-  // Gets the JsonVariant associated with the specified key.
-  // Returns a constant reference or JsonVariant::invalid() if not found.
-  const JsonVariant &at(key_type key) const;
-
-  // Gets or create the JsonVariant associated with the specified key.
-  // Returns a reference or JsonVariant::invalid() if allocation failed.
-  JsonVariant &operator[](key_type key);
-
-  // Gets the JsonVariant associated with the specified key.
-  // Returns a constant reference or JsonVariant::invalid() if not found.
-  const JsonVariant &operator[](key_type key) const { return at(key); }
-
-  // Adds an uninitialized JsonVariant associated with the specified key.
-  // Return a reference or JsonVariant::invalid() if allocation fails.
-  JsonVariant &add(key_type key) { return (*this)[key]; }
-
-  // Adds the specified key with the specified value.
+  // A meta-function that returns true if type T can be used in
+  // JsonObject::set()
   template <typename T>
-  void add(key_type key, T value) {
-    add(key).set(value);
+  struct CanSet {
+    static const bool value = JsonVariant::IsConstructibleFrom<T>::value ||
+                              TypeTraits::IsSame<T, String&>::value ||
+                              TypeTraits::IsSame<T, const String&>::value;
+  };
+
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  // You should not use this constructor directly.
+  // Instead, use JsonBuffer::createObject() or JsonBuffer.parseObject().
+  FORCE_INLINE explicit JsonObject(JsonBuffer* buffer)
+      : Internals::List<JsonPair>(buffer) {}
+
+  // Gets or sets the value associated with the specified key.
+  FORCE_INLINE JsonObjectSubscript<const char*> operator[](const char* key);
+  FORCE_INLINE JsonObjectSubscript<const String&> operator[](const String& key);
+
+  // Gets the value associated with the specified key.
+  FORCE_INLINE JsonVariant operator[](JsonObjectKey key) const;
+
+  // Sets the specified key with the specified value.
+  // bool set(TKey key, bool value);
+  // bool set(TKey key, char value);
+  // bool set(TKey key, long value);
+  // bool set(TKey key, int value);
+  // bool set(TKey key, short value);
+  // bool set(TKey key, float value);
+  // bool set(TKey key, double value);
+  // bool set(TKey key, const char* value);
+  // bool set(TKey key, RawJson value);
+  template <typename T>
+  FORCE_INLINE bool set(
+      JsonObjectKey key, T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type* = 0) {
+    return setNodeAt<T>(key, value);
+  }
+  // bool set(Key, String&);
+  // bool set(Key, JsonArray&);
+  // bool set(Key, JsonObject&);
+  // bool set(Key, JsonVariant&);
+  template <typename T>
+  FORCE_INLINE bool set(
+      JsonObjectKey key, const T& value,
+      typename TypeTraits::EnableIf<CanSet<T&>::value>::type* = 0) {
+    return setNodeAt<T&>(key, const_cast<T&>(value));
+  }
+  // bool set(Key, float value, uint8_t decimals);
+  // bool set(Key, double value, uint8_t decimals);
+  template <typename TValue>
+  FORCE_INLINE bool set(
+      JsonObjectKey key, TValue value, uint8_t decimals,
+      typename TypeTraits::EnableIf<
+          TypeTraits::IsFloatingPoint<TValue>::value>::type* = 0) {
+    return setNodeAt<const JsonVariant&>(key, JsonVariant(value, decimals));
   }
 
-  // Adds the specified key with a reference to the specified JsonArray.
-  void add(key_type key, JsonArray &array) { add(key).set(array); }
+  // Gets the value associated with the specified key.
+  FORCE_INLINE JsonVariant get(JsonObjectKey) const;
 
-  // Adds the specified key with a reference to the specified JsonObject.
-  void add(key_type key, JsonObject &object) { add(key).set(object); }
+  // Gets the value associated with the specified key.
+  template <typename T>
+  FORCE_INLINE T get(JsonObjectKey) const;
+
+  // Checks the type of the value associated with the specified key.
+  template <typename T>
+  FORCE_INLINE bool is(JsonObjectKey) const;
 
   // Creates and adds a JsonArray.
   // This is a shortcut for JsonBuffer::createArray() and JsonObject::add().
-  JsonArray &createNestedArray(key_type key);
+  FORCE_INLINE JsonArray& createNestedArray(JsonObjectKey key);
 
   // Creates and adds a JsonObject.
   // This is a shortcut for JsonBuffer::createObject() and JsonObject::add().
-  JsonObject &createNestedObject(key_type key);
+  FORCE_INLINE JsonObject& createNestedObject(JsonObjectKey key);
 
   // Tells weither the specified key is present and associated with a value.
-  bool containsKey(key_type key) const { return at(key).success(); }
+  FORCE_INLINE bool containsKey(JsonObjectKey key) const;
 
   // Removes the specified key and the associated value.
-  void remove(key_type key);
+  void remove(JsonObjectKey key);
 
   // Returns a reference an invalid JsonObject.
   // This object is meant to replace a NULL pointer.
   // This is used when memory allocation or JSON parsing fail.
-  static JsonObject &invalid() { return _invalid; }
+  static JsonObject& invalid() { return _invalid; }
 
   // Serialize the object to the specified JsonWriter
-  void writeTo(Internals::JsonWriter &writer) const;
+  void writeTo(Internals::JsonWriter& writer) const;
 
  private:
-  // Create an empty JsonArray attached to the specified JsonBuffer.
-  explicit JsonObject(JsonBuffer *buffer) : Internals::List<JsonPair>(buffer) {}
-
   // Returns the list node that matches the specified key.
-  node_type *getNodeAt(key_type key) const;
+  node_type* getNodeAt(const char* key) const;
+
+  node_type* getOrCreateNodeAt(const char* key);
+
+  template <typename T>
+  FORCE_INLINE bool setNodeAt(JsonObjectKey key, T value);
+
+  FORCE_INLINE bool setNodeKey(node_type*, JsonObjectKey key);
+
+  template <typename T>
+  FORCE_INLINE bool setNodeValue(node_type*, T value);
 
   // The instance returned by JsonObject::invalid()
   static JsonObject _invalid;
 };
 }
+
+#include "JsonObject.ipp"

include/ArduinoJson/JsonObject.ipp

@@ -0,0 +1,133 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "JsonArray.hpp"
+#include "JsonObject.hpp"
+#include "JsonObjectSubscript.hpp"
+
+namespace ArduinoJson {
+
+inline JsonVariant JsonObject::get(JsonObjectKey key) const {
+  node_type *node = getNodeAt(key.c_str());
+  return node ? node->content.value : JsonVariant();
+}
+
+template <typename T>
+inline T JsonObject::get(JsonObjectKey key) const {
+  node_type *node = getNodeAt(key.c_str());
+  return node ? node->content.value.as<T>() : JsonVariant::defaultValue<T>();
+}
+
+template <typename T>
+inline bool JsonObject::is(JsonObjectKey key) const {
+  node_type *node = getNodeAt(key.c_str());
+  return node ? node->content.value.is<T>() : false;
+}
+
+inline JsonObjectSubscript<const char *> JsonObject::operator[](
+    const char *key) {
+  return JsonObjectSubscript<const char *>(*this, key);
+}
+
+inline JsonObjectSubscript<const String &> JsonObject::operator[](
+    const String &key) {
+  return JsonObjectSubscript<const String &>(*this, key);
+}
+
+inline JsonVariant JsonObject::operator[](JsonObjectKey key) const {
+  return get(key);
+}
+
+inline bool JsonObject::containsKey(JsonObjectKey key) const {
+  return getNodeAt(key.c_str()) != NULL;
+}
+
+inline void JsonObject::remove(JsonObjectKey key) {
+  removeNode(getNodeAt(key.c_str()));
+}
+
+template <typename T>
+inline bool JsonObject::setNodeAt(JsonObjectKey key, T value) {
+  node_type *node = getNodeAt(key.c_str());
+  if (!node) {
+    node = addNewNode();
+    if (!node || !setNodeKey(node, key)) return false;
+  }
+  return setNodeValue<T>(node, value);
+}
+
+inline bool JsonObject::setNodeKey(node_type *node, JsonObjectKey key) {
+  if (key.needs_copy()) {
+    node->content.key = _buffer->strdup(key.c_str());
+    if (node->content.key == NULL) return false;
+  } else {
+    node->content.key = key.c_str();
+  }
+  return true;
+}
+
+template <typename TValue>
+inline bool JsonObject::setNodeValue(node_type *node, TValue value) {
+  node->content.value = value;
+  return true;
+}
+
+template <>
+inline bool JsonObject::setNodeValue(node_type *node, String &value) {
+  node->content.value = _buffer->strdup(value);
+  return node->content.value;
+}
+
+template <>
+inline bool JsonObject::setNodeValue(node_type *node, const String &value) {
+  node->content.value = _buffer->strdup(value);
+  return node->content.value;
+}
+
+template <typename TImplem>
+inline const JsonObjectSubscript<const char *> JsonVariantBase<TImplem>::
+operator[](const char *key) const {
+  return asObject()[key];
+}
+
+template <typename TImplem>
+inline const JsonObjectSubscript<const String &> JsonVariantBase<TImplem>::
+operator[](const String &key) const {
+  return asObject()[key];
+}
+
+template <>
+inline JsonObject const &JsonVariant::defaultValue<JsonObject const &>() {
+  return JsonObject::invalid();
+}
+
+template <>
+inline JsonObject &JsonVariant::defaultValue<JsonObject &>() {
+  return JsonObject::invalid();
+}
+
+inline JsonObject &JsonVariant::asObject() const {
+  if (_type == Internals::JSON_OBJECT) return *_content.asObject;
+  return JsonObject::invalid();
+}
+
+inline JsonObject &JsonObject::createNestedObject(JsonObjectKey key) {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &array = _buffer->createObject();
+  setNodeAt<const JsonVariant &>(key, array);
+  return array;
+}
+
+inline JsonObject &JsonArray::createNestedObject() {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  add(object);
+  return object;
+}
+}

include/ArduinoJson/JsonObjectKey.hpp

@@ -0,0 +1,27 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "String.hpp"
+
+namespace ArduinoJson {
+
+// Represents a key in a JsonObject
+class JsonObjectKey {
+ public:
+  JsonObjectKey(const char* key) : _value(key), _needs_copy(false) {}
+  JsonObjectKey(const String& key) : _value(key.c_str()), _needs_copy(true) {}
+
+  const char* c_str() const { return _value; }
+  bool needs_copy() const { return _needs_copy; }
+
+ private:
+  const char* _value;
+  bool _needs_copy;
+};
+}

include/ArduinoJson/JsonObjectSubscript.hpp

@@ -0,0 +1,99 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Configuration.hpp"
+#include "JsonVariantBase.hpp"
+#include "TypeTraits/EnableIf.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+
+namespace ArduinoJson {
+
+template <typename TKey>
+class JsonObjectSubscript : public JsonVariantBase<JsonObjectSubscript<TKey> > {
+ public:
+  FORCE_INLINE JsonObjectSubscript(JsonObject& object, TKey key)
+      : _object(object), _key(key) {}
+
+  JsonObjectSubscript<TKey>& operator=(const JsonObjectSubscript<TKey>& src) {
+    _object.set<const JsonVariant&>(_key, src);
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonObject::CanSet<T&>::value,
+                                JsonObjectSubscript<TKey> >::type&
+  operator=(const T& src) {
+    _object.set<T&>(_key, const_cast<T&>(src));
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonObject::CanSet<T>::value,
+                                JsonObjectSubscript<TKey> >::type&
+  operator=(T src) {
+    _object.set<T>(_key, src);
+    return *this;
+  }
+
+  FORCE_INLINE bool success() const { return _object.containsKey(_key); }
+
+  FORCE_INLINE operator JsonVariant() const { return _object.get(_key); }
+
+  template <typename TValue>
+  FORCE_INLINE TValue as() const {
+    return _object.get<TValue>(_key);
+  }
+
+  template <typename TValue>
+  FORCE_INLINE bool is() const {
+    return _object.is<TValue>(_key);
+  }
+
+  template <typename TValue>
+  FORCE_INLINE bool set(TValue value) {
+    return _object.set<TValue>(_key, value);
+  }
+
+  template <typename TValue>
+  FORCE_INLINE bool set(TValue value, uint8_t decimals) {
+    return _object.set(_key, value, decimals);
+  }
+
+  FORCE_INLINE JsonVariant get() { return _object.get(_key); }
+
+  void writeTo(Internals::JsonWriter& writer) const {
+    _object.get(_key).writeTo(writer);
+  }
+
+ private:
+  JsonObject& _object;
+  TKey _key;
+};
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream& operator<<(
+    std::ostream& os, const JsonObjectSubscript<const String&>& source) {
+  return source.printTo(os);
+}
+
+inline std::ostream& operator<<(
+    std::ostream& os, const JsonObjectSubscript<const char*>& source) {
+  return source.printTo(os);
+}
+#endif
+
+}  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

include/ArduinoJson/JsonPair.hpp

@@ -1,11 +1,13 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
+#include "JsonObjectKey.hpp"
 #include "JsonVariant.hpp"
 
 namespace ArduinoJson {

include/ArduinoJson/JsonVariant.hpp

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
@@ -12,6 +13,14 @@
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/JsonVariantContent.hpp"
 #include "Internals/JsonVariantType.hpp"
+#include "JsonVariantBase.hpp"
+#include "RawJson.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsIntegral.hpp"
+#include "TypeTraits/IsSame.hpp"
+#include "TypeTraits/RemoveConst.hpp"
+#include "TypeTraits/RemoveReference.hpp"
 
 namespace ArduinoJson {
 
@@ -26,261 +35,299 @@ class JsonObject;
 // - a char, short, int or a long (signed or unsigned)
 // - a string (const char*)
 // - a reference to a JsonArray or JsonObject
-class JsonVariant : public Internals::JsonPrintable<JsonVariant> {
+class JsonVariant : public JsonVariantBase<JsonVariant> {
  public:
-  // Creates an uninitialized JsonVariant
-  JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
-
-  // Initializes a JsonVariant with the specified value.
   template <typename T>
-  explicit JsonVariant(T value) {
-    set(value);
-  }
+  struct IsConstructibleFrom;
 
-  // Tells weither the variant is valid.
-  bool success() const {
-    return _type != Internals::JSON_INVALID &&
-           _type != Internals::JSON_UNDEFINED;
-  }
+  // Creates an uninitialized JsonVariant
+  FORCE_INLINE JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
 
-  // Sets the variant to a boolean value.
+  // Create a JsonVariant containing a boolean value.
   // It will be serialized as "true" or "false" in JSON.
-  void set(bool value);
+  FORCE_INLINE JsonVariant(bool value);
 
-  // Sets the variant to a floating point value.
+  // Create a JsonVariant containing a floating point value.
   // The second argument specifies the number of decimal digits to write in
   // the JSON string.
-  void set(double value, uint8_t decimals = 2);
-
-  // Sets the variant to be an integer value.
-  void set(signed long value);
-  void set(signed char value) { set(static_cast<long>(value)); }
-  void set(signed int value) { set(static_cast<long>(value)); }
-  void set(signed short value) { set(static_cast<long>(value)); }
-  void set(unsigned char value) { set(static_cast<long>(value)); }
-  void set(unsigned int value) { set(static_cast<long>(value)); }
-  void set(unsigned long value) { set(static_cast<long>(value)); }
-  void set(unsigned short value) { set(static_cast<long>(value)); }
-
-  // Sets the variant to be a string.
-  void set(const char *value);
-
-  // Sets the variant to be a reference to an array.
-  void set(JsonArray &array);
-
-  // Sets the variant to be a reference to an object.
-  void set(JsonObject &object);
-
-  // Sets the variant to the specified value.
+  // JsonVariant(double value, uint8_t decimals);
+  // JsonVariant(float value, uint8_t decimals);
   template <typename T>
-  JsonVariant &operator=(T value) {
-    set(value);
-    return *this;
+  FORCE_INLINE JsonVariant(
+      T value, uint8_t decimals = 2,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
+          * = 0) {
+    using namespace Internals;
+    _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
+    _content.asFloat = static_cast<JsonFloat>(value);
   }
 
-  // Sets the variant to be a reference to an array.
-  JsonVariant &operator=(JsonArray &array) {
-    set(array);
-    return *this;
+  // Create a JsonVariant containing an integer value.
+  // JsonVariant(signed short)
+  // JsonVariant(signed int)
+  // JsonVariant(signed long)
+  template <typename T>
+  FORCE_INLINE JsonVariant(
+      T value, typename TypeTraits::EnableIf<
+                   TypeTraits::IsSignedIntegral<T>::value>::type * = 0) {
+    using namespace Internals;
+    if (value >= 0) {
+      _type = JSON_POSITIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(value);
+    } else {
+      _type = JSON_NEGATIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(-value);
+    }
+  }
+  // JsonVariant(unsigned short)
+  // JsonVariant(unsigned int)
+  // JsonVariant(unsigned long)
+  template <typename T>
+  FORCE_INLINE JsonVariant(
+      T value, typename TypeTraits::EnableIf<
+                   TypeTraits::IsUnsignedIntegral<T>::value>::type * = 0) {
+    using namespace Internals;
+    _type = JSON_POSITIVE_INTEGER;
+    _content.asInteger = static_cast<JsonUInt>(value);
   }
 
-  // Sets the variant to be a reference to an object.
-  JsonVariant &operator=(JsonObject &object) {
-    set(object);
-    return *this;
-  }
+  // Create a JsonVariant containing a string.
+  FORCE_INLINE JsonVariant(const char *value);
 
-  // Gets the variant as a boolean value.
-  // Returns false if the variant is not a boolean value.
-  operator bool() const;
+  // Create a JsonVariant containing an unparsed string
+  FORCE_INLINE JsonVariant(RawJson value);
 
-  // Gets the variant as a floating-point value.
-  // Returns 0.0 if the variant is not a floating-point value
-  operator double() const;
-  operator float() const { return static_cast<float>(as<double>()); }
+  // Create a JsonVariant containing a reference to an array.
+  FORCE_INLINE JsonVariant(JsonArray &array);
 
-  // Gets the variant as an integer value.
-  // Returns 0 if the variant is not an integer value.
-  operator signed long() const;
-  operator signed char() const { return cast_long_to<signed char>(); }
-  operator signed int() const { return cast_long_to<signed int>(); }
-  operator signed short() const { return cast_long_to<signed short>(); }
-  operator unsigned char() const { return cast_long_to<unsigned char>(); }
-  operator unsigned int() const { return cast_long_to<unsigned int>(); }
-  operator unsigned long() const { return cast_long_to<unsigned long>(); }
-  operator unsigned short() const { return cast_long_to<unsigned short>(); }
-
-  // Gets the variant as a string.
-  // Returns NULL if variant is not a string.
-  operator const char *() const;
-  const char *asString() const { return as<const char *>(); }
-
-  // Gets the variant as an array.
-  // Returns a reference to the JsonArray or JsonArray::invalid() if the variant
-  // is not an array.
-  operator JsonArray &() const;
-  JsonArray &asArray() const { return as<JsonArray &>(); }
-
-  // Gets the variant as an object.
-  // Returns a reference to the JsonObject or JsonObject::invalid() if the
-  // variant is not an object.
-  operator JsonObject &() const;
-  JsonObject &asObject() const { return as<JsonObject &>(); }
+  // Create a JsonVariant containing a reference to an object.
+  FORCE_INLINE JsonVariant(JsonObject &object);
 
   // Get the variant as the specified type.
-  // See cast operators for details.
+  //
+  // short as<signed short>() const;
+  // int as<signed int>() const;
+  // long as<signed long>() const;
   template <typename T>
-  T as() const {
-    return static_cast<T>(*this);
+  const typename TypeTraits::EnableIf<TypeTraits::IsSignedIntegral<T>::value,
+                                      T>::type
+  as() const {
+    return static_cast<T>(asInteger());
+  }
+  //
+  // short as<unsigned short>() const;
+  // int as<unsigned int>() const;
+  // long as<unsigned long>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsUnsignedIntegral<T>::value,
+                                      T>::type
+  as() const {
+    return static_cast<T>(asUnsignedInteger());
+  }
+  //
+  // double as<double>() const;
+  // float as<float>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                      T>::type
+  as() const {
+    return static_cast<T>(asFloat());
+  }
+  //
+  // const String as<String>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, String>::value,
+                                      T>::type
+  as() const {
+    return toString();
+  }
+  //
+  // const char* as<const char*>() const;
+  // const char* as<char*>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
+                                    TypeTraits::IsSame<T, char *>::value,
+                                const char *>::type
+  as() const {
+    return asString();
+  }
+  //
+  // const bool as<bool>() const
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
+                                      T>::type
+  as() const {
+    return asInteger() != 0;
+  }
+  //
+  // JsonArray& as<JsonArray> const;
+  // JsonArray& as<JsonArray&> const;
+  // JsonArray& as<const JsonArray&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<
+          typename TypeTraits::RemoveConst<
+              typename TypeTraits::RemoveReference<T>::type>::type,
+          JsonArray>::value,
+      JsonArray &>::type
+  as() const {
+    return asArray();
+  }
+  //
+  // JsonObject& as<JsonObject> const;
+  // JsonObject& as<JsonObject&> const;
+  // JsonObject& as<const JsonObject&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<
+          typename TypeTraits::RemoveConst<
+              typename TypeTraits::RemoveReference<T>::type>::type,
+          JsonObject>::value,
+      JsonObject &>::type
+  as() const {
+    return asObject();
   }
 
   // Tells weither the variant has the specified type.
   // Returns true if the variant has type type T, false otherwise.
+  //
+  // short as<short>() const;
+  // int as<int>() const;
+  // long as<long>() const;
   template <typename T>
-  bool is() const {
-    return false;
+  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value,
+                                      bool>::type
+  is() const {
+    return isInteger();
+  }
+  //
+  // double is<double>() const;
+  // float is<float>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                      bool>::type
+  is() const {
+    return isFloat();
+  }
+  //
+  // const bool is<bool>() const
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
+                                      bool>::type
+  is() const {
+    return isBoolean();
+  }
+  //
+  // bool is<const char*>() const;
+  // bool is<char*>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
+                                    TypeTraits::IsSame<T, char *>::value,
+                                bool>::type
+  is() const {
+    return isString();
+  }
+  //
+  // bool is<JsonArray> const;
+  // bool is<JsonArray&> const;
+  // bool is<const JsonArray&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<
+          typename TypeTraits::RemoveConst<
+              typename TypeTraits::RemoveReference<T>::type>::type,
+          JsonArray>::value,
+      bool>::type
+  is() const {
+    return isArray();
+  }
+  //
+  // JsonObject& as<JsonObject> const;
+  // JsonObject& as<JsonObject&> const;
+  // JsonObject& as<const JsonObject&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<
+          typename TypeTraits::RemoveConst<
+              typename TypeTraits::RemoveReference<T>::type>::type,
+          JsonObject>::value,
+      bool>::type
+  is() const {
+    return isObject();
   }
 
-  // Returns an invalid variant.
-  // This is meant to replace a NULL pointer.
-  static JsonVariant &invalid() { return _invalid; }
+  // Returns true if the variant has a value
+  bool success() const { return _type != Internals::JSON_UNDEFINED; }
 
   // Serialize the variant to a JsonWriter
   void writeTo(Internals::JsonWriter &writer) const;
 
-  // Mimics an array or an object.
-  // Returns the size of the array or object if the variant has that type.
-  // Returns 0 if the variant is neither an array nor an object
-  size_t size() const;
+  // Value returned if the variant has an incompatible type
+  template <typename T>
+  static T defaultValue() {
+    return T();
+  }
 
-  // Mimics an array.
-  // Returns the element at specified index if the variant is an array.
-  // Returns JsonVariant::invalid() if the variant is not an array.
-  JsonVariant &operator[](int index);
-
-  // Mimics an object.
-  // Returns the value associated with the specified key if the variant is an
-  // object.
-  // Return JsonVariant::invalid() if the variant is not an object.
-  JsonVariant &operator[](const char *key);
+  const char *asString() const;
+  JsonArray &asArray() const;
+  JsonObject &asObject() const;
 
  private:
-  // Special constructor used only to create _invalid.
-  explicit JsonVariant(Internals::JsonVariantType type) : _type(type) {}
-
-  // Helper for interger cast operators
+  // It's not allowed to store a char
   template <typename T>
-  T cast_long_to() const {
-    return static_cast<T>(as<long>());
-  }
+  FORCE_INLINE JsonVariant(T value,
+                           typename TypeTraits::EnableIf<
+                               TypeTraits::IsSame<T, char>::value>::type * = 0);
+
+  String toString() const;
+  Internals::JsonFloat asFloat() const;
+  Internals::JsonInteger asInteger() const;
+  Internals::JsonUInt asUnsignedInteger() const;
+  bool isBoolean() const;
+  bool isFloat() const;
+  bool isInteger() const;
+  bool isArray() const { return _type == Internals::JSON_ARRAY; }
+  bool isObject() const { return _type == Internals::JSON_OBJECT; }
+  bool isString() const { return _type == Internals::JSON_STRING; }
 
   // The current type of the variant
   Internals::JsonVariantType _type;
 
   // The various alternatives for the value of the variant.
   Internals::JsonVariantContent _content;
-
-  // The instance returned by JsonVariant::invalid()
-  static JsonVariant _invalid;
 };
 
-template <>
-inline bool JsonVariant::is<long>() const {
-  return _type == Internals::JSON_LONG;
+inline JsonVariant float_with_n_digits(float value, uint8_t digits) {
+  return JsonVariant(value, digits);
 }
 
-template <>
-inline bool JsonVariant::is<double>() const {
-  return _type >= Internals::JSON_DOUBLE_0_DECIMALS;
-}
-
-template <>
-inline bool JsonVariant::is<bool>() const {
-  return _type == Internals::JSON_BOOLEAN;
-}
-
-template <>
-inline bool JsonVariant::is<const char *>() const {
-  return _type == Internals::JSON_STRING;
-}
-
-template <>
-inline bool JsonVariant::is<JsonArray &>() const {
-  return _type == Internals::JSON_ARRAY;
-}
-
-template <>
-inline bool JsonVariant::is<const JsonArray &>() const {
-  return _type == Internals::JSON_ARRAY;
-}
-
-template <>
-inline bool JsonVariant::is<JsonObject &>() const {
-  return _type == Internals::JSON_OBJECT;
-}
-
-template <>
-inline bool JsonVariant::is<const JsonObject &>() const {
-  return _type == Internals::JSON_OBJECT;
+inline JsonVariant double_with_n_digits(double value, uint8_t digits) {
+  return JsonVariant(value, digits);
 }
 
 template <typename T>
-inline bool operator==(const JsonVariant &left, T right) {
-  return left.as<T>() == right;
+struct JsonVariant::IsConstructibleFrom {
+  static const bool value =
+      TypeTraits::IsIntegral<T>::value ||
+      TypeTraits::IsFloatingPoint<T>::value ||
+      TypeTraits::IsSame<T, bool>::value ||
+      TypeTraits::IsSame<T, char *>::value ||
+      TypeTraits::IsSame<T, const char *>::value ||
+      TypeTraits::IsSame<T, RawJson>::value ||
+      TypeTraits::IsSame<T, JsonArray &>::value ||
+      TypeTraits::IsSame<T, const JsonArray &>::value ||
+      TypeTraits::IsSame<T, JsonArraySubscript &>::value ||
+      TypeTraits::IsSame<T, const JsonArraySubscript &>::value ||
+      TypeTraits::IsSame<T, JsonObject &>::value ||
+      TypeTraits::IsSame<T, const JsonObject &>::value ||
+      TypeTraits::IsSame<T, JsonObjectSubscript<const char *> &>::value ||
+      TypeTraits::IsSame<T, const JsonObjectSubscript<const char *> &>::value ||
+      TypeTraits::IsSame<T, JsonObjectSubscript<String> &>::value ||
+      TypeTraits::IsSame<T, const JsonObjectSubscript<String> &>::value ||
+      TypeTraits::IsSame<T, JsonVariant &>::value ||
+      TypeTraits::IsSame<T, const JsonVariant &>::value;
+};
 }
 
-template <typename T>
-inline bool operator==(T left, const JsonVariant &right) {
-  return left == right.as<T>();
-}
-
-template <typename T>
-inline bool operator!=(const JsonVariant &left, T right) {
-  return left.as<T>() != right;
-}
-
-template <typename T>
-inline bool operator!=(T left, const JsonVariant &right) {
-  return left != right.as<T>();
-}
-
-template <typename T>
-inline bool operator<=(const JsonVariant &left, T right) {
-  return left.as<T>() <= right;
-}
-
-template <typename T>
-inline bool operator<=(T left, const JsonVariant &right) {
-  return left <= right.as<T>();
-}
-
-template <typename T>
-inline bool operator>=(const JsonVariant &left, T right) {
-  return left.as<T>() >= right;
-}
-
-template <typename T>
-inline bool operator>=(T left, const JsonVariant &right) {
-  return left >= right.as<T>();
-}
-
-template <typename T>
-inline bool operator<(const JsonVariant &left, T right) {
-  return left.as<T>() < right;
-}
-
-template <typename T>
-inline bool operator<(T left, const JsonVariant &right) {
-  return left < right.as<T>();
-}
-
-template <typename T>
-inline bool operator>(const JsonVariant &left, T right) {
-  return left.as<T>() > right;
-}
-
-template <typename T>
-inline bool operator>(T left, const JsonVariant &right) {
-  return left > right.as<T>();
-}
-}
+// Include inline implementations
+#include "JsonVariant.ipp"

include/ArduinoJson/JsonVariant.ipp

@@ -0,0 +1,89 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Configuration.hpp"
+#include "JsonVariant.hpp"
+#include "Internals/Parse.hpp"
+
+#include <string.h>
+
+namespace ArduinoJson {
+
+inline JsonVariant::JsonVariant(bool value) {
+  using namespace Internals;
+  _type = JSON_BOOLEAN;
+  _content.asInteger = static_cast<JsonInteger>(value);
+}
+
+inline JsonVariant::JsonVariant(const char *value) {
+  _type = Internals::JSON_STRING;
+  _content.asString = value;
+}
+
+inline JsonVariant::JsonVariant(RawJson value) {
+  _type = Internals::JSON_UNPARSED;
+  _content.asString = value;
+}
+
+inline JsonVariant::JsonVariant(JsonArray &array) {
+  _type = Internals::JSON_ARRAY;
+  _content.asArray = &array;
+}
+
+inline JsonVariant::JsonVariant(JsonObject &object) {
+  _type = Internals::JSON_OBJECT;
+  _content.asObject = &object;
+}
+
+inline Internals::JsonInteger JsonVariant::asInteger() const {
+  using namespace Internals;
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return 0;
+    case JSON_POSITIVE_INTEGER:
+    case JSON_BOOLEAN:
+      return _content.asInteger;
+    case JSON_NEGATIVE_INTEGER:
+      return -static_cast<Internals::JsonInteger>(_content.asInteger);
+    case JSON_STRING:
+    case JSON_UNPARSED:
+      if (!_content.asString) return 0;
+      if (!strcmp("true", _content.asString)) return 1;
+      return parse<Internals::JsonInteger>(_content.asString);
+    default:
+      return static_cast<Internals::JsonInteger>(_content.asFloat);
+  }
+}
+
+inline Internals::JsonUInt JsonVariant::asUnsignedInteger() const {
+  using namespace Internals;
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return 0;
+    case JSON_POSITIVE_INTEGER:
+    case JSON_BOOLEAN:
+    case JSON_NEGATIVE_INTEGER:
+      return _content.asInteger;
+    case JSON_STRING:
+    case JSON_UNPARSED:
+      if (!_content.asString) return 0;
+      if (!strcmp("true", _content.asString)) return 1;
+      return parse<Internals::JsonUInt>(_content.asString);
+    default:
+      return static_cast<Internals::JsonUInt>(_content.asFloat);
+  }
+}
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream &operator<<(std::ostream &os, const JsonVariant &source) {
+  return source.printTo(os);
+}
+#endif
+
+}  // namespace ArduinoJson

include/ArduinoJson/JsonVariantBase.hpp

@@ -0,0 +1,133 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Internals/ForceInline.hpp"
+#include "JsonObjectKey.hpp"
+
+namespace ArduinoJson {
+
+// Forward declarations.
+class JsonArraySubscript;
+template <typename TKey>
+class JsonObjectSubscript;
+
+template <typename TImpl>
+class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
+ public:
+  FORCE_INLINE const char *asString() const { return as<const char *>(); }
+
+  // Gets the variant as an array.
+  // Returns a reference to the JsonArray or JsonArray::invalid() if the
+  // variant
+  // is not an array.
+  FORCE_INLINE operator JsonArray &() const { return as<JsonArray &>(); }
+  FORCE_INLINE JsonArray &asArray() const { return as<JsonArray &>(); }
+
+  // Gets the variant as an object.
+  // Returns a reference to the JsonObject or JsonObject::invalid() if the
+  // variant is not an object.
+  FORCE_INLINE operator JsonObject &() const { return as<JsonObject &>(); }
+  FORCE_INLINE JsonObject &asObject() const { return as<JsonObject &>(); }
+
+  template <typename T>
+  FORCE_INLINE operator T() const {
+    return as<T>();
+  }
+
+  template <typename T>
+  FORCE_INLINE const T as() const {
+    return impl()->template as<T>();
+  }
+
+  // Mimics an array or an object.
+  // Returns the size of the array or object if the variant has that type.
+  // Returns 0 if the variant is neither an array nor an object
+  size_t size() const { return asArray().size() + asObject().size(); }
+
+  // Mimics an array.
+  // Returns the element at specified index if the variant is an array.
+  // Returns JsonVariant::invalid() if the variant is not an array.
+  FORCE_INLINE const JsonArraySubscript operator[](int index) const;
+
+  // Mimics an object.
+  // Returns the value associated with the specified key if the variant is
+  // an object.
+  // Return JsonVariant::invalid() if the variant is not an object.
+  FORCE_INLINE const JsonObjectSubscript<const char *> operator[](
+      const char *key) const;
+  FORCE_INLINE const JsonObjectSubscript<const String &> operator[](
+      const String &key) const;
+
+  // Serialize the variant to a JsonWriter
+  void writeTo(Internals::JsonWriter &writer) const;
+
+ private:
+  const TImpl *impl() const { return static_cast<const TImpl *>(this); }
+};
+
+template <typename TImpl, typename TComparand>
+inline bool operator==(const JsonVariantBase<TImpl> &left, TComparand right) {
+  return left.template as<TComparand>() == right;
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator==(TComparand left, const JsonVariantBase<TImpl> &right) {
+  return left == right.template as<TComparand>();
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator!=(const JsonVariantBase<TImpl> &left, TComparand right) {
+  return left.template as<TComparand>() != right;
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator!=(TComparand left, const JsonVariantBase<TImpl> &right) {
+  return left != right.template as<TComparand>();
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator<=(const JsonVariantBase<TImpl> &left, TComparand right) {
+  return left.template as<TComparand>() <= right;
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator<=(TComparand left, const JsonVariantBase<TImpl> &right) {
+  return left <= right.template as<TComparand>();
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator>=(const JsonVariantBase<TImpl> &left, TComparand right) {
+  return left.template as<TComparand>() >= right;
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator>=(TComparand left, const JsonVariantBase<TImpl> &right) {
+  return left >= right.template as<TComparand>();
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator<(const JsonVariantBase<TImpl> &left, TComparand right) {
+  return left.template as<TComparand>() < right;
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator<(TComparand left, const JsonVariantBase<TImpl> &right) {
+  return left < right.template as<TComparand>();
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator>(const JsonVariantBase<TImpl> &left, TComparand right) {
+  return left.template as<TComparand>() > right;
+}
+
+template <typename TImpl, typename TComparand>
+inline bool operator>(TComparand left, const JsonVariantBase<TImpl> &right) {
+  return left > right.template as<TComparand>();
+}
+}

include/ArduinoJson/Polyfills/isInfinity.hpp

@@ -0,0 +1,65 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#include <float.h>
+#else
+#include <math.h>
+#endif
+
+// GCC warning: "conversion to 'float' from 'double' may alter its value"
+#ifdef __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic push
+#endif
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
+#pragma GCC diagnostic ignored "-Wfloat-conversion"
+#else
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+#endif
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+template <typename T>
+bool isInfinity(T x) {
+  return !_finite(x);
+}
+#else
+template <typename T>
+bool isInfinity(T x) {
+  return isinf(x);
+}
+
+#if defined(_GLIBCXX_HAVE_ISINFL) && _GLIBCXX_HAVE_ISINFL
+template <>
+inline bool isInfinity<double>(double x) {
+  return isinfl(x);
+}
+#endif
+
+#if defined(_GLIBCXX_HAVE_ISINFF) && _GLIBCXX_HAVE_ISINFF
+template <>
+inline bool isInfinity<float>(float x) {
+  return isinff(x);
+}
+#endif
+#endif
+}
+}
+
+#if defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic pop
+#endif
+#endif

include/ArduinoJson/Polyfills/isNaN.hpp

@@ -0,0 +1,54 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#include <float.h>
+#else
+#include <math.h>
+#endif
+
+// GCC warning: "conversion to 'float' from 'double' may alter its value"
+#ifdef __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic push
+#endif
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
+#pragma GCC diagnostic ignored "-Wfloat-conversion"
+#else
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+#endif
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+
+template <typename T>
+bool isNaN(T x) {
+  return _isnan(x) != 0;
+}
+#else
+
+template <typename T>
+bool isNaN(T x) {
+  return isnan(x);
+}
+
+#endif
+}
+}
+
+#if defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic pop
+#endif
+#endif

include/ArduinoJson/Polyfills/normalize.hpp

@@ -0,0 +1,47 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+#ifdef ARDUINO
+
+// on embedded platform, favor code size over speed
+
+template <typename T>
+short normalize(T& value) {
+  short powersOf10 = 0;
+  while (value && value < 1) {
+    powersOf10--;
+    value *= 10;
+  }
+  while (value > 10) {
+    powersOf10++;
+    value /= 10;
+  }
+  return powersOf10;
+}
+
+#else
+
+// on non-embedded platform, favor speed over code size
+
+template <typename T>
+short normalize(T& value) {
+  if (value == 0.0) return 0;
+
+  short powersOf10 = static_cast<short>(floor(log10(value)));
+  value /= pow(T(10), powersOf10);
+
+  return powersOf10;
+}
+
+#endif
+}
+}

include/ArduinoJson/Print.hpp

@@ -0,0 +1,39 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#ifndef ARDUINO
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace ArduinoJson {
+// This class reproduces Arduino's Print class
+class Print {
+ public:
+  virtual ~Print() {}
+
+  virtual size_t write(uint8_t) = 0;
+
+  size_t print(const char* s) {
+    size_t n = 0;
+    while (*s) {
+      n += write(*s++);
+    }
+    return n;
+  }
+
+  size_t println() { return write('\r') + write('\n'); }
+};
+}
+
+#else
+
+#include <Print.h>
+
+#endif

include/ArduinoJson/RawJson.hpp

@@ -0,0 +1,21 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+
+// A special type of data that can be used to insert pregenerated JSON portions.
+class RawJson {
+ public:
+  explicit RawJson(const char* str) : _str(str) {}
+  operator const char*() const { return _str; }
+
+ private:
+  const char* _str;
+};
+}

include/ArduinoJson/StaticJsonBuffer.hpp

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #pragma once
 
@@ -21,11 +22,10 @@ class StaticJsonBuffer : public JsonBuffer {
   size_t capacity() const { return CAPACITY; }
   size_t size() const { return _size; }
 
- protected:
-  virtual void* alloc(size_t size) {
-    if (_size + size > CAPACITY) return NULL;
+  virtual void* alloc(size_t bytes) {
+    if (_size + bytes > CAPACITY) return NULL;
     void* p = &_buffer[_size];
-    _size += size;
+    _size += round_size_up(bytes);
     return p;
   }
 

include/ArduinoJson/String.hpp

@@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Configuration.hpp"
+
+#if ARDUINOJSON_USE_ARDUINO_STRING
+
+#include <WString.h>
+
+#else
+
+#include <string>
+
+namespace ArduinoJson {
+typedef std::string String;
+}
+
+#endif

include/ArduinoJson/TypeTraits/EnableIf.hpp

@@ -0,0 +1,22 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that return the type T if Condition is true.
+template <bool Condition, typename T = void>
+struct EnableIf {};
+
+template <typename T>
+struct EnableIf<true, T> {
+  typedef T type;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsFloatingPoint.hpp

@@ -0,0 +1,21 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is a floating point type
+template <typename T>
+struct IsFloatingPoint {
+  static const bool value = IsSame<T, float>::value || IsSame<T, double>::value;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsIntegral.hpp

@@ -0,0 +1,26 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+#include "IsSame.hpp"
+#include "IsSignedIntegral.hpp"
+#include "IsUnsignedIntegral.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is an integral type.
+template <typename T>
+struct IsIntegral {
+  static const bool value = TypeTraits::IsSignedIntegral<T>::value ||
+                            TypeTraits::IsUnsignedIntegral<T>::value ||
+                            TypeTraits::IsSame<T, char>::value;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsReference.hpp

@@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is a reference
+template <typename T>
+struct IsReference {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsReference<T&> {
+  static const bool value = true;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsSame.hpp

@@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if types T and U are the same.
+template <typename T, typename U>
+struct IsSame {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsSame<T, T> {
+  static const bool value = true;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsSignedIntegral.hpp

@@ -0,0 +1,33 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+#include "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is an integral type.
+template <typename T>
+struct IsSignedIntegral {
+  static const bool value = TypeTraits::IsSame<T, signed char>::value ||
+                            TypeTraits::IsSame<T, signed short>::value ||
+                            TypeTraits::IsSame<T, signed int>::value ||
+                            TypeTraits::IsSame<T, signed long>::value ||
+#if ARDUINOJSON_USE_LONG_LONG
+                            TypeTraits::IsSame<T, signed long long>::value ||
+#endif
+
+#if ARDUINOJSON_USE_INT64
+                            TypeTraits::IsSame<T, signed __int64>::value ||
+#endif
+                            false;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsUnsignedIntegral.hpp

@@ -0,0 +1,33 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+#include "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is an integral type.
+template <typename T>
+struct IsUnsignedIntegral {
+  static const bool value = TypeTraits::IsSame<T, unsigned char>::value ||
+                            TypeTraits::IsSame<T, unsigned short>::value ||
+                            TypeTraits::IsSame<T, unsigned int>::value ||
+                            TypeTraits::IsSame<T, unsigned long>::value ||
+#if ARDUINOJSON_USE_LONG_LONG
+                            TypeTraits::IsSame<T, unsigned long long>::value ||
+#endif
+
+#if ARDUINOJSON_USE_INT64
+                            TypeTraits::IsSame<T, unsigned __int64>::value ||
+#endif
+                            false;
+};
+}
+}

include/ArduinoJson/TypeTraits/RemoveConst.hpp

@@ -0,0 +1,23 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct RemoveConst {
+  typedef T type;
+};
+template <typename T>
+struct RemoveConst<const T> {
+  typedef T type;
+};
+}
+}

include/ArduinoJson/TypeTraits/RemoveReference.hpp

@@ -0,0 +1,23 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that return the type T without the reference modifier.
+template <typename T>
+struct RemoveReference {
+  typedef T type;
+};
+template <typename T>
+struct RemoveReference<T&> {
+  typedef T type;
+};
+}
+}

library.json

@@ -2,16 +2,21 @@
   "name": "Json",
   "keywords": "json, rest, http, web",
   "description": "An elegant and efficient JSON library for embedded systems",
-  "repository":
-  {
+  "repository": {
     "type": "git",
     "url": "https://github.com/bblanchon/ArduinoJson.git"
   },
-  "authors":
-  {
+  "version": "5.5.1",
+  "authors": {
     "name": "Benoit Blanchon",
     "url": "http://blog.benoitblanchon.fr"
   },
+  "exclude": [
+    "scripts",
+    "src/ArduinoJson.h",
+    "test",
+    "third-party"
+  ],
   "frameworks": "arduino",
-  "platforms": "atmelavr"  
-}
+  "platforms": "*"
+}

library.properties

@@ -1,8 +1,9 @@
 name=ArduinoJson
-version=4.0
-author=Benoit Blanchon <http://blog.benoitblanchon.fr/>
-maintainer=Benoit Blanchon <http://blog.benoitblanchon.fr/>
-sentence=An efficient and elegant JSON library for Arduino
-paragraph=Supports JSON parsing and formatting. Uses fixed memory allocation.
+version=5.5.1
+author=Benoit Blanchon <blog.benoitblanchon.fr>
+maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
+sentence=An efficient and elegant JSON library for Arduino.
+paragraph=Like this project? Please star it on GitHub!
+category=Data Processing
 url=https://github.com/bblanchon/ArduinoJson
-architectures=*
+architectures=*

scripts/build-arduino-package.sh

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

scripts/build-old-arduino-package.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+TAG=$(git describe)
+OUTPUT="ArduinoJson-$TAG-old-layout.zip"
+
+cd $(dirname $0)/..
+
+cat > ArduinoJson.h <<END
+// WARNING:
+// --------
+// This file is a workaround for old version of the Arduino IDE.
+// If you are using Arduino IDE 1.0.6 or above, then you installed the wrong 
+// package of ArduinoJson.
+// In that case, just delete the current installation and install the package.
+
+END
+cp ArduinoJson.h ArduinoJson.cpp
+
+cat "include/ArduinoJson.h" | sed 's!include "!include "include/!g' >> ArduinoJson.h
+
+find src -name "*.cpp" |
+while read FILE; do
+	echo >> ArduinoJson.cpp
+	echo "// $FILE" >> ArduinoJson.cpp
+	echo "//" >> ArduinoJson.cpp
+	cat "$FILE" | sed 's!\.\./!!g' >> ArduinoJson.cpp
+done
+
+unix2dos ArduinoJson.cpp
+unix2dos ArduinoJson.h
+
+pushd ..
+
+# remove existing file
+rm -f $OUTPUT
+
+# create zipman dos2
+7z a $OUTPUT \
+	ArduinoJson/CHANGELOG.md \
+	ArduinoJson/examples \
+	ArduinoJson/include/ArduinoJson \
+	ArduinoJson/keywords.txt \
+	ArduinoJson/LICENSE.md \
+	ArduinoJson/README.md \
+	ArduinoJson/ArduinoJson.h \
+	ArduinoJson/ArduinoJson.cpp \
+	-x!ArduinoJson/src/CMakeLists.txt
+
+popd
+
+rm ArduinoJson.h
+rm ArduinoJson.cpp

scripts/create-build-envs.sh

@@ -20,10 +20,10 @@ build-env()
 if [[ $(uname) == MINGW* ]]
 then
 	build-env "Make" "MinGW Makefiles"
-	build-env "SublimeText" "Sublime Text 2 - MinGW Makefiles"
-	build-env "VisualStudio" "Visual Studio 12 2013"
+	build-env "SublimeText" "Sublime Text 2 - Ninja"
+	build-env "VisualStudio" "Visual Studio 14 2015"
 else
-	build-env "SublimeText" "Sublime Text 2 - Unix Makefiles"
+	build-env "SublimeText" "Sublime Text 2 - Ninja"
 	build-env "Make" "Unix Makefiles"
 	build-env "Xcode" "Xcode"
-fi
+fi

scripts/create-size-graph.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+set -eu
+
+OUTPUT="$(pwd)/sizes.csv"
+
+echo "Tag;Date;Parser;Generator" > $OUTPUT
+
+cd $(dirname $(dirname $0))
+
+git tag | while read TAG
+do 
+
+	git checkout -q tags/$TAG
+
+	DATE=$(git log -1 --date=short --pretty=format:%cd)
+	PARSER_SIZE=$(arduino --verify examples/JsonParserExample/JsonParserExample.ino 2>/dev/null  | grep -e 'Sketch uses' | sed 's/.*uses \([0-9]*\).\([0-9]\+\).*/\1\2/')
+	
+	if [ -e 'examples/JsonGeneratorExample/JsonGeneratorExample.ino' ]; then
+		GENERATOR_SIZE=$(arduino --verify examples/JsonGeneratorExample/JsonGeneratorExample.ino 2>/dev/null  | grep -e 'Sketch uses' | sed 's/.*uses \([0-9]*\).\([0-9]\+\).*/\1\2/')
+	else
+		GENERATOR_SIZE=""
+	fi
+
+	echo $TAG 
+	if [ ! -z "$PARSER_SIZE" ]
+	then
+		echo "JsonParserExample = $PARSER_SIZE bytes"
+	else
+		echo "JsonParserExample compilation failed."
+	fi
+
+	if [ ! -z "$GENERATOR_SIZE" ]
+	then
+		echo "JsonGeneratorExample = $GENERATOR_SIZE bytes"
+	else
+		echo "JsonGeneratorExample compilation failed."
+	fi
+
+	echo "$TAG;$DATE;$PARSER_SIZE;$GENERATOR_SIZE" >> $OUTPUT
+
+done

scripts/travis/arduino.sh

@@ -0,0 +1,16 @@
+#!/bin/sh -eux
+
+/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16
+sleep 3
+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/
+  
+ln -s $PWD /tmp/arduino/libraries/ArduinoJson
+
+for EXAMPLE in $PWD/examples/*/*.ino; do
+	arduino --verify --board $BOARD $EXAMPLE
+done

scripts/travis/cmake-osx.sh

@@ -0,0 +1,9 @@
+#!/bin/sh -eux
+
+URL=https://cmake.org/files/v3.4/cmake-3.4.3-Darwin-x86_64.tar.gz
+
+curl -sS $URL | tar xz -C /tmp --strip 1
+
+/tmp/CMake.app/Contents/bin/cmake .
+make
+make test

scripts/travis/cmake.sh

@@ -0,0 +1,9 @@
+#!/bin/sh -eux
+
+URL=https://cmake.org/files/v3.4/cmake-3.4.3-Linux-x86_64.tar.gz
+
+curl -sS $URL | tar xz -C /tmp --strip 1
+
+/tmp/bin/cmake -DCMAKE_CXX_COMPILER=$CMAKE_CXX_COMPILER .
+make 
+make test

scripts/travis/coverage.sh

@@ -0,0 +1,10 @@
+#!/bin/sh -eux
+
+curl https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1
+
+/tmp/bin/cmake -DCOVERAGE=true .
+make 
+make test
+
+pip install --user cpp-coveralls
+coveralls --exclude third-party --gcov-options '\-lp'; fi

scripts/travis/platformio.sh

@@ -0,0 +1,10 @@
+#!/bin/sh -eux
+
+pip install --user platformio
+
+rm -r test
+
+for EXAMPLE in JsonParserExample JsonGeneratorExample
+do
+	platformio ci examples/$EXAMPLE/$EXAMPLE.ino -l '.' -b $BOARD
+done

src/Arduino/Print.cpp

@@ -1,35 +0,0 @@
-// Copyright Benoit Blanchon 2014
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#ifndef ARDUINO
-
-#include "../../include/ArduinoJson/Arduino/Print.hpp"
-
-#include <stdio.h>  // for sprintf
-
-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, "%.*f", digits, 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

src/ArduinoJson.h

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 // About this file
 // ---------------

src/CMakeLists.txt

@@ -1,9 +1,18 @@
-file(GLOB_RECURSE INC_FILES ../include/*.hpp)
-file(GLOB_RECURSE SRC_FILES *.cpp)
+# Copyright Benoit Blanchon 2014-2016
+# MIT License
+# 
+# Arduino JSON library
+# https://github.com/bblanchon/ArduinoJson
+# If you like this project, please add a star!
+
+file(GLOB_RECURSE HPP_FILES ../include/*.hpp)
+file(GLOB_RECURSE IPP_FILES ../include/*.ipp)
+file(GLOB_RECURSE CPP_FILES *.cpp)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
-	add_definitions(
+	add_compile_options(
 		-fno-exceptions
+		-fno-rtti
 		-pedantic
 		-Wall
 		-Wcast-align
@@ -20,6 +29,7 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 		-Wno-sign-conversion
 		-Wno-unused
 		-Wno-variadic-macros
+		-Wnon-virtual-dtor
 		-Wold-style-cast
 		-Woverloaded-virtual
 		-Wredundant-decls
@@ -30,13 +40,32 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 	)
 endif()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU)")
-	add_definitions(
-		-Wlogical-op
-		-Wnoexcept
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	add_compile_options(
 		-Wstrict-null-sentinel
 	)
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)
+		add_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy
+	endif()
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)
+		add_compile_options(-Wnoexcept)
+	endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	add_compile_options(
+		-Wc++11-compat
+		-Wdeprecated-register
+	)
 endif()
 
+if(MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+	add_compile_options(-W4)
+endif()
 
-add_library(ArduinoJson ${SRC_FILES} ${INC_FILES})
+add_library(ArduinoJson ${CPP_FILES} ${HPP_FILES} ${IPP_FILES})
+
+target_include_directories(ArduinoJson INTERFACE ${CMAKE_CURRENT_LIST_DIR}/../include)

src/Internals/Comments.cpp

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

src/Internals/Encoding.cpp

@@ -0,0 +1,14 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#include "../../include/ArduinoJson/Internals/Encoding.hpp"
+
+// How to escape special chars:
+// _escapeTable[2*i+1] => the special char
+// _escapeTable[2*i] => the char to use instead
+const char ArduinoJson::Internals::Encoding::_escapeTable[] =
+    "\"\"\\\\b\bf\fn\nr\rt\t";

src/Internals/IndentedPrint.cpp

@@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #include "../../include/ArduinoJson/Internals/IndentedPrint.hpp"
 

src/Internals/JsonParser.cpp

@@ -1,15 +1,14 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
 
 #include "../../include/ArduinoJson/Internals/JsonParser.hpp"
 
-#include <stdlib.h>  // for strtol, strtod
-#include <ctype.h>
-
-#include "../../include/ArduinoJson/Internals/QuotedString.hpp"
+#include "../../include/ArduinoJson/Internals/Comments.hpp"
+#include "../../include/ArduinoJson/Internals/Encoding.hpp"
 #include "../../include/ArduinoJson/JsonArray.hpp"
 #include "../../include/ArduinoJson/JsonBuffer.hpp"
 #include "../../include/ArduinoJson/JsonObject.hpp"
@@ -17,73 +16,35 @@
 using namespace ArduinoJson;
 using namespace ArduinoJson::Internals;
 
-void JsonParser::skipSpaces() {
-  while (isspace(*_ptr)) _ptr++;
-}
-
 bool JsonParser::skip(char charToSkip) {
-  skipSpaces();
-  if (*_ptr != charToSkip) return false;
-  _ptr++;
-  skipSpaces();
+  const char *ptr = skipSpacesAndComments(_readPtr);
+  if (*ptr != charToSkip) return false;
+  ptr++;
+  _readPtr = skipSpacesAndComments(ptr);
   return true;
 }
 
-bool JsonParser::skip(const char *wordToSkip) {
-  const char *charToSkip = wordToSkip;
-  while (*charToSkip && *_ptr == *charToSkip) {
-    charToSkip++;
-    _ptr++;
-  }
-  return *charToSkip == '\0';
+bool JsonParser::parseAnythingTo(JsonVariant *destination) {
+  if (_nestingLimit == 0) return false;
+  _nestingLimit--;
+  bool success = parseAnythingToUnsafe(destination);
+  _nestingLimit++;
+  return success;
 }
 
-void JsonParser::parseAnythingTo(JsonVariant &destination) {
-  if (_nestingLimit == 0) return;
-  _nestingLimit--;
+inline bool JsonParser::parseAnythingToUnsafe(JsonVariant *destination) {
+  _readPtr = skipSpacesAndComments(_readPtr);
 
-  skipSpaces();
-
-  switch (*_ptr) {
+  switch (*_readPtr) {
     case '[':
-      destination = parseArray();
-      break;
+      return parseArrayTo(destination);
 
     case '{':
-      destination = parseObject();
-      break;
+      return parseObjectTo(destination);
 
-    case 't':
-    case 'f':
-      parseBooleanTo(destination);
-      break;
-
-    case '-':
-    case '.':
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-      parseNumberTo(destination);
-      break;
-
-    case 'n':
-      parseNullTo(destination);
-      break;
-
-    case '\'':
-    case '\"':
-      destination = parseString();
-      break;
+    default:
+      return parseStringTo(destination);
   }
-
-  _nestingLimit++;
 }
 
 JsonArray &JsonParser::parseArray() {
@@ -97,9 +58,9 @@ JsonArray &JsonParser::parseArray() {
   // Read each value
   for (;;) {
     // 1 - Parse value
-    JsonVariant &value = array.add();
-    parseAnythingTo(value);
-    if (!value.success()) goto ERROR_INVALID_VALUE;
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!array.add(value)) goto ERROR_NO_MEMORY;
 
     // 2 - More values?
     if (skip(']')) goto SUCCES_NON_EMPTY_ARRAY;
@@ -113,9 +74,18 @@ SUCCES_NON_EMPTY_ARRAY:
 ERROR_INVALID_VALUE:
 ERROR_MISSING_BRACKET:
 ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
   return JsonArray::invalid();
 }
 
+bool JsonParser::parseArrayTo(JsonVariant *destination) {
+  JsonArray &array = parseArray();
+  if (!array.success()) return false;
+
+  *destination = array;
+  return true;
+}
+
 JsonObject &JsonParser::parseObject() {
   // Create an empty object
   JsonObject &object = _buffer->createObject();
@@ -132,9 +102,9 @@ JsonObject &JsonParser::parseObject() {
     if (!skip(':')) goto ERROR_MISSING_COLON;
 
     // 2 - Parse value
-    JsonVariant &value = object.add(key);
-    parseAnythingTo(value);
-    if (!value.success()) goto ERROR_INVALID_VALUE;
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!object.set(key, value)) goto ERROR_NO_MEMORY;
 
     // 3 - More keys/values?
     if (skip('}')) goto SUCCESS_NON_EMPTY_OBJECT;
@@ -150,48 +120,82 @@ ERROR_INVALID_VALUE:
 ERROR_MISSING_BRACE:
 ERROR_MISSING_COLON:
 ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
   return JsonObject::invalid();
 }
 
-void JsonParser::parseBooleanTo(JsonVariant &destination) {
-  if (skip("true"))
-    destination = true;
-  else if (skip("false"))
-    destination = false;
-  else
-    destination = JsonVariant::invalid();
+bool JsonParser::parseObjectTo(JsonVariant *destination) {
+  JsonObject &object = parseObject();
+  if (!object.success()) return false;
+
+  *destination = object;
+  return true;
 }
 
-void JsonParser::parseNumberTo(JsonVariant &destination) {
-  char *endOfLong;
-  long longValue = strtol(_ptr, &endOfLong, 10);
-  char stopChar = *endOfLong;
-
-  // Could it be a floating point value?
-  bool couldBeFloat = stopChar == '.' || stopChar == 'e' || stopChar == 'E';
-
-  if (couldBeFloat) {
-    // Yes => parse it as a double
-    double doubleValue = strtod(_ptr, &_ptr);
-    // Count the decimal digits
-    uint8_t decimals = static_cast<uint8_t>(_ptr - endOfLong - 1);
-    // Set the variant as a double
-    destination.set(doubleValue, decimals);
-  } else {
-    // No => set the variant as a long
-    _ptr = endOfLong;
-    destination = longValue;
-  }
+static inline bool isInRange(char c, char min, char max) {
+  return min <= c && c <= max;
 }
 
-void JsonParser::parseNullTo(JsonVariant &destination) {
-  const char *NULL_STRING = NULL;
-  if (skip("null"))
-    destination = NULL_STRING;
-  else
-    destination = JsonVariant::invalid();
+static inline bool isLetterOrNumber(char c) {
+  return isInRange(c, '0', '9') || isInRange(c, 'a', 'z') ||
+         isInRange(c, 'A', 'Z') || c == '-' || c == '.';
 }
 
+static inline bool isQuote(char c) { return c == '\'' || c == '\"'; }
+
 const char *JsonParser::parseString() {
-  return QuotedString::extractFrom(_ptr, &_ptr);
+  const char *readPtr = _readPtr;
+  char *writePtr = _writePtr;
+
+  char c = *readPtr;
+
+  if (isQuote(c)) {  // quotes
+    char stopChar = c;
+    for (;;) {
+      c = *++readPtr;
+      if (c == '\0') break;
+
+      if (c == stopChar) {
+        readPtr++;
+        break;
+      }
+
+      if (c == '\\') {
+        // replace char
+        c = Encoding::unescapeChar(*++readPtr);
+        if (c == '\0') break;
+      }
+
+      *writePtr++ = c;
+    }
+  } else {  // no quotes
+    for (;;) {
+      if (!isLetterOrNumber(c)) break;
+      *writePtr++ = c;
+      c = *++readPtr;
+    }
+  }
+  // end the string here
+  *writePtr++ = '\0';
+
+  const char *startPtr = _writePtr;
+
+  // update end ptr
+  _readPtr = readPtr;
+  _writePtr = writePtr;
+
+  // return pointer to unquoted string
+  return startPtr;
+}
+
+bool JsonParser::parseStringTo(JsonVariant *destination) {
+  bool hasQuotes = isQuote(_readPtr[0]);
+  const char *value = parseString();
+  if (value == NULL) return false;
+  if (hasQuotes) {
+    *destination = value;
+  } else {
+    *destination = RawJson(value);
+  }
+  return true;
 }