Set version to 5.7.1

* Removed `ArduinoJson::String`
* Removed `JsonVariant::defaultValue<T>()`
* Removed non-template `JsonObject::get()` and `JsonArray.get()`
* Fixed support for `StringSumHelper` (issue #184)
* Replaced `ARDUINOJSON_USE_ARDUINO_STRING` by `ARDUINOJSON_ENABLE_STD_STRING` and `ARDUINOJSON_ENABLE_ARDUINO_STRING` (issue #378)
* Added example `StringExample.ino` to show where `String` can be used

.clang-format

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

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,11 @@
+<!--
+Thanks for using ArduinoJson :-)
+
+Before opening an issue, please make sure you've read these:
+https://github.com/bblanchon/ArduinoJson/wiki/FAQ
+https://github.com/bblanchon/ArduinoJson/wiki/Avoiding-pitfalls
+
+Next, make sure you provide all the relevant information: platform, code snippet, and error messages.
+
+Please be concise!
+-->

.mbedignore

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

.travis.yml

@@ -64,16 +64,50 @@ matrix:
           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: 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

ArduinoJson.h

@@ -5,10 +5,4 @@
 // 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,6 +1,125 @@
 ArduinoJson: change log
 =======================
 
+v5.7.1
+------
+
+* Added support for PROGMEM (issue #76)
+* Fixed compilation error when index is not an `int` (issue #381)
+
+v5.7.0
+------
+
+* Templatized all functions using `String` or `std::string`
+* Removed `ArduinoJson::String`
+* Removed `JsonVariant::defaultValue<T>()`
+* Removed non-template `JsonObject::get()` and `JsonArray.get()`
+* Fixed support for `StringSumHelper` (issue #184)
+* Replaced `ARDUINOJSON_USE_ARDUINO_STRING` by `ARDUINOJSON_ENABLE_STD_STRING` and `ARDUINOJSON_ENABLE_ARDUINO_STRING` (issue #378)
+* Added example `StringExample.ino` to show where `String` can be used
+* Increased default nesting limit to 50 when compiled for a computer (issue #349)
+
+**BREAKING CHANGES**:
+
+The non-template functions `JsonObject::get()` and `JsonArray.get()` have been removed. This means that you need to explicitely tell the type you expect in return.
+
+Old code:
+
+```c++
+#define ARDUINOJSON_USE_ARDUINO_STRING 0
+JsonVariant value1 = myObject.get("myKey");
+JsonVariant value2 = myArray.get(0);
+```
+
+New code:
+
+```c++
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
+#define ARDUINOJSON_ENABLE_STD_STRING 1
+JsonVariant value1 = myObject.get<JsonVariant>("myKey");
+JsonVariant value2 = myArray.get<JsonVariant>(0);
+```
+
+
+v5.6.7
+------
+
+* Fixed `array[idx].as<JsonVariant>()` and `object[key].as<JsonVariant>()`
+* Fixed return value of `JsonObject::set()` (issue #350)
+* Fixed undefined behavior in `Prettyfier` and `Print` (issue #354)
+* Fixed parser that incorrectly rejected floats containing a `+` (issue #349)
+
+v5.6.6
+------
+
+* Fixed `-Wparentheses` warning introduced in v5.6.5 (PR #335 by @nuket)
+* Added `.mbedignore` for ARM mbdeb (PR #334 by @nuket)
+* Fixed  `JsonVariant::success()` which didn't propagate `JsonArray::success()` nor `JsonObject::success()` (issue #342).
+
+v5.6.5
+------
+
+* `as<char*>()` now returns `true` when input is `null` (issue #330)
+
+v5.6.4
+------
+
+* Fixed error in float serialization (issue #324)
+
+v5.6.3
+------
+
+* Improved speed of float serialization (about twice faster)
+* Added `as<JsonArray>()` as a synonym for `as<JsonArray&>()`... (issue #291)
+* Fixed `call of overloaded isinf(double&) is ambiguous` (issue #284)
+
+v5.6.2
+------
+
+* Fixed build when another lib does `#undef isnan` (issue #284)
+
+v5.6.1
+------
+
+* Added missing `#pragma once` (issue #310)
+
+v5.6.0
+------
+
+* ArduinoJson is now a header-only library (issue #199)
+
+v5.5.1
+------
+
+* Fixed compilation error with Intel Galileo (issue #299)
+
+v5.5.0
+------
+
+* Added `JsonVariant::success()` (issue #279)
+* Renamed `JsonVariant::invalid<T>()` to `JsonVariant::defaultValue<T>()`
+
+v5.4.0
+------
+
+* Changed `::String` to `ArduinoJson::String` (issue #275)
+* Changed `::Print` to `ArduinoJson::Print` too
+
+v5.3.0
+------
+
+* Added custom implementation of `ftoa` (issues #266, #267, #269 and #270)
+* Added `JsonVariant JsonBuffer::parse()` (issue #265)
+* Fixed `unsigned long` printed as `signed long` (issue #170)
+
+v5.2.0
+------
+
+* Added `JsonVariant::as<char*>()` as a synonym for `JsonVariant::as<const char*>()` (issue #257)
+* Added example `JsonHttpClient` (issue #256)
+* Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254)
+* Added `RawJson()` to insert pregenerated JSON portions (issue #259)
+
 v5.1.1
 ------
 
@@ -58,7 +177,7 @@ v5.0.3
 v5.0.2
 ------
 
-* Fixed segmentation fault in `parseObject(String)` and `parseArray(String)`, when the 
+* 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)
@@ -174,14 +293,14 @@ v3.1
 
 Old generator API:
 
-	JsonObject<3> root; 
+	JsonObject<3> root;
     root.add("sensor", "gps");
     root.add("time", 1351824120);
     root.add("data", array);
 
 New generator API:
 
-	JsonObject<3> root; 
+	JsonObject<3> root;
     root["sensor"] = "gps";
     root["time"] = 1351824120;
     root["data"] = array;
@@ -238,7 +357,7 @@ v1.1
 * Example: changed `char* json` into `char[] json` so that the bytes are not write protected
 * Fixed parsing bug when the JSON contains multi-dimensional arrays
 
-v1.0 
+v1.0
 ----
 
 Initial release

CMakeLists.txt

@@ -5,7 +5,7 @@
 # https://github.com/bblanchon/ArduinoJson
 # If you like this project, please add a star!
 
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.0)
 project(ArduinoJson)
 
 enable_testing()
@@ -18,5 +18,4 @@ if(${COVERAGE})
 	set(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
 endif()
 
-add_subdirectory(src)
 add_subdirectory(test)

README.md

@@ -15,10 +15,12 @@ Features
 * JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
 * Elegant API, very easy to use
-* Efficient (no malloc, nor copy)
+* Fixed memory allocation (zero malloc)
+* No data duplication (zero copy)
 * Portable (written in C++98)
 * Self-contained (no external dependency)
 * Small footprint
+* Header-only library
 * MIT License
 
 Works on
@@ -27,7 +29,7 @@ Works on
 * All Arduino boards (Uno, Due, Mini, Micro, Yun...)
 * ESP8266
 * Teensy
-* Intel Edison
+* Intel Edison and Galileo
 * PlatformIO
 * Energia
 * RedBearLab boards (BLE Nano...)
@@ -84,38 +86,43 @@ From Arduino's Forum user `jflaplante`:
 > I tried aJson json-arduino before trying your library. I always ran into memory problem after a while.
 > I have no such problem so far with your library. It is working perfectly with my web services.
 
-From Arduino's Forum user `gbathree`:
-> Thanks so much - this is an awesome library!  If you want to see what we're doing with it - the project is located at www.photosynq.org.
-
 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
-* Surge Communications
-* Alex Scott
-* Firepick Services LLC
-* A B Doodkorte
-* Scott Smith
-* Johann Stieger
+* Robert Murphy <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Surge Communications <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Alex Scott <img alt='United Kingdom' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1e7.svg' width='18' height='18'>
+* Firepick Services LLC <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* A B Doodkorte <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
+* Scott Smith <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Johann Stieger <img alt='Austria' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e6-1f1f9.svg' width='18' height='18'>
+* Gustavo Donizeti Gini <img alt='Brazil' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e7-1f1f7.svg' width='18' height='18'>
+* Charles-Henri Hallard <img alt='France' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1eb-1f1f7.svg' width='18' height='18'>
+* Martijn van den Burg <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
+* Nick Koumaris <img alt='Greece' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1f7.svg' width='18' height='18'>
+* Jon Williams <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Kestutis Liaugminas <img alt='Lithuania' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f1-1f1f9.svg' width='18' height='18'>
+* Darlington Adibe <img alt='Nigeria' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1ec.svg' width='18' height='18'>
+* Yoeri Kroon <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
 
 ---
 

appveyor.yml

@@ -1,11 +1,13 @@
-version: 5.1.1.{build}
+version: 5.7.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
+#  - CMAKE_GENERATOR: MinGW Makefiles
+# Note: Disabled because of unexplicated error -1073741511
+# This used to work fine with GCC 4.8.2 then failed after they upgraded to GCC 4.9.3
 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
@@ -13,4 +15,4 @@ before_build:
 build_script:
 - cmake --build . --config %CONFIGURATION%
 test_script:
-- ctest -V . 
+- ctest -V .

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/ProgmemExample/ProgmemExample.ino

@@ -0,0 +1,51 @@
+// 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>
+
+// About
+// -----
+// This example shows the different ways you can use PROGMEM with ArduinoJson.
+// Please don't see this as an invitation to use PROGMEM.
+// On the contrary, you should always use char[] when possible, it's much more
+// efficient in term of code size, speed and memory usage.
+
+void setup() {
+#if ARDUINO_ARCH_AVR
+  DynamicJsonBuffer jsonBuffer;
+
+  // You can use a Flash String as your JSON input.
+  // WARNING: the content of the Flash String will be duplicated in the
+  // JsonBuffer.
+  JsonObject& root =
+      jsonBuffer.parseObject(F("{\"sensor\":\"gps\",\"time\":1351824120,"
+                               "\"data\":[48.756080,2.302038]}"));
+
+  // You can use a Flash String to get an element of a JsonObject
+  // No duplication is done.
+  long time = root[F("time")];
+
+  // You can use a Flash String to set an element of a JsonObject
+  // WARNING: the content of the Flash String will be duplicated in the
+  // JsonBuffer.
+  root[F("time")] = time;
+
+  // You can set a Flash String to a JsonObject or JsonArray:
+  // WARNING: the content of the Flash String will be duplicated in the
+  // JsonBuffer.
+  root["sensor"] = F("gps");
+
+#else
+
+#warning PROGMEM is only supported on AVR architecture
+
+#endif
+}
+
+void loop() {
+  // not used in this example
+}

examples/StringExample/StringExample.ino

@@ -0,0 +1,53 @@
+// 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>
+
+// About
+// -----
+// This example shows the different ways you can use String with ArduinoJson.
+// Please don't see this as an invitation to use String.
+// On the contrary, you should always use char[] when possible, it's much more
+// efficient in term of code size, speed and memory usage.
+
+void setup() {
+  DynamicJsonBuffer jsonBuffer;
+
+  // You can use a String as your JSON input.
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
+  String input =
+      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+  JsonObject& root = jsonBuffer.parseObject(input);
+
+  // You can use a String to get an element of a JsonObject
+  // No duplication is done.
+  long time = root[String("time")];
+
+  // You can use a String to set an element of a JsonObject
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
+  root[String("time")] = time;
+
+  // You can get a String from a JsonObject or JsonArray:
+  // No duplication is done, at least not in the JsonBuffer.
+  String sensor = root[String("sensor")];
+
+  // You can set a String to a JsonObject or JsonArray:
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
+  root["sensor"] = sensor;
+
+  // You can also concatenate strings
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
+  root[String("sen") + "sor"] = String("gp") + "s";
+
+  // Lastly, you can print the resulting JSON to a String
+  String output;
+  root.printTo(output);
+}
+
+void loop() {
+  // not used in this example
+}

include/ArduinoJson.h

@@ -5,9 +5,5 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
-#include "ArduinoJson/DynamicJsonBuffer.hpp"
-#include "ArduinoJson/JsonArray.hpp"
-#include "ArduinoJson/JsonObject.hpp"
-#include "ArduinoJson/StaticJsonBuffer.hpp"
-
+#include "ArduinoJson.hpp"
 using namespace ArduinoJson;

include/ArduinoJson.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
+
+#include "ArduinoJson/DynamicJsonBuffer.hpp"
+#include "ArduinoJson/JsonArray.hpp"
+#include "ArduinoJson/JsonObject.hpp"
+#include "ArduinoJson/StaticJsonBuffer.hpp"
+
+#include "ArduinoJson/Internals/JsonParser.ipp"
+#include "ArduinoJson/Internals/JsonSerializer.ipp"
+#include "ArduinoJson/JsonArray.ipp"
+#include "ArduinoJson/JsonBuffer.ipp"
+#include "ArduinoJson/JsonObject.ipp"
+#include "ArduinoJson/JsonVariant.ipp"
+
+using namespace ArduinoJson;

include/ArduinoJson/Arduino/Print.hpp

@@ -1,89 +0,0 @@
-// 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 "../Internals/JsonFloat.hpp"
-#include "../Internals/JsonInteger.hpp"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-// snprintf has been added in Visual Studio 2015
-#define ARDUINOJSON_SNPRINTF _snprintf
-#else
-#define ARDUINOJSON_SNPRINTF snprintf
-#endif
-
-// 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 print(ArduinoJson::Internals::JsonFloat value, int digits = 2) {
-    char tmp[32];
-
-    // https://github.com/arduino/Arduino/blob/db8cbf24c99dc930b9ccff1a43d018c81f178535/hardware/arduino/sam/cores/arduino/Print.cpp#L220
-    bool isBigDouble = value > 4294967040.0 || value < -4294967040.0;
-
-    if (isBigDouble) {
-      // Arduino's implementation prints "ovf"
-      // We prefer using the scientific notation, since we have sprintf
-      ARDUINOJSON_SNPRINTF(tmp, sizeof(tmp), "%g", value);
-    } else {
-      // Here we have the exact same output as Arduino's implementation
-      ARDUINOJSON_SNPRINTF(tmp, sizeof(tmp), "%.*f", digits, value);
-    }
-
-    return print(tmp);
-  }
-
-  size_t print(ArduinoJson::Internals::JsonInteger value) {
-    // see http://clc-wiki.net/wiki/K%26R2_solutions:Chapter_3:Exercise_4
-    char buffer[22];
-
-    size_t n = 0;
-    if (value < 0) {
-      value = -value;
-      n += write('-');
-    }
-    uint8_t i = 0;
-    do {
-      ArduinoJson::Internals::JsonInteger digit = value % 10;
-      value /= 10;
-      buffer[i++] = static_cast<char>(digit >= 0 ? '0' + digit : '0' - digit);
-    } while (value);
-
-    while (i > 0) {
-      n += write(buffer[--i]);
-    }
-
-    return n;
-  }
-
-  size_t println() { return write('\r') + write('\n'); }
-};
-
-#else
-
-#include <Print.h>
-
-#endif

include/ArduinoJson/Arduino/String.hpp

@@ -1,19 +0,0 @@
-// 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 <string>
-typedef std::string String;
-
-#else
-
-#include <WString.h>
-
-#endif

include/ArduinoJson/Configuration.hpp

@@ -22,7 +22,26 @@
 #define ARDUINOJSON_USE_INT64 0
 #endif
 
-// arduino doesn't support STL stream
+// Arduino has its own implementation of String to replace std::string
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
+#endif
+
+// On AVR archiecture, we can use PROGMEM
+#ifndef ARDUINOJSON_ENABLE_PROGMEM
+#ifdef ARDUINO_ARCH_AVR
+#define ARDUINOJSON_ENABLE_PROGMEM 1
+#else
+#define ARDUINOJSON_ENABLE_PROGMEM 0
+#endif
+#endif
+
+// Arduino doesn't have std::string
+#ifndef ARDUINOJSON_ENABLE_STD_STRING
+#define ARDUINOJSON_ENABLE_STD_STRING 0
+#endif
+
+// Arduino doesn't support STL stream
 #ifndef ARDUINOJSON_ENABLE_STD_STREAM
 #define ARDUINOJSON_ENABLE_STD_STREAM 0
 #endif
@@ -37,6 +56,11 @@
 #endif
 #endif
 
+// low value to prevent stack overflow
+#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
+#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
+#endif
+
 #else  // assume this is a computer
 
 // on a computer we have plenty of memory so we can use doubles
@@ -62,6 +86,21 @@
 #endif
 #endif
 
+// on a computer, we can use std::string
+#ifndef ARDUINOJSON_ENABLE_STD_STRING
+#define ARDUINOJSON_ENABLE_STD_STRING 1
+#endif
+
+// on a computer, there is no reason to beleive Arduino String is available
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
+#endif
+
+// PROGMEM is only available on AVR architecture
+#ifndef ARDUINOJSON_ENABLE_PROGMEM
+#define ARDUINOJSON_ENABLE_PROGMEM 0
+#endif
+
 // on a computer, we can assume that the STL is there
 #ifndef ARDUINOJSON_ENABLE_STD_STREAM
 #define ARDUINOJSON_ENABLE_STD_STREAM 1
@@ -72,6 +111,11 @@
 #define ARDUINOJSON_ENABLE_ALIGNMENT 1
 #endif
 
+// on a computer, we should have a lot of space on the stack
+#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
+#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50
+#endif
+
 #endif
 
 #if ARDUINOJSON_USE_LONG_LONG && ARDUINOJSON_USE_INT64

include/ArduinoJson/Internals/BlockJsonBuffer.hpp

@@ -11,12 +11,26 @@
 
 #include <stdlib.h>
 
+#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 {
 namespace Internals {
 class DefaultAllocator {
  public:
-  void* allocate(size_t size) { return malloc(size); }
-  void deallocate(void* pointer) { free(pointer); }
+  void* allocate(size_t size) {
+    return malloc(size);
+  }
+  void deallocate(void* pointer) {
+    free(pointer);
+  }
 };
 
 template <typename TAllocator>
@@ -51,7 +65,6 @@ class BlockJsonBuffer : public JsonBuffer {
     return total;
   }
 
- protected:
   virtual void* alloc(size_t bytes) {
     return canAllocInHead(bytes) ? allocInHead(bytes) : allocInNewBlock(bytes);
   }
@@ -92,3 +105,11 @@ class BlockJsonBuffer : public JsonBuffer {
 };
 }
 }
+
+#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/Internals/Comments.hpp

@@ -9,6 +9,48 @@
 
 namespace ArduinoJson {
 namespace Internals {
-const char *skipSpacesAndComments(const char *ptr);
+inline 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 const char *skipCppStyleComment(const char *ptr) {
+  ptr += 2;
+  for (;;) {
+    if (ptr[0] == '\0' || ptr[0] == '\n') return ptr;
+    ptr++;
+  }
+}
+
+inline const char *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;
+    }
+  }
+}
 }
 }

include/ArduinoJson/Internals/DummyPrint.hpp

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"
 
 namespace ArduinoJson {
 namespace Internals {

include/ArduinoJson/Internals/DynamicStringBuilder.hpp

@@ -7,27 +7,27 @@
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
-#include "../Arduino/String.hpp"
+#include "../Print.hpp"
+#include "StringFuncs.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
 
 // A Print implementation that allows to write in a String
+template <typename TString>
 class DynamicStringBuilder : public Print {
  public:
-  DynamicStringBuilder(String &str) : _str(str) {}
+  DynamicStringBuilder(TString &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);
+    StringFuncs<TString>::append(_str, static_cast<char>(c));
     return 1;
   }
 
  private:
   DynamicStringBuilder &operator=(const DynamicStringBuilder &);
 
-  String &_str;
+  TString &_str;
 };
 }
 }

include/ArduinoJson/Internals/Encoding.hpp

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -16,7 +16,7 @@ class Encoding {
  public:
   // Optimized for code size on a 8-bit AVR
   static char escapeChar(char c) {
-    const char *p = _escapeTable;
+    const char *p = escapeTable(false);
     while (p[0] && p[1] != c) {
       p += 2;
     }
@@ -25,7 +25,7 @@ class Encoding {
 
   // Optimized for code size on a 8-bit AVR
   static char unescapeChar(char c) {
-    const char *p = _escapeTable + 4;
+    const char *p = escapeTable(true);
     for (;;) {
       if (p[0] == '\0') return c;
       if (p[0] == c) return p[1];
@@ -34,7 +34,9 @@ class Encoding {
   }
 
  private:
-  static const char _escapeTable[];
+  static const char *escapeTable(bool excludeIdenticals) {
+    return &"\"\"\\\\b\bf\fn\nr\rt\t"[excludeIdenticals ? 4 : 0];
+  }
 };
 }
 }

include/ArduinoJson/Internals/IndentedPrint.hpp

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -23,7 +23,13 @@ class IndentedPrint : public Print {
     isNewLine = true;
   }
 
-  virtual size_t write(uint8_t);
+  virtual size_t write(uint8_t c) {
+    size_t n = 0;
+    if (isNewLine) n += writeTabs();
+    n += sink->write(c);
+    isNewLine = c == '\n';
+    return n;
+  }
 
   // Adds one level of indentation
   void indent() {
@@ -46,7 +52,11 @@ class IndentedPrint : public Print {
   uint8_t tabSize : 3;
   bool isNewLine : 1;
 
-  size_t writeTabs();
+  size_t writeTabs() {
+    size_t n = 0;
+    for (int i = 0; i < level * tabSize; i++) n += sink->write(' ');
+    return n;
+  }
 
   static const int MAX_LEVEL = 15;    // because it's only 4 bits
   static const int MAX_TAB_SIZE = 7;  // because it's only 3 bits

include/ArduinoJson/Internals/JsonInteger.hpp

@@ -14,10 +14,13 @@ 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

@@ -27,6 +27,12 @@ class JsonParser {
   JsonArray &parseArray();
   JsonObject &parseObject();
 
+  JsonVariant parseVariant() {
+    JsonVariant result;
+    parseAnythingTo(&result);
+    return result;
+  }
+
  private:
   bool skip(char charToSkip);
 
@@ -38,6 +44,19 @@ class JsonParser {
   inline bool parseObjectTo(JsonVariant *destination);
   inline bool parseStringTo(JsonVariant *destination);
 
+  static inline bool isInRange(char c, char min, char max) {
+    return min <= c && c <= max;
+  }
+
+  static inline bool isLetterOrNumber(char c) {
+    return isInRange(c, '0', '9') || isInRange(c, 'a', 'z') ||
+           isInRange(c, 'A', 'Z') || c == '+' || c == '-' || c == '.';
+  }
+
+  static inline bool isQuote(char c) {
+    return c == '\'' || c == '\"';
+  }
+
   JsonBuffer *_buffer;
   const char *_readPtr;
   char *_writePtr;

include/ArduinoJson/Internals/JsonParser.ipp

@@ -5,18 +5,12 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
-#include "../../include/ArduinoJson/Internals/JsonParser.hpp"
+#pragma once
 
-#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"
+#include "Comments.hpp"
+#include "JsonParser.hpp"
 
-using namespace ArduinoJson;
-using namespace ArduinoJson::Internals;
-
-bool JsonParser::skip(char charToSkip) {
+inline bool ArduinoJson::Internals::JsonParser::skip(char charToSkip) {
   const char *ptr = skipSpacesAndComments(_readPtr);
   if (*ptr != charToSkip) return false;
   ptr++;
@@ -24,7 +18,8 @@ bool JsonParser::skip(char charToSkip) {
   return true;
 }
 
-bool JsonParser::parseAnythingTo(JsonVariant *destination) {
+inline bool ArduinoJson::Internals::JsonParser::parseAnythingTo(
+    JsonVariant *destination) {
   if (_nestingLimit == 0) return false;
   _nestingLimit--;
   bool success = parseAnythingToUnsafe(destination);
@@ -32,7 +27,8 @@ bool JsonParser::parseAnythingTo(JsonVariant *destination) {
   return success;
 }
 
-inline bool JsonParser::parseAnythingToUnsafe(JsonVariant *destination) {
+inline bool ArduinoJson::Internals::JsonParser::parseAnythingToUnsafe(
+    JsonVariant *destination) {
   _readPtr = skipSpacesAndComments(_readPtr);
 
   switch (*_readPtr) {
@@ -47,7 +43,8 @@ inline bool JsonParser::parseAnythingToUnsafe(JsonVariant *destination) {
   }
 }
 
-JsonArray &JsonParser::parseArray() {
+inline ArduinoJson::JsonArray &
+ArduinoJson::Internals::JsonParser::parseArray() {
   // Create an empty array
   JsonArray &array = _buffer->createArray();
 
@@ -78,7 +75,8 @@ ERROR_NO_MEMORY:
   return JsonArray::invalid();
 }
 
-bool JsonParser::parseArrayTo(JsonVariant *destination) {
+inline bool ArduinoJson::Internals::JsonParser::parseArrayTo(
+    JsonVariant *destination) {
   JsonArray &array = parseArray();
   if (!array.success()) return false;
 
@@ -86,7 +84,8 @@ bool JsonParser::parseArrayTo(JsonVariant *destination) {
   return true;
 }
 
-JsonObject &JsonParser::parseObject() {
+inline ArduinoJson::JsonObject &
+ArduinoJson::Internals::JsonParser::parseObject() {
   // Create an empty object
   JsonObject &object = _buffer->createObject();
 
@@ -124,7 +123,8 @@ ERROR_NO_MEMORY:
   return JsonObject::invalid();
 }
 
-bool JsonParser::parseObjectTo(JsonVariant *destination) {
+inline bool ArduinoJson::Internals::JsonParser::parseObjectTo(
+    JsonVariant *destination) {
   JsonObject &object = parseObject();
   if (!object.success()) return false;
 
@@ -132,18 +132,7 @@ bool JsonParser::parseObjectTo(JsonVariant *destination) {
   return true;
 }
 
-static inline bool isInRange(char c, char min, char max) {
-  return min <= c && c <= max;
-}
-
-static inline bool isLetterOrNumber(char c) {
-  return isInRange(c, '0', '9') || isInRange(c, 'a', 'z') ||
-         isInRange(c, 'A', 'Z') || c == '-' || c == '.';
-}
-
-static inline bool isQuote(char c) { return c == '\'' || c == '\"'; }
-
-const char *JsonParser::parseString() {
+inline const char *ArduinoJson::Internals::JsonParser::parseString() {
   const char *readPtr = _readPtr;
   char *writePtr = _writePtr;
 
@@ -188,14 +177,15 @@ const char *JsonParser::parseString() {
   return startPtr;
 }
 
-bool JsonParser::parseStringTo(JsonVariant *destination) {
+inline bool ArduinoJson::Internals::JsonParser::parseStringTo(
+    JsonVariant *destination) {
   bool hasQuotes = isQuote(_readPtr[0]);
   const char *value = parseString();
   if (value == NULL) return false;
   if (hasQuotes) {
     *destination = value;
   } else {
-    *destination = Unparsed(value);
+    *destination = RawJson(value);
   }
   return true;
 }

include/ArduinoJson/Internals/JsonPrintable.hpp

@@ -8,12 +8,14 @@
 #pragma once
 
 #include "../Configuration.hpp"
+#include "../TypeTraits/EnableIf.hpp"
 #include "DummyPrint.hpp"
+#include "DynamicStringBuilder.hpp"
 #include "IndentedPrint.hpp"
+#include "JsonSerializer.hpp"
 #include "JsonWriter.hpp"
 #include "Prettyfier.hpp"
 #include "StaticStringBuilder.hpp"
-#include "DynamicStringBuilder.hpp"
 
 #if ARDUINOJSON_ENABLE_STD_STREAM
 #include "StreamPrintAdapter.hpp"
@@ -31,7 +33,7 @@ class JsonPrintable {
  public:
   size_t printTo(Print &print) const {
     JsonWriter writer(print);
-    downcast().writeTo(writer);
+    JsonSerializer::serialize(downcast(), writer);
     return writer.bytesWritten();
   }
 
@@ -48,8 +50,10 @@ class JsonPrintable {
     return printTo(sb);
   }
 
-  size_t printTo(String &str) const {
-    DynamicStringBuilder sb(str);
+  template <typename TString>
+  typename TypeTraits::EnableIf<StringFuncs<TString>::has_append, size_t>::type
+  printTo(TString &str) const {
+    DynamicStringBuilder<TString> sb(str);
     return printTo(sb);
   }
 
@@ -68,8 +72,10 @@ class JsonPrintable {
     return prettyPrintTo(indentedPrint);
   }
 
-  size_t prettyPrintTo(String &str) const {
-    DynamicStringBuilder sb(str);
+  template <typename TString>
+  typename TypeTraits::EnableIf<StringFuncs<TString>::has_append, size_t>::type
+  prettyPrintTo(TString &str) const {
+    DynamicStringBuilder<TString> sb(str);
     return prettyPrintTo(sb);
   }
 
@@ -84,7 +90,9 @@ class JsonPrintable {
   }
 
  private:
-  const T &downcast() const { return *static_cast<const T *>(this); }
+  const T &downcast() const {
+    return *static_cast<const T *>(this);
+  }
 };
 
 #if ARDUINOJSON_ENABLE_STD_STREAM

include/ArduinoJson/Internals/JsonSerializer.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 "JsonWriter.hpp"
+
+namespace ArduinoJson {
+
+class JsonArray;
+class JsonArraySubscript;
+class JsonObject;
+template <typename TKey>
+class JsonObjectSubscript;
+class JsonVariant;
+
+namespace Internals {
+
+class JsonSerializer {
+ public:
+  static void serialize(const JsonArray &, JsonWriter &);
+  static void serialize(const JsonArraySubscript &, JsonWriter &);
+  static void serialize(const JsonObject &, JsonWriter &);
+  template <typename TKey>
+  static void serialize(const JsonObjectSubscript<TKey> &, JsonWriter &);
+  static void serialize(const JsonVariant &, JsonWriter &);
+};
+}
+}

include/ArduinoJson/Internals/JsonSerializer.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 "../JsonArraySubscript.hpp"
+#include "../JsonObject.hpp"
+#include "../JsonObjectSubscript.hpp"
+#include "../JsonVariant.hpp"
+#include "JsonSerializer.hpp"
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonArray& array, JsonWriter& writer) {
+  writer.beginArray();
+
+  JsonArray::const_iterator it = array.begin();
+  while (it != array.end()) {
+    serialize(*it, writer);
+
+    ++it;
+    if (it == array.end()) break;
+
+    writer.writeComma();
+  }
+
+  writer.endArray();
+}
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonArraySubscript& arraySubscript, JsonWriter& writer) {
+  serialize(arraySubscript.as<JsonVariant>(), writer);
+}
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonObject& object, JsonWriter& writer) {
+  writer.beginObject();
+
+  JsonObject::const_iterator it = object.begin();
+  while (it != object.end()) {
+    writer.writeString(it->key);
+    writer.writeColon();
+    serialize(it->value, writer);
+
+    ++it;
+    if (it == object.end()) break;
+
+    writer.writeComma();
+  }
+
+  writer.endObject();
+}
+
+template <typename TKey>
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonObjectSubscript<TKey>& objectSubscript, JsonWriter& writer) {
+  serialize(objectSubscript.template as<JsonVariant>(), writer);
+}
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonVariant& variant, JsonWriter& writer) {
+  switch (variant._type) {
+    case JSON_UNDEFINED:
+      return;
+
+    case JSON_ARRAY:
+      serialize(*variant._content.asArray, writer);
+      return;
+
+    case JSON_OBJECT:
+      serialize(*variant._content.asObject, writer);
+      return;
+
+    case JSON_STRING:
+      writer.writeString(variant._content.asString);
+      return;
+
+    case JSON_UNPARSED:
+      writer.writeRaw(variant._content.asString);
+      return;
+
+    case JSON_NEGATIVE_INTEGER:
+      writer.writeRaw('-');
+    case JSON_POSITIVE_INTEGER:
+      writer.writeInteger(variant._content.asInteger);
+      return;
+
+    case JSON_BOOLEAN:
+      writer.writeBoolean(variant._content.asInteger != 0);
+      return;
+
+    default:
+      uint8_t decimals =
+          static_cast<uint8_t>(variant._type - JSON_FLOAT_0_DECIMALS);
+      writer.writeFloat(variant._content.asFloat, decimals);
+  }
+}

include/ArduinoJson/Internals/JsonVariantAs.hpp

@@ -0,0 +1,45 @@
+// 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 {
+
+// A metafunction that returns the type of the value returned by
+// JsonVariant::as<T>()
+template <typename T>
+struct JsonVariantAs {
+  typedef T type;
+};
+
+template <>
+struct JsonVariantAs<char*> {
+  typedef const char* type;
+};
+
+template <>
+struct JsonVariantAs<JsonArray> {
+  typedef JsonArray& type;
+};
+
+template <>
+struct JsonVariantAs<const JsonArray> {
+  typedef const JsonArray& type;
+};
+
+template <>
+struct JsonVariantAs<JsonObject> {
+  typedef JsonObject& type;
+};
+
+template <>
+struct JsonVariantAs<const JsonObject> {
+  typedef const JsonObject& type;
+};
+}
+}

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -20,11 +20,11 @@ namespace Internals {
 // A union that defines the actual content of a JsonVariant.
 // The enum JsonVariantType determines which member is in use.
 union JsonVariantContent {
-  JsonFloat asFloat;      // used for double and float
-  JsonInteger 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
+  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/JsonVariantDefault.hpp

@@ -8,17 +8,19 @@
 #pragma once
 
 namespace ArduinoJson {
-namespace TypeTraits {
+namespace Internals {
 
-// A meta-function that returns true if T is a reference
 template <typename T>
-struct IsReference {
-  static const bool value = false;
+struct JsonVariantDefault {
+  static T get() {
+    return T();
+  }
 };
 
 template <typename T>
-struct IsReference<T&> {
-  static const bool value = true;
-};
+struct JsonVariantDefault<const T> : JsonVariantDefault<T> {};
+
+template <typename T>
+struct JsonVariantDefault<T&> : JsonVariantDefault<T> {};
 }
 }

include/ArduinoJson/Internals/JsonVariantType.hpp

@@ -16,13 +16,15 @@ namespace Internals {
 // Enumerated type to know the current type of a JsonVariant.
 // The value determines which member of JsonVariantContent is used.
 enum JsonVariantType {
-  JSON_UNDEFINED,  // the JsonVariant has not been initialized
-  JSON_UNPARSED,   // the JsonVariant contains an unparsed string
-  JSON_STRING,     // the JsonVariant stores a const char*
-  JSON_BOOLEAN,    // the JsonVariant stores a bool
-  JSON_INTEGER,    // the JsonVariant stores an integer
-  JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
-  JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject
+  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 float values
   // Multiple values are used for double, depending on the number of decimal

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -7,9 +7,11 @@
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
+#include "../Polyfills/attributes.hpp"
+#include "../Polyfills/math.hpp"
+#include "../Polyfills/normalize.hpp"
+#include "../Print.hpp"
 #include "Encoding.hpp"
-#include "ForceInline.hpp"
 #include "JsonFloat.hpp"
 #include "JsonInteger.hpp"
 
@@ -30,56 +32,153 @@ 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() const { 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) { write(value ? "true" : "false"); }
+  void writeBoolean(bool value) {
+    writeRaw(value ? "true" : "false");
+  }
 
   void writeString(const char *value) {
     if (!value) {
-      write("null");
+      writeRaw("null");
     } else {
-      write('\"');
+      writeRaw('\"');
       while (*value) writeChar(*value++);
-      write('\"');
+      writeRaw('\"');
     }
   }
 
   void writeChar(char c) {
     char specialChar = Encoding::escapeChar(c);
     if (specialChar) {
-      write('\\');
-      write(specialChar);
+      writeRaw('\\');
+      writeRaw(specialChar);
     } else {
-      write(c);
+      writeRaw(c);
     }
   }
 
-  void writeInteger(JsonInteger value) { _length += _sink.print(value); }
+  void writeFloat(JsonFloat value, uint8_t digits = 2) {
+    if (Polyfills::isNaN(value)) return writeRaw("NaN");
 
-  void writeFloat(JsonFloat value, uint8_t decimals) {
-    _length += _sink.print(value, decimals);
+    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 up last digit (so that print(1.999, 2) prints as "2.00")
+    value += getRoundingBias(digits);
+
+    // 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) {
+      // Extract digit
+      remainder *= 10.0;
+      char currentDigit = char(remainder);
+      remainder -= static_cast<JsonFloat>(currentDigit);
+
+      // Print
+      writeRaw(char('0' + currentDigit));
+    }
+
+    if (powersOf10 < 0) {
+      writeRaw("e-");
+      writeInteger(-powersOf10);
+    }
+
+    if (powersOf10 > 0) {
+      writeRaw('e');
+      writeInteger(powersOf10);
+    }
   }
 
-  void writeRaw(const char *s) { return write(s); }
+  void writeInteger(JsonUInt value) {
+    char buffer[22];
+    char *ptr = buffer + sizeof(buffer) - 1;
+
+    *ptr = 0;
+    do {
+      *--ptr = static_cast<char>(value % 10 + '0');
+      value /= 10;
+    } while (value);
+
+    writeRaw(ptr);
+  }
+
+  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); }
-  FORCE_INLINE void write(const char *s) { _length += _sink.print(s); }
-
   Print &_sink;
   size_t _length;
 
  private:
   JsonWriter &operator=(const JsonWriter &);  // cannot be assigned
+
+  static JsonFloat getLastDigit(uint8_t digits) {
+    // Designed as a compromise between code size and speed
+    switch (digits) {
+      case 0:
+        return 1e-0;
+      case 1:
+        return 1e-1;
+      case 2:
+        return 1e-2;
+      case 3:
+        return 1e-3;
+      default:
+        return getLastDigit(uint8_t(digits - 4)) * 1e-4;
+    }
+  }
+
+  FORCE_INLINE static JsonFloat getRoundingBias(uint8_t digits) {
+    return 0.5 * getLastDigit(digits);
+  }
 };
 }
 }

include/ArduinoJson/Internals/List.hpp

@@ -36,21 +36,56 @@ class List {
   // Would return false in the following situation:
   // - the memory allocation failed (StaticJsonBuffer was too small)
   // - the JSON parsing failed
-  bool success() const { return _buffer != NULL; }
+  bool success() const {
+    return _buffer != NULL;
+  }
 
   // Returns the numbers of elements in the list.
   // For a JsonObject, it would return the number of key-value pairs
-  size_t size() const;
+  size_t size() const {
+    size_t nodeCount = 0;
+    for (node_type *node = _firstNode; node; node = node->next) nodeCount++;
+    return nodeCount;
+  }
 
-  iterator begin() { return iterator(_firstNode); }
-  iterator end() { return iterator(NULL); }
+  iterator begin() {
+    return iterator(_firstNode);
+  }
+  iterator end() {
+    return iterator(NULL);
+  }
 
-  const_iterator begin() const { return const_iterator(_firstNode); }
-  const_iterator end() const { return const_iterator(NULL); }
+  const_iterator begin() const {
+    return const_iterator(_firstNode);
+  }
+  const_iterator end() const {
+    return const_iterator(NULL);
+  }
 
  protected:
-  node_type *addNewNode();
-  void removeNode(node_type *nodeToRemove);
+  node_type *addNewNode() {
+    node_type *newNode = new (_buffer) node_type();
+
+    if (_firstNode) {
+      node_type *lastNode = _firstNode;
+      while (lastNode->next) lastNode = lastNode->next;
+      lastNode->next = newNode;
+    } else {
+      _firstNode = newNode;
+    }
+
+    return newNode;
+  }
+
+  void removeNode(node_type *nodeToRemove) {
+    if (!nodeToRemove) return;
+    if (nodeToRemove == _firstNode) {
+      _firstNode = nodeToRemove->next;
+    } else {
+      for (node_type *node = _firstNode; node; node = node->next)
+        if (node->next == nodeToRemove) node->next = nodeToRemove->next;
+    }
+  }
 
   JsonBuffer *_buffer;
   node_type *_firstNode;

include/ArduinoJson/Internals/Parse.hpp

@@ -29,6 +29,11 @@ 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);
@@ -39,6 +44,11 @@ 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
@@ -46,6 +56,11 @@ 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/Prettyfier.hpp

@@ -20,24 +20,107 @@ class Prettyfier : public Print {
     _inString = false;
   }
 
-  virtual size_t write(uint8_t);
+  virtual size_t write(uint8_t c) {
+    size_t n = _inString ? handleStringChar(c) : handleMarkupChar(c);
+    _previousChar = c;
+    return n;
+  }
 
  private:
   Prettyfier& operator=(const Prettyfier&);  // cannot be assigned
 
-  bool inEmptyBlock() { return _previousChar == '{' || _previousChar == '['; }
+  bool inEmptyBlock() {
+    return _previousChar == '{' || _previousChar == '[';
+  }
 
-  size_t handleStringChar(uint8_t);
-  size_t handleMarkupChar(uint8_t);
+  size_t handleStringChar(uint8_t c) {
+    bool isQuote = c == '"' && _previousChar != '\\';
 
-  size_t handleBlockClose(uint8_t);
-  size_t handleBlockOpen(uint8_t);
-  size_t handleColon();
-  size_t handleComma();
-  size_t handleQuoteOpen();
-  size_t handleNormalChar(uint8_t);
-  size_t indentIfNeeded();
-  size_t unindentIfNeeded();
+    if (isQuote) _inString = false;
+
+    return _sink.write(c);
+  }
+
+  size_t handleMarkupChar(uint8_t c) {
+    switch (c) {
+      case '{':
+      case '[':
+        return writeBlockOpen(c);
+
+      case '}':
+      case ']':
+        return writeBlockClose(c);
+
+      case ':':
+        return writeColon();
+
+      case ',':
+        return writeComma();
+
+      case '"':
+        return writeQuoteOpen();
+
+      default:
+        return writeNormalChar(c);
+    }
+  }
+
+  size_t writeBlockClose(uint8_t c) {
+    size_t n = 0;
+    n += unindentIfNeeded();
+    n += _sink.write(c);
+    return n;
+  }
+
+  size_t writeBlockOpen(uint8_t c) {
+    size_t n = 0;
+    n += indentIfNeeded();
+    n += _sink.write(c);
+    return n;
+  }
+
+  size_t writeColon() {
+    size_t n = 0;
+    n += _sink.write(':');
+    n += _sink.write(' ');
+    return n;
+  }
+
+  size_t writeComma() {
+    size_t n = 0;
+    n += _sink.write(',');
+    n += _sink.println();
+    return n;
+  }
+
+  size_t writeQuoteOpen() {
+    _inString = true;
+    size_t n = 0;
+    n += indentIfNeeded();
+    n += _sink.write('"');
+    return n;
+  }
+
+  size_t writeNormalChar(uint8_t c) {
+    size_t n = 0;
+    n += indentIfNeeded();
+    n += _sink.write(c);
+    return n;
+  }
+
+  size_t indentIfNeeded() {
+    if (!inEmptyBlock()) return 0;
+
+    _sink.indent();
+    return _sink.println();
+  }
+
+  size_t unindentIfNeeded() {
+    if (inEmptyBlock()) return 0;
+
+    _sink.unindent();
+    return _sink.println();
+  }
 
   uint8_t _previousChar;
   IndentedPrint& _sink;

include/ArduinoJson/Internals/StaticStringBuilder.hpp

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -20,7 +20,13 @@ class StaticStringBuilder : public Print {
     buffer[0] = '\0';
   }
 
-  virtual size_t write(uint8_t c);
+  virtual size_t write(uint8_t c) {
+    if (length >= capacity) return 0;
+
+    buffer[length++] = c;
+    buffer[length] = '\0';
+    return 1;
+  }
 
  private:
   char *buffer;

include/ArduinoJson/Internals/StreamPrintAdapter.hpp

@@ -11,7 +11,7 @@
 
 #if ARDUINOJSON_ENABLE_STD_STREAM
 
-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"
 
 #include <ostream>
 

include/ArduinoJson/Internals/StringFuncs.hpp

@@ -0,0 +1,121 @@
+// 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_ARDUINO_STRING
+#include <WString.h>
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+#include <string>
+#endif
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TString>
+struct StringFuncs {};
+
+template <typename TString>
+struct StringFuncs<const TString> : StringFuncs<TString> {};
+
+template <typename TString>
+struct StringFuncs<TString&> : StringFuncs<TString> {};
+
+struct CharPtrFuncs {
+  static bool equals(const char* str, const char* expected) {
+    return strcmp(str, expected) == 0;
+  }
+
+  template <typename Buffer>
+  static char* duplicate(const char* str, Buffer* buffer) {
+    if (!str) return NULL;
+    size_t size = strlen(str) + 1;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy(dup, str, size);
+    return static_cast<char*>(dup);
+  }
+
+  static const bool has_append = false;
+  static const bool has_equals = true;
+  static const bool should_duplicate = false;
+};
+
+template <>
+struct StringFuncs<const char*> : CharPtrFuncs {};
+
+template <>
+struct StringFuncs<char*> : CharPtrFuncs {};
+
+template <size_t N>
+struct StringFuncs<char[N]> : CharPtrFuncs {};
+
+template <size_t N>
+struct StringFuncs<const char[N]> : CharPtrFuncs {};
+
+template <typename TString>
+struct StdStringFuncs {
+  template <typename Buffer>
+  static char* duplicate(const TString& str, Buffer* buffer) {
+    if (!str.c_str()) return NULL;  // <- Arduino string can return NULL
+    size_t size = str.length() + 1;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy(dup, str.c_str(), size);
+    return static_cast<char*>(dup);
+  }
+
+  static bool equals(const TString& str, const char* expected) {
+    return str == expected;
+  }
+
+  static void append(TString& str, char c) {
+    str += c;
+  }
+
+  static const bool has_append = true;
+  static const bool has_equals = true;
+  static const bool should_duplicate = true;
+};
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+template <>
+struct StringFuncs<String> : StdStringFuncs<String> {};
+template <>
+struct StringFuncs<StringSumHelper> : StdStringFuncs<StringSumHelper> {};
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+template <>
+struct StringFuncs<std::string> : StdStringFuncs<std::string> {};
+#endif
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+template <>
+struct StringFuncs<const __FlashStringHelper*> {
+  static bool equals(const __FlashStringHelper* str, const char* expected) {
+    return strcmp_P((PGM_P)str, expected) == 0;
+  }
+
+  template <typename Buffer>
+  static char* duplicate(const __FlashStringHelper* str, Buffer* buffer) {
+    if (!str) return NULL;
+    size_t size = strlen_P((PGM_P)str) + 1;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy_P(dup, (PGM_P)str, size);
+    return static_cast<char*>(dup);
+  }
+
+  static const bool has_append = false;
+  static const bool has_equals = true;
+  static const bool should_duplicate = true;
+};
+#endif
+}
+}

include/ArduinoJson/Internals/ValueSetter.hpp

@@ -0,0 +1,41 @@
+// 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 "../JsonVariant.hpp"
+#include "../TypeTraits/EnableIf.hpp"
+#include "StringFuncs.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TSource, typename Enable = void>
+struct ValueSetter {
+  template <typename TDestination>
+  static bool set(JsonBuffer*, TDestination& destination,
+                  const TSource& source) {
+    destination = source;
+    return true;
+  }
+};
+
+template <typename TSource>
+struct ValueSetter<TSource, typename TypeTraits::EnableIf<
+                                StringFuncs<TSource>::should_duplicate>::type> {
+  template <typename TDestination>
+  static bool set(JsonBuffer* buffer, TDestination& destination,
+                  const TSource& source) {
+    const char* copy = buffer->strdup(source);
+    if (!copy) return false;
+    destination = copy;
+    return true;
+  }
+};
+}
+}

include/ArduinoJson/JsonArray.hpp

@@ -11,10 +11,12 @@
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
+#include "Internals/StringFuncs.hpp"
+#include "Internals/ValueSetter.hpp"
 #include "JsonVariant.hpp"
+#include "TypeTraits/ConstRefOrConstPtr.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.
@@ -40,15 +42,6 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
                   public Internals::List<JsonVariant>,
                   public Internals::JsonBufferAllocated {
  public:
-  // 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;
-  };
-
   // Create an empty JsonArray attached to the specified JsonBuffer.
   // You should not call this constructor directly.
   // Instead, use JsonBuffer::createArray() or JsonBuffer::parseArray().
@@ -56,10 +49,12 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
       : Internals::List<JsonVariant>(buffer) {}
 
   // Gets the value at the specified index
-  FORCE_INLINE JsonVariant operator[](size_t index) const;
+  JsonVariant operator[](size_t index) const {
+    return get<JsonVariant>(index);
+  }
 
   // Gets or sets the value at specified index
-  FORCE_INLINE JsonArraySubscript operator[](size_t index);
+  JsonArraySubscript operator[](size_t index);
 
   // Adds the specified value at the end of the array.
   //
@@ -71,31 +66,24 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   // bool add(float value);
   // bool add(double value);
   // bool add(const char*);
-  template <typename T>
-  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 char[]);
+  // bool add(const char[N]);
+  // bool add(RawJson);
+  // bool add(const std::string&)
   // 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(const T &value) {
+    // reduce the number of template function instanciation to reduce code size
+    return addNodeImpl<typename TypeTraits::ConstRefOrConstPtr<T>::type>(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));
+  bool add(T value, uint8_t decimals) {
+    return add(JsonVariant(value, decimals));
   }
 
   // Sets the value at specified index.
@@ -104,43 +92,41 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   // 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 std::string&)
   // 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, const T &value) {
+    // reduce the number of template function instanciation to reduce code size
+    return setNodeAt<typename TypeTraits::ConstRefOrConstPtr<T>::type>(index,
+                                                                       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));
+  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                bool>::type
+  set(size_t index, T value, uint8_t decimals) {
+    return set(index, JsonVariant(value, decimals));
   }
 
-  // Gets the value at the specified index.
-  FORCE_INLINE JsonVariant get(size_t index) const;
-
   // Gets the value at the specified index.
   template <typename T>
-  FORCE_INLINE T get(size_t index) const;
+  typename Internals::JsonVariantAs<T>::type get(size_t index) const {
+    node_type *node = getNodeAt(index);
+    return node ? node->content.as<T>()
+                : Internals::JsonVariantDefault<T>::get();
+    ;
+  }
 
   // Check the type of the value at specified index.
   template <typename T>
-  FORCE_INLINE bool is(size_t index) const;
+  bool is(size_t index) const {
+    node_type *node = getNodeAt(index);
+    return node ? node->content.is<T>() : false;
+  }
 
   // Creates a JsonArray and adds a reference at the end of the array.
   // It's a shortcut for JsonBuffer::createArray() and JsonArray::add()
@@ -151,31 +137,94 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   JsonObject &createNestedObject();
 
   // Removes element at specified index.
-  void removeAt(size_t index);
+  void removeAt(size_t index) {
+    removeNode(getNodeAt(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.
-  static JsonArray &invalid() { return _invalid; }
+  static JsonArray &invalid() {
+    static JsonArray instance(NULL);
+    return instance;
+  }
 
-  // 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:
-  node_type *getNodeAt(size_t index) const;
+  node_type *getNodeAt(size_t index) const {
+    node_type *node = _firstNode;
+    while (node && index--) node = node->next;
+    return node;
+  }
 
-  template <typename TValue>
-  bool setNodeAt(size_t index, TValue value);
+  template <typename TValueRef>
+  bool setNodeAt(size_t index, TValueRef value) {
+    node_type *node = getNodeAt(index);
+    if (!node) return false;
 
-  template <typename TValue>
-  bool addNode(TValue);
+    return Internals::ValueSetter<TValueRef>::set(_buffer, node->content,
+                                                  value);
+  }
 
-  template <typename T>
-  FORCE_INLINE bool setNodeValue(node_type *, T value);
+  template <typename TValueRef>
+  bool addNodeImpl(TValueRef value) {
+    node_type *node = addNewNode();
+    if (!node) return false;
 
-  // The instance returned by JsonArray::invalid()
-  static JsonArray _invalid;
+    return Internals::ValueSetter<TValueRef>::set(_buffer, node->content,
+                                                  value);
+  }
 };
 }
-
-#include "JsonArray.ipp"

include/ArduinoJson/JsonArray.ipp

@@ -8,76 +8,36 @@
 #pragma once
 
 #include "JsonArray.hpp"
-#include "JsonObject.hpp"
 #include "JsonArraySubscript.hpp"
+#include "JsonObject.hpp"
 
 namespace ArduinoJson {
 
-inline JsonArraySubscript JsonArray::operator[](size_t index) {
-  return JsonArraySubscript(*this, index);
+inline JsonVariant::JsonVariant(const JsonArray &array) {
+  if (array.success()) {
+    _type = Internals::JSON_ARRAY;
+    _content.asArray = const_cast<JsonArray *>(&array);
+  } else {
+    _type = Internals::JSON_UNDEFINED;
+  }
 }
 
-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;
+inline JsonVariant::JsonVariant(const JsonObject &object) {
+  if (object.success()) {
+    _type = Internals::JSON_OBJECT;
+    _content.asObject = const_cast<JsonObject *>(&object);
+  } else {
+    _type = Internals::JSON_UNDEFINED;
+  }
 }
 
+namespace Internals {
 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::invalid<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::invalid<JsonArray &>() {
-  return JsonArray::invalid();
-}
-
-template <>
-inline JsonArray const &JsonVariant::invalid<JsonArray const &>() {
-  return JsonArray::invalid();
+struct JsonVariantDefault<JsonArray> {
+  static JsonArray &get() {
+    return JsonArray::invalid();
+  }
+};
 }
 
 inline JsonArray &JsonVariant::asArray() const {
@@ -92,10 +52,11 @@ inline JsonArray &JsonArray::createNestedArray() {
   return array;
 }
 
-inline JsonArray &JsonObject::createNestedArray(JsonObjectKey key) {
+template <typename TString>
+inline JsonArray &JsonObject::createNestedArray(const TString &key) {
   if (!_buffer) return JsonArray::invalid();
   JsonArray &array = _buffer->createArray();
-  setNodeAt<const JsonVariant &>(key, array);
+  set(key, array);
   return array;
 }
 }

include/ArduinoJson/JsonArraySubscript.hpp

@@ -21,33 +21,23 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
   FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
       : _array(array), _index(index) {}
 
-  JsonArraySubscript& operator=(const JsonArraySubscript& src) {
-    _array.set<const JsonVariant&>(_index, src);
+  FORCE_INLINE JsonArraySubscript& operator=(const JsonArraySubscript& src) {
+    _array.set(_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));
+  FORCE_INLINE JsonArraySubscript& operator=(const T& src) {
+    _array.set(_index, 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 bool success() const { return _index < _array.size(); }
-
-  FORCE_INLINE operator JsonVariant() const { return _array.get(_index); }
-
   template <typename T>
-  FORCE_INLINE T as() const {
+  FORCE_INLINE typename Internals::JsonVariantAs<T>::type as() const {
     return _array.get<T>(_index);
   }
 
@@ -56,12 +46,8 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
     return _array.is<T>(_index);
   }
 
-  void writeTo(Internals::JsonWriter& writer) const {
-    _array.get(_index).writeTo(writer);
-  }
-
   template <typename TValue>
-  void set(TValue value) {
+  FORCE_INLINE void set(const TValue& value) {
     _array.set(_index, value);
   }
 
@@ -77,6 +63,16 @@ inline std::ostream& operator<<(std::ostream& os,
 }
 #endif
 
+inline JsonArraySubscript JsonArray::operator[](size_t index) {
+  return JsonArraySubscript(*this, index);
+}
+
+template <typename TImplem>
+inline const JsonArraySubscript JsonVariantBase<TImplem>::operator[](
+    int index) const {
+  return asArray()[index];
+}
+
 }  // namespace ArduinoJson
 
 #ifdef _MSC_VER

include/ArduinoJson/JsonBuffer.hpp

@@ -11,12 +11,15 @@
 #include <stdint.h>  // for uint8_t
 #include <string.h>
 
-#include "Arduino/String.hpp"
 #include "JsonVariant.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
 
@@ -54,51 +57,57 @@ class JsonBuffer {
   // writable
   // because the parser will insert null-terminators and replace escaped chars.
   //
-  // The second argument set the nesting limit (see comment on DEFAULT_LIMIT)
+  // The second argument set the nesting limit
   //
   // Returns a reference to the new JsonObject or JsonObject::invalid() if the
   // allocation fails.
-  JsonArray &parseArray(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+  JsonArray &parseArray(
+      char *json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_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) {
+  template <typename TString>
+  JsonArray &parseArray(const TString &json,
+                        uint8_t nesting = ARDUINOJSON_DEFAULT_NESTING_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
   // writable
   // because the parser will insert null-terminators and replace escaped chars.
   //
-  // The second argument set the nesting limit (see comment on DEFAULT_LIMIT)
+  // The second argument set the nesting limit
   //
   // Returns a reference to the new JsonObject or JsonObject::invalid() if the
   // allocation fails.
-  JsonObject &parseObject(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+  JsonObject &parseObject(
+      char *json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_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) {
+  template <typename TString>
+  JsonObject &parseObject(const TString &json,
+                          uint8_t nesting = ARDUINOJSON_DEFAULT_NESTING_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 = ARDUINOJSON_DEFAULT_NESTING_LIMIT);
+
+  // With this overload, the JsonBuffer will make a copy of the string
+  template <typename TString>
+  JsonVariant parse(const TString &json,
+                    uint8_t nesting = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return parse(strdup(json), nesting);
   }
 
   // Duplicate a string
-  char *strdup(const char *src) {
-    return src ? strdup(src, strlen(src)) : NULL;
+  template <typename TString>
+  char *strdup(const TString &src) {
+    return Internals::StringFuncs<TString>::duplicate(src, this);
   }
-  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.
@@ -114,23 +123,13 @@ class JsonBuffer {
     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
-  // 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
-  // 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/JsonBuffer.ipp

@@ -0,0 +1,38 @@
+// 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/JsonParser.hpp"
+
+inline ArduinoJson::JsonArray &ArduinoJson::JsonBuffer::createArray() {
+  JsonArray *ptr = new (this) JsonArray(this);
+  return ptr ? *ptr : JsonArray::invalid();
+}
+
+inline ArduinoJson::JsonObject &ArduinoJson::JsonBuffer::createObject() {
+  JsonObject *ptr = new (this) JsonObject(this);
+  return ptr ? *ptr : JsonObject::invalid();
+}
+
+inline ArduinoJson::JsonArray &ArduinoJson::JsonBuffer::parseArray(
+    char *json, uint8_t nestingLimit) {
+  Internals::JsonParser parser(this, json, nestingLimit);
+  return parser.parseArray();
+}
+
+inline ArduinoJson::JsonObject &ArduinoJson::JsonBuffer::parseObject(
+    char *json, uint8_t nestingLimit) {
+  Internals::JsonParser parser(this, json, nestingLimit);
+  return parser.parseObject();
+}
+
+inline ArduinoJson::JsonVariant ArduinoJson::JsonBuffer::parse(
+    char *json, uint8_t nestingLimit) {
+  Internals::JsonParser parser(this, json, nestingLimit);
+  return parser.parseVariant();
+}

include/ArduinoJson/JsonObject.hpp

@@ -7,15 +7,16 @@
 
 #pragma once
 
-#include "Arduino/String.hpp"
 #include "Internals/JsonBufferAllocated.hpp"
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
+#include "Internals/StringFuncs.hpp"
+#include "Internals/ValueSetter.hpp"
 #include "JsonPair.hpp"
+#include "TypeTraits/ConstRefOrConstPtr.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.
@@ -40,27 +41,20 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
                    public Internals::List<JsonPair>,
                    public Internals::JsonBufferAllocated {
  public:
-  // A meta-function that returns true if type T can be used in
-  // JsonObject::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;
-  };
-
   // 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) {}
+  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);
+  template <typename TString>
+  JsonObjectSubscript<TString> operator[](const TString& key);
 
   // Gets the value associated with the specified key.
-  FORCE_INLINE JsonVariant operator[](JsonObjectKey key) const;
+  template <typename TString>
+  JsonVariant operator[](const TString& key) const {
+    return get<JsonVariant>(key);
+  }
 
   // Sets the specified key with the specified value.
   // bool set(TKey key, bool value);
@@ -71,83 +65,104 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   // bool set(TKey key, float value);
   // bool set(TKey key, double value);
   // bool set(TKey key, const char* 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(TKey key, RawJson 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));
+  template <typename TValue, typename TString>
+  bool set(const TString& key, const TValue& value) {
+    // reduce the number of template function instanciation to reduce code size
+    return setNodeAt<typename TypeTraits::ConstRefOrConstPtr<TString>::type,
+                     typename TypeTraits::ConstRefOrConstPtr<TValue>::type>(
+        key, 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));
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<TValue>::value,
+                                bool>::type
+  set(const TString& key, TValue value, uint8_t decimals) {
+    return set(key, JsonVariant(value, decimals));
   }
 
   // Gets the value associated with the specified key.
-  FORCE_INLINE JsonVariant get(JsonObjectKey) const;
-
-  // Gets the value associated with the specified key.
-  template <typename T>
-  FORCE_INLINE T get(JsonObjectKey) const;
+  template <typename TValue, typename TString>
+  typename Internals::JsonVariantAs<TValue>::type get(
+      const TString& key) const {
+    node_type* node = getNodeAt(key);
+    return node ? node->content.value.as<TValue>()
+                : Internals::JsonVariantDefault<TValue>::get();
+  }
 
   // Checks the type of the value associated with the specified key.
-  template <typename T>
-  FORCE_INLINE bool is(JsonObjectKey) const;
+  template <typename TValue, typename TString>
+  bool is(const TString& key) const {
+    node_type* node = getNodeAt(key);
+    return node ? node->content.value.is<TValue>() : false;
+  }
 
   // Creates and adds a JsonArray.
   // This is a shortcut for JsonBuffer::createArray() and JsonObject::add().
-  FORCE_INLINE JsonArray& createNestedArray(JsonObjectKey key);
+  template <typename TString>
+  JsonArray& createNestedArray(const TString& key);
 
   // Creates and adds a JsonObject.
   // This is a shortcut for JsonBuffer::createObject() and JsonObject::add().
-  FORCE_INLINE JsonObject& createNestedObject(JsonObjectKey key);
+  template <typename TString>
+  JsonObject& createNestedObject(const TString& key);
 
   // Tells weither the specified key is present and associated with a value.
-  FORCE_INLINE bool containsKey(JsonObjectKey key) const;
+  template <typename TString>
+  bool containsKey(const TString& key) const {
+    return getNodeAt(key) != NULL;
+  }
 
   // Removes the specified key and the associated value.
-  void remove(JsonObjectKey key);
+  template <typename TString>
+  void remove(const TString& key) {
+    removeNode(getNodeAt(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; }
-
-  // Serialize the object to the specified JsonWriter
-  void writeTo(Internals::JsonWriter& writer) const;
+  static JsonObject& invalid() {
+    static JsonObject instance(NULL);
+    return instance;
+  }
 
  private:
   // Returns the list node that matches the specified key.
-  node_type* getNodeAt(const char* key) const;
+  template <typename TString>
+  node_type* getNodeAt(const TString& key) const {
+    // reduce the number of template function instanciation to reduce code size
+    return getNodeAtImpl<
+        typename TypeTraits::ConstRefOrConstPtr<TString>::type>(key);
+  }
 
-  node_type* getOrCreateNodeAt(const char* key);
+  template <typename TStringRef>
+  node_type* getNodeAtImpl(TStringRef key) const {
+    for (node_type* node = _firstNode; node; node = node->next) {
+      if (Internals::StringFuncs<TStringRef>::equals(key, node->content.key))
+        return node;
+    }
+    return NULL;
+  }
 
-  template <typename T>
-  FORCE_INLINE bool setNodeAt(JsonObjectKey key, T value);
+  template <typename TStringRef, typename TValueRef>
+  bool setNodeAt(TStringRef key, TValueRef value) {
+    node_type* node = getNodeAtImpl<TStringRef>(key);
+    if (!node) {
+      node = addNewNode();
+      if (!node) return false;
 
-  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;
+      bool key_ok = Internals::ValueSetter<TStringRef>::set(
+          _buffer, node->content.key, key);
+      if (!key_ok) return false;
+    }
+    return Internals::ValueSetter<TValueRef>::set(_buffer, node->content.value,
+                                                  value);
+  }
 };
 }
-
-#include "JsonObject.ipp"

include/ArduinoJson/JsonObject.ipp

@@ -13,104 +13,13 @@
 
 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::invalid<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;
+namespace Internals {
+template <>
+struct JsonVariantDefault<JsonObject> {
+  static JsonObject &get() {
+    return JsonObject::invalid();
   }
-  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::invalid<JsonObject const &>() {
-  return JsonObject::invalid();
-}
-
-template <>
-inline JsonObject &JsonVariant::invalid<JsonObject &>() {
-  return JsonObject::invalid();
+};
 }
 
 inline JsonObject &JsonVariant::asObject() const {
@@ -118,11 +27,12 @@ inline JsonObject &JsonVariant::asObject() const {
   return JsonObject::invalid();
 }
 
-inline JsonObject &JsonObject::createNestedObject(JsonObjectKey key) {
+template <typename TString>
+inline JsonObject &JsonObject::createNestedObject(const TString &key) {
   if (!_buffer) return JsonObject::invalid();
-  JsonObject &array = _buffer->createObject();
-  setNodeAt<const JsonVariant &>(key, array);
-  return array;
+  JsonObject &object = _buffer->createObject();
+  set(key, object);
+  return object;
 }
 
 inline JsonObject &JsonArray::createNestedObject() {

include/ArduinoJson/JsonObjectKey.hpp

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

@@ -9,6 +9,7 @@
 
 #include "Configuration.hpp"
 #include "JsonVariantBase.hpp"
+#include "TypeTraits/ConstRefOrConstPtr.hpp"
 #include "TypeTraits/EnableIf.hpp"
 
 #ifdef _MSC_VER
@@ -18,40 +19,37 @@
 
 namespace ArduinoJson {
 
-template <typename TKey>
-class JsonObjectSubscript : public JsonVariantBase<JsonObjectSubscript<TKey> > {
+template <typename TString>
+class JsonObjectSubscript
+    : public JsonVariantBase<JsonObjectSubscript<TString> > {
+  // const String&
+  // const std::string&
+  // const char*
+  typedef typename TypeTraits::ConstRefOrConstPtr<TString>::type TStringRef;
+
  public:
-  FORCE_INLINE JsonObjectSubscript(JsonObject& object, TKey key)
+  FORCE_INLINE JsonObjectSubscript(JsonObject& object, TStringRef key)
       : _object(object), _key(key) {}
 
-  JsonObjectSubscript<TKey>& operator=(const JsonObjectSubscript<TKey>& src) {
-    _object.set<const JsonVariant&>(_key, src);
+  FORCE_INLINE JsonObjectSubscript<TString>& operator=(
+      const JsonObjectSubscript<TString>& src) {
+    _object.set(_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));
+  FORCE_INLINE JsonObjectSubscript<TString>& operator=(const T& src) {
+    _object.set(_key, 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 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);
+  FORCE_INLINE typename Internals::JsonVariantAs<TValue>::type as() const {
+    return _object.get<TValue, TStringRef>(_key);
   }
 
   template <typename TValue>
@@ -60,38 +58,32 @@ class JsonObjectSubscript : public JsonVariantBase<JsonObjectSubscript<TKey> > {
   }
 
   template <typename TValue>
-  FORCE_INLINE bool set(TValue value) {
-    return _object.set<TValue>(_key, value);
+  FORCE_INLINE bool set(const TValue& value) {
+    return _object.set(_key, value);
   }
 
   template <typename TValue>
-  FORCE_INLINE bool set(TValue value, uint8_t decimals) {
+  FORCE_INLINE bool set(const 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;
+  TStringRef _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) {
+template <typename TString>
+inline std::ostream& operator<<(std::ostream& os,
+                                const JsonObjectSubscript<TString>& source) {
   return source.printTo(os);
 }
 #endif
 
+template <typename TString>
+inline JsonObjectSubscript<TString> JsonObject::operator[](const TString& key) {
+  return JsonObjectSubscript<TString>(*this, key);
+}
 }  // namespace ArduinoJson
 
 #ifdef _MSC_VER

include/ArduinoJson/JsonPair.hpp

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include "JsonObjectKey.hpp"
 #include "JsonVariant.hpp"
 
 namespace ArduinoJson {

include/ArduinoJson/JsonVariant.hpp

@@ -12,13 +12,16 @@
 
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/JsonVariantContent.hpp"
+#include "Internals/JsonVariantDefault.hpp"
 #include "Internals/JsonVariantType.hpp"
-#include "Internals/Unparsed.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/IsSignedIntegral.hpp"
+#include "TypeTraits/IsUnsignedIntegral.hpp"
 #include "TypeTraits/RemoveConst.hpp"
 #include "TypeTraits/RemoveReference.hpp"
 
@@ -36,16 +39,20 @@ class JsonObject;
 // - a string (const char*)
 // - a reference to a JsonArray or JsonObject
 class JsonVariant : public JsonVariantBase<JsonVariant> {
- public:
-  template <typename T>
-  struct IsConstructibleFrom;
+  friend void Internals::JsonSerializer::serialize(const JsonVariant &,
+                                                   JsonWriter &);
 
+ public:
   // Creates an uninitialized JsonVariant
-  FORCE_INLINE JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
+  JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
 
   // Create a JsonVariant containing a boolean value.
   // It will be serialized as "true" or "false" in JSON.
-  FORCE_INLINE JsonVariant(bool value);
+  JsonVariant(bool value) {
+    using namespace Internals;
+    _type = JSON_BOOLEAN;
+    _content.asInteger = static_cast<JsonInteger>(value);
+  }
 
   // Create a JsonVariant containing a floating point value.
   // The second argument specifies the number of decimal digits to write in
@@ -53,50 +60,87 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   // JsonVariant(double value, uint8_t decimals);
   // JsonVariant(float value, uint8_t decimals);
   template <typename T>
-  FORCE_INLINE JsonVariant(
-      T value, uint8_t decimals = 2,
-      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
-          * = 0) {
+  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);
   }
 
   // Create a JsonVariant containing an integer value.
-  // JsonVariant(short)
-  // JsonVariant(int)
-  // JsonVariant(long)
+  // JsonVariant(signed short)
+  // JsonVariant(signed int)
+  // JsonVariant(signed long)
   template <typename T>
-  FORCE_INLINE JsonVariant(
-      T value,
-      typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value>::type * =
-          0) {
+  JsonVariant(T value,
+              typename TypeTraits::EnableIf<
+                  TypeTraits::IsSignedIntegral<T>::value>::type * = 0) {
     using namespace Internals;
-    _type = JSON_INTEGER;
-    _content.asInteger = static_cast<JsonInteger>(value);
+    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>
+  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);
   }
 
   // Create a JsonVariant containing a string.
-  FORCE_INLINE JsonVariant(const char *value);
+  JsonVariant(const char *value) {
+    _type = Internals::JSON_STRING;
+    _content.asString = value;
+  }
 
   // Create a JsonVariant containing an unparsed string
-  FORCE_INLINE JsonVariant(Internals::Unparsed value);
+  JsonVariant(RawJson value) {
+    _type = Internals::JSON_UNPARSED;
+    _content.asString = value;
+  }
 
   // Create a JsonVariant containing a reference to an array.
-  FORCE_INLINE JsonVariant(JsonArray &array);
+  // CAUTION: we are lying about constness, because the array can be modified if
+  // the variant is converted back to a JsonArray&
+  JsonVariant(const JsonArray &array);
 
   // Create a JsonVariant containing a reference to an object.
-  FORCE_INLINE JsonVariant(JsonObject &object);
+  // CAUTION: we are lying about constness, because the object can be modified
+  // if the variant is converted back to a JsonObject&
+  JsonVariant(const JsonObject &object);
 
   // Get the variant as the specified type.
-  // short as<short>() const;
-  // int as<int>() const;
-  // long as<long>() const;
+  //
+  // short as<signed short>() const;
+  // int as<signed int>() const;
+  // long as<signed long>() const;
   template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value, T>::type
+  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>
@@ -105,21 +149,29 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   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,
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
+                                    TypeTraits::IsSame<T, char *>::value,
                                 const char *>::type
   as() const {
     return asString();
   }
+  //
+  // std::string as<std::string>() const;
+  // String as<String>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<Internals::StringFuncs<T>::has_append, T>::type
+  as() const {
+    const char *cstr = asString();
+    if (cstr) return T(cstr);
+    T s;
+    printTo(s);
+    return s;
+  }
+  //
   // const bool as<bool>() const
   template <typename T>
   const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
@@ -127,53 +179,164 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   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::RemoveReference<T>::type,
+                         JsonArray>::value,
+      JsonArray &>::type
+  as() const {
+    return asArray();
+  }
+  //
+  // const JsonArray& as<const JsonArray&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
+                         const JsonArray>::value,
+      const JsonArray &>::type
+  as() const {
+    return asArray();
+  }
+  //
+  // JsonObject& as<JsonObject> const;
+  // JsonObject& as<JsonObject&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
+                         JsonObject>::value,
+      JsonObject &>::type
+  as() const {
+    return asObject();
+  }
+  //
+  // JsonObject& as<const JsonObject> const;
+  // JsonObject& as<const JsonObject&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
+                         const JsonObject>::value,
+      const JsonObject &>::type
+  as() const {
+    return asObject();
+  }
+  //
+  // JsonVariant as<JsonVariant> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, JsonVariant>::value,
+                                T>::type
+  as() const {
+    return *this;
+  }
+
+  // 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>
+  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value &&
+                                          !TypeTraits::IsSame<T, bool>::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,
-      JsonArray &>::type
-  as() const {
-    return asArray();
+      bool>::type
+  is() const {
+    return isArray();
   }
-  // JsonObject& as<JsonObject> const;
-  // JsonObject& as<JsonObject&> const;
-  // JsonObject& as<const JsonObject&> const;
+  //
+  // bool is<JsonObject> const;
+  // bool is<JsonObject&> const;
+  // bool is<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();
+      bool>::type
+  is() const {
+    return isObject();
   }
 
-  // Tells weither the variant has the specified type.
-  // Returns true if the variant has type type T, false otherwise.
-  template <typename T>
-  bool is() const;
-
-  // Serialize the variant to a JsonWriter
-  void writeTo(Internals::JsonWriter &writer) const;
-
-  // TODO: rename
-  template <typename T>
-  static T invalid();
+  // Returns true if the variant has a value
+  bool success() const {
+    return _type != Internals::JSON_UNDEFINED;
+  }
 
+  // DEPRECATED: use as<char*>() instead
   const char *asString() const;
+
+  // DEPRECATED: use as<JsonArray>() instead
   JsonArray &asArray() const;
+
+  // DEPRECATED: use as<JsonObject>() instead
   JsonObject &asObject() const;
 
  private:
-  String toString() const;
+  // It's not allowed to store a char
+  template <typename T>
+  JsonVariant(T value, typename TypeTraits::EnableIf<
+                           TypeTraits::IsSame<T, char>::value>::type * = 0);
+
   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 ||
+           (_type == Internals::JSON_UNPARSED && _content.asString &&
+            !strcmp("null", _content.asString));
+  }
 
   // The current type of the variant
   Internals::JsonVariantType _type;
@@ -189,29 +352,4 @@ inline JsonVariant float_with_n_digits(float value, uint8_t digits) {
 inline JsonVariant double_with_n_digits(double value, uint8_t digits) {
   return JsonVariant(value, digits);
 }
-
-template <typename T>
-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, 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;
-};
 }
-
-// Include inline implementations
-#include "JsonVariant.ipp"

include/ArduinoJson/JsonVariant.ipp

@@ -8,137 +8,118 @@
 #pragma once
 
 #include "Configuration.hpp"
-#include "JsonVariant.hpp"
 #include "Internals/Parse.hpp"
+#include "JsonArray.hpp"
+#include "JsonObject.hpp"
+#include "JsonVariant.hpp"
 
-#include <string.h>
+#include <errno.h>   // for errno
+#include <stdlib.h>  // for strtol, strtod
+#include <string.h>  // for strcmp
 
 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(Internals::Unparsed 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;
-}
-
-template <typename T>
-inline T JsonVariant::invalid() {
-  return T();
-}
-
-template <typename T>
-inline bool JsonVariant::is() const {
-  return false;
-}
-
-template <>  // in .cpp
-bool JsonVariant::is<signed long>() const;
-
-template <>  // in .cpp
-bool JsonVariant::is<double>() const;
-
-template <>  // int .cpp
-bool JsonVariant::is<bool>() const;
-
-template <>
-inline bool JsonVariant::is<char const *>() const {
-  return _type == Internals::JSON_STRING;
-}
-
-template <>
-inline bool JsonVariant::is<float>() const {
-  return is<double>();
-}
-
-template <>
-inline bool JsonVariant::is<JsonArray &>() const {
-  return _type == Internals::JSON_ARRAY;
-}
-
-template <>
-inline bool JsonVariant::is<JsonArray const &>() const {
-  return _type == Internals::JSON_ARRAY;
-}
-
-template <>
-inline bool JsonVariant::is<JsonObject &>() const {
-  return _type == Internals::JSON_OBJECT;
-}
-
-template <>
-inline bool JsonVariant::is<JsonObject const &>() const {
-  return _type == Internals::JSON_OBJECT;
-}
-
-template <>
-inline bool JsonVariant::is<signed char>() const {
-  return is<signed long>();
-}
-
-template <>
-inline bool JsonVariant::is<signed int>() const {
-  return is<signed long>();
-}
-
-template <>
-inline bool JsonVariant::is<signed short>() const {
-  return is<signed long>();
-}
-
-template <>
-inline bool JsonVariant::is<unsigned char>() const {
-  return is<signed long>();
-}
-
-template <>
-inline bool JsonVariant::is<unsigned int>() const {
-  return is<signed long>();
-}
-
-template <>
-inline bool JsonVariant::is<unsigned long>() const {
-  return is<signed long>();
-}
-
-template <>
-inline bool JsonVariant::is<unsigned short>() const {
-  return is<signed long>();
-}
-
 inline Internals::JsonInteger JsonVariant::asInteger() const {
-  if (_type == Internals::JSON_INTEGER || _type == Internals::JSON_BOOLEAN)
-    return _content.asInteger;
-
-  if (_type >= Internals::JSON_FLOAT_0_DECIMALS)
-    return static_cast<Internals::JsonInteger>(_content.asFloat);
-
-  if ((_type == Internals::JSON_STRING || _type == Internals::JSON_UNPARSED) &&
-      _content.asString) {
-    if (!strcmp("true", _content.asString)) return 1;
-    return Internals::parse<Internals::JsonInteger>(_content.asString);
+  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);
   }
+}
 
-  return 0L;
+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);
+  }
+}
+
+inline const char *JsonVariant::asString() const {
+  using namespace Internals;
+  if (_type == JSON_UNPARSED && _content.asString &&
+      !strcmp("null", _content.asString))
+    return NULL;
+  if (_type == JSON_STRING || _type == JSON_UNPARSED) return _content.asString;
+  return NULL;
+}
+
+inline Internals::JsonFloat JsonVariant::asFloat() const {
+  using namespace Internals;
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return 0;
+    case JSON_POSITIVE_INTEGER:
+    case JSON_BOOLEAN:
+      return static_cast<JsonFloat>(_content.asInteger);
+    case JSON_NEGATIVE_INTEGER:
+      return -static_cast<JsonFloat>(_content.asInteger);
+    case JSON_STRING:
+    case JSON_UNPARSED:
+      return _content.asString ? parse<JsonFloat>(_content.asString) : 0;
+    default:
+      return _content.asFloat;
+  }
+}
+
+inline bool JsonVariant::isBoolean() const {
+  using namespace Internals;
+  if (_type == JSON_BOOLEAN) return true;
+
+  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
+
+  return !strcmp(_content.asString, "true") ||
+         !strcmp(_content.asString, "false");
+}
+
+inline bool JsonVariant::isInteger() const {
+  using namespace Internals;
+  if (_type == JSON_POSITIVE_INTEGER || _type == JSON_NEGATIVE_INTEGER)
+    return true;
+
+  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
+
+  char *end;
+  errno = 0;
+  strtol(_content.asString, &end, 10);
+
+  return *end == '\0' && errno == 0;
+}
+
+inline bool JsonVariant::isFloat() const {
+  using namespace Internals;
+  if (_type >= JSON_FLOAT_0_DECIMALS) return true;
+
+  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
+
+  char *end;
+  errno = 0;
+  strtod(_content.asString, &end);
+
+  return *end == '\0' && errno == 0 && !is<long>();
 }
 
 #if ARDUINOJSON_ENABLE_STD_STREAM

include/ArduinoJson/JsonVariantBase.hpp

@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include "Internals/ForceInline.hpp"
-#include "JsonObjectKey.hpp"
+#include "Internals/JsonVariantAs.hpp"
+#include "Polyfills/attributes.hpp"
 
 namespace ArduinoJson {
 
@@ -20,20 +20,35 @@ class JsonObjectSubscript;
 template <typename TImpl>
 class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
  public:
-  FORCE_INLINE const char *asString() const { return as<const char *>(); }
+  // DEPRECATED: use as<char*>() instead
+  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 &>(); }
+  FORCE_INLINE operator JsonArray &() const {
+    return as<JsonArray &>();
+  }
+
+  // DEPRECATED: use as<JsonArray>() instead
+  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 &>(); }
+  FORCE_INLINE operator JsonObject &() const {
+    return as<JsonObject &>();
+  }
+
+  // DEPRECATED: use as<JsonObject>() instead
+  FORCE_INLINE JsonObject &asObject() const {
+    return as<JsonObject &>();
+  }
 
   template <typename T>
   FORCE_INLINE operator T() const {
@@ -41,14 +56,16 @@ class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
   }
 
   template <typename T>
-  FORCE_INLINE const T as() const {
+  FORCE_INLINE const typename Internals::JsonVariantAs<T>::type 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(); }
+  size_t size() const {
+    return asArray().size() + asObject().size();
+  }
 
   // Mimics an array.
   // Returns the element at specified index if the variant is an array.
@@ -59,16 +76,18 @@ class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
   // 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;
+  template <typename TString>
+  FORCE_INLINE
+      typename TypeTraits::EnableIf<Internals::StringFuncs<TString>::has_equals,
+                                    const JsonObjectSubscript<TString> >::type
+      operator[](const TString &key) const {
+    return asObject()[key];
+  }
 
  private:
-  const TImpl *impl() const { return static_cast<const TImpl *>(this); }
+  const TImpl *impl() const {
+    return static_cast<const TImpl *>(this);
+  }
 };
 
 template <typename TImpl, typename TComparand>

include/ArduinoJson/Polyfills/attributes.hpp

@@ -9,6 +9,8 @@
 
 #ifdef _MSC_VER
 #define FORCE_INLINE __forceinline
+#define NO_INLINE __declspec(noinline)
 #else
 #define FORCE_INLINE __attribute__((always_inline))
+#define NO_INLINE __attribute__((noinline))
 #endif

include/ArduinoJson/Polyfills/math.hpp

@@ -0,0 +1,111 @@
+// 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>
+
+namespace ArduinoJson {
+namespace Polyfills {
+template <typename T>
+bool isNaN(T x) {
+  return _isnan(x) != 0;
+}
+
+template <typename T>
+bool isInfinity(T x) {
+  return !_finite(x);
+}
+}
+}
+
+#else
+
+#include <math.h>
+
+// 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
+
+// Workaround for libs that #undef isnan or isinf
+// https://github.com/bblanchon/ArduinoJson/issues/284
+#if !defined(isnan) || !defined(isinf)
+namespace std {}
+#endif
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+template <typename T>
+bool isNaN(T x) {
+// Workaround for libs that #undef isnan
+// https://github.com/bblanchon/ArduinoJson/issues/284
+#ifndef isnan
+  using namespace std;
+#endif
+
+  return isnan(x);
+}
+
+#if defined(_GLIBCXX_HAVE_ISNANL) && _GLIBCXX_HAVE_ISNANL
+template <>
+inline bool isNaN<double>(double x) {
+  return isnanl(x);
+}
+#endif
+
+#if defined(_GLIBCXX_HAVE_ISNANF) && _GLIBCXX_HAVE_ISNANF
+template <>
+inline bool isNaN<float>(float x) {
+  return isnanf(x);
+}
+#endif
+
+template <typename T>
+bool isInfinity(T x) {
+// Workaround for libs that #undef isinf
+// https://github.com/bblanchon/ArduinoJson/issues/284
+#ifndef isinf
+  using namespace std;
+#endif
+
+  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
+
+#if defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic pop
+#endif
+#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,44 @@
+// 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(static_cast<uint8_t>(*s++));
+    }
+    return n;
+  }
+
+  size_t println() {
+    size_t n = 0;
+    n += write('\r');
+    n += write('\n');
+    return n;
+  }
+};
+}
+
+#else
+
+#include <Print.h>
+
+#endif

include/ArduinoJson/RawJson.hpp

@@ -8,14 +8,16 @@
 #pragma once
 
 namespace ArduinoJson {
-namespace Internals {
-class Unparsed {
+
+// A special type of data that can be used to insert pregenerated JSON portions.
+class RawJson {
  public:
-  explicit Unparsed(const char* str) : _str(str) {}
-  operator const char*() const { return _str; }
+  explicit RawJson(const char* str) : _str(str) {}
+  operator const char*() const {
+    return _str;
+  }
 
  private:
   const char* _str;
 };
 }
-}

include/ArduinoJson/StaticJsonBuffer.hpp

@@ -9,6 +9,16 @@
 
 #include "JsonBuffer.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 {
 
 // Implements a JsonBuffer with fixed memory allocation.
@@ -19,8 +29,12 @@ class StaticJsonBuffer : public JsonBuffer {
  public:
   explicit StaticJsonBuffer() : _size(0) {}
 
-  size_t capacity() const { return CAPACITY; }
-  size_t size() const { return _size; }
+  size_t capacity() const {
+    return CAPACITY;
+  }
+  size_t size() const {
+    return _size;
+  }
 
   virtual void* alloc(size_t bytes) {
     if (_size + bytes > CAPACITY) return NULL;
@@ -34,3 +48,11 @@ class StaticJsonBuffer : public JsonBuffer {
   size_t _size;
 };
 }
+
+#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/TypeTraits/ConstRefOrConstPtr.hpp

@@ -0,0 +1,31 @@
+// 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 ConstRefOrConstPtr {
+  typedef const T& type;
+};
+template <typename T>
+struct ConstRefOrConstPtr<T*> {
+  typedef const T* type;
+};
+template <typename T>
+struct ConstRefOrConstPtr<T[]> {
+  typedef const T* type;
+};
+template <typename T, size_t N>
+struct ConstRefOrConstPtr<T[N]> {
+  typedef const T* type;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsIntegral.hpp

@@ -7,10 +7,9 @@
 
 #pragma once
 
-#include "../Configuration.hpp"
 #include "IsSame.hpp"
-
-#include <stdint.h>
+#include "IsSignedIntegral.hpp"
+#include "IsUnsignedIntegral.hpp"
 
 namespace ArduinoJson {
 namespace TypeTraits {
@@ -18,24 +17,13 @@ namespace TypeTraits {
 // A meta-function that returns true if T is an integral type.
 template <typename T>
 struct IsIntegral {
-  static const bool value = TypeTraits::IsSame<T, signed char>::value ||
-                            TypeTraits::IsSame<T, unsigned char>::value ||
-                            TypeTraits::IsSame<T, signed short>::value ||
-                            TypeTraits::IsSame<T, unsigned short>::value ||
-                            TypeTraits::IsSame<T, signed int>::value ||
-                            TypeTraits::IsSame<T, unsigned int>::value ||
-                            TypeTraits::IsSame<T, signed long>::value ||
-                            TypeTraits::IsSame<T, unsigned long>::value ||
-#if ARDUINOJSON_USE_LONG_LONG
-                            TypeTraits::IsSame<T, long long>::value ||
-                            TypeTraits::IsSame<T, unsigned long long>::value ||
-#endif
-
-#if ARDUINOJSON_USE_INT64
-                            TypeTraits::IsSame<T, __int64>::value ||
-                            TypeTraits::IsSame<T, unsigned __int64>::value ||
-#endif
-                            TypeTraits::IsSame<T, char>::value;
+  static const bool value = TypeTraits::IsSignedIntegral<T>::value ||
+                            TypeTraits::IsUnsignedIntegral<T>::value ||
+                            TypeTraits::IsSame<T, char>::value ||
+                            TypeTraits::IsSame<T, bool>::value;
 };
+
+template <typename T>
+struct IsIntegral<const T> : IsIntegral<T> {};
 }
 }

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;
+};
+}
+}

library.json

@@ -1,12 +1,12 @@
 {
-  "name": "Json",
+  "name": "ArduinoJson",
   "keywords": "json, rest, http, web",
   "description": "An elegant and efficient JSON library for embedded systems",
   "repository": {
     "type": "git",
     "url": "https://github.com/bblanchon/ArduinoJson.git"
   },
-  "version": "5.1.1",
+  "version": "5.7.1",
   "authors": {
     "name": "Benoit Blanchon",
     "url": "http://blog.benoitblanchon.fr"

library.properties

@@ -1,5 +1,5 @@
 name=ArduinoJson
-version=5.1.1
+version=5.7.1
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.

scripts/buffer-size-calculator.html

@@ -0,0 +1,143 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>ArduinoJson - JsonBuffer size calculator</title>
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+</head>
+<body>
+    <div class="container">
+        <div class="jumbotron">
+            <h1>JsonBuffer size calculator</h1>
+        </div>
+        <div id='error' class="alert alert-danger" role="alert">
+            Please paste your JSON in the "input" box
+        </div>
+        <div class="row">
+            <div class="col-md-6">
+                <h2>Input</h2>
+                <textarea class="form-control" rows=30 id='input'></textarea><br>
+            </div>
+            <div id='results' class="col-md-6" style='display:none'>
+                <h2>Result</h2>
+                <h3>Expression</h3>
+                <p><code id='resultexpr'></code></p>
+                <table class="table">
+                  <thead>
+                    <th>Platform</th>
+                    <th>Size (in bytes)</th>
+                  </thead>
+                  <tbody>
+                    <tr>
+                      <td>AVR 8-bit</td>
+                      <td id='sizeavr8'></td>
+                    </tr>
+                    <tr>
+                      <td>ESP8266</td>
+                      <td id='sizeesp8266'></td>
+                    </tr>
+                    <tr>
+                      <td>x86</td>
+                      <td id='sizex86'></td>
+                    </tr>
+                    <tr>
+                      <td>x64</td>
+                      <td id='sizex64'></td>
+                    </tr>
+                  </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+</body>
+<script type="text/javascript">
+    function Recipe() {
+        var arrays = [];
+        var objects = [];
+
+        this.addJsonArray = function(size) {
+            if (arrays[size])
+                arrays[size]++;
+            else
+                arrays[size] = 1;
+        }
+
+        this.addJsonObject = function(size) {
+            if (objects[size])
+                objects[size]++;
+            else
+                objects[size] = 1;
+        }
+
+        this.getExpression = function() {
+            var elements = [];
+            for (var size in arrays) {
+                var count = arrays[size];
+                if (count > 1)
+                    elements.push(count + "*JSON_ARRAY_SIZE("+size+")");
+                else
+                    elements.push("JSON_ARRAY_SIZE("+size+")");
+            }
+            for (var size in objects) {
+                var count = objects[size];
+                if (count > 1)
+                    elements.push(count + "*JSON_OBJECT_SIZE("+size+")");
+                else
+                    elements.push("JSON_OBJECT_SIZE("+size+")");
+            }
+            return elements.join(" + ");
+        }
+    }
+
+    function scanJson(recipe, obj) {
+        if (obj instanceof Array) {
+            recipe.addJsonArray(obj.length);
+            for (var i = 0; i<obj.length; i++)
+                scanJson(recipe, obj[i]);
+        }
+        else if (obj instanceof Object) {
+            recipe.addJsonObject(Object.keys(obj).length);
+            for (var key in obj) 
+                scanJson(recipe, obj[key]);
+        }
+    }
+
+    input.oninput = function(e) {
+        results.style.display = 'none';
+        error.style.visibility = 'hidden';
+
+        try {
+            var recipe = new Recipe();
+            scanJson(recipe, JSON.parse(input.value));
+            var expression = recipe.getExpression();
+
+            resultexpr.innerText = expression;
+            sizeavr8.innerText = eval(
+                "function JSON_ARRAY_SIZE(n) { return 4 + 8*n }" +
+                "function JSON_OBJECT_SIZE(n) { return 4 + 10*n }" +
+                expression
+            );
+            sizeesp8266.innerText = eval(
+                "function JSON_ARRAY_SIZE(n) { return 8 + 12*n }" +
+                "function JSON_OBJECT_SIZE(n) { return 8 + 16*n }" +
+                expression
+            );
+            sizex86.innerText = eval(
+                "function JSON_ARRAY_SIZE(n) { return 12 + 24*n }" +
+                "function JSON_OBJECT_SIZE(n) { return 12 + 32*n }" +
+                expression
+            );
+            sizex64.innerText = eval(
+                "function JSON_ARRAY_SIZE(n) { return 24 + 24*n }" +
+                "function JSON_OBJECT_SIZE(n) { return 24 + 32*n }" +
+                expression
+            );
+            results.style.display = 'block';
+        }
+        catch (ex) {
+            error.innerText = "ERROR: " + ex.message;
+            error.style.visibility = 'visible';
+        }
+    }
+</script>
+</html>

scripts/build-arduino-package.sh

@@ -17,5 +17,4 @@ rm -f $OUTPUT
 	ArduinoJson/library.properties \
 	ArduinoJson/LICENSE.md \
 	ArduinoJson/README.md \
-	ArduinoJson/src	\
-	-x!ArduinoJson/src/CMakeLists.txt
+	ArduinoJson/ArduinoJson.h

scripts/build-old-arduino-package.sh

@@ -1,52 +0,0 @@
-#!/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

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

scripts/travis/arduino.sh

@@ -11,5 +11,6 @@ export PATH=$PATH:/tmp/arduino/
   
 ln -s $PWD /tmp/arduino/libraries/ArduinoJson
 
-arduino --verify --board $BOARD $PWD/examples/JsonParserExample/JsonParserExample.ino
-arduino --verify --board $BOARD $PWD/examples/JsonGeneratorExample/JsonGeneratorExample.ino
+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

@@ -1,6 +1,8 @@
 #!/bin/sh -eux
 
-curl -sS https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1
+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 

src/ArduinoJson.h

@@ -1,14 +0,0 @@
-// 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 to please the Arduino IDE. It must be present in the src/
-// for the IDE to find it. Feel free to ignore this file if your working in
-// another environment
-
-#include "../include/ArduinoJson.h"

src/CMakeLists.txt

@@ -1,71 +0,0 @@
-# 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_compile_options(
-		-fno-exceptions
-		-fno-rtti
-		-pedantic
-		-Wall
-		-Wcast-align
-		-Wcast-qual
-		-Wconversion
-		-Wctor-dtor-privacy
-		-Wdisabled-optimization
-		-Werror
-		-Wextra
-		-Wformat=2
-		-Winit-self
-		-Wmissing-include-dirs
-		-Wno-parentheses
-		-Wno-sign-conversion
-		-Wno-unused
-		-Wno-variadic-macros
-		-Wnon-virtual-dtor
-		-Wold-style-cast
-		-Woverloaded-virtual
-		-Wredundant-decls
-		-Wshadow
-		-Wsign-promo
-		-Wstrict-overflow=5
-		-Wundef
-	)
-endif()
-
-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 ${CPP_FILES} ${HPP_FILES} ${IPP_FILES})
-
-target_include_directories(ArduinoJson INTERFACE ${CMAKE_CURRENT_LIST_DIR}/../include)

src/Internals/Comments.cpp

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

@@ -1,14 +0,0 @@
-// 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,30 +0,0 @@
-// 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"
-
-using namespace ArduinoJson::Internals;
-
-size_t IndentedPrint::write(uint8_t c) {
-  size_t n = 0;
-
-  if (isNewLine) n += writeTabs();
-
-  n += sink->write(c);
-
-  isNewLine = c == '\n';
-
-  return n;
-}
-
-inline size_t IndentedPrint::writeTabs() {
-  size_t n = 0;
-
-  for (int i = 0; i < level * tabSize; i++) n += sink->write(' ');
-
-  return n;
-}

src/Internals/List.cpp

@@ -1,50 +0,0 @@
-// 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/List.hpp"
-
-#include "../../include/ArduinoJson/JsonPair.hpp"
-#include "../../include/ArduinoJson/JsonVariant.hpp"
-
-using namespace ArduinoJson;
-using namespace ArduinoJson::Internals;
-
-template <typename T>
-size_t List<T>::size() const {
-  size_t nodeCount = 0;
-  for (node_type *node = _firstNode; node; node = node->next) nodeCount++;
-  return nodeCount;
-}
-
-template <typename T>
-typename List<T>::node_type *List<T>::addNewNode() {
-  node_type *newNode = new (_buffer) node_type();
-
-  if (_firstNode) {
-    node_type *lastNode = _firstNode;
-    while (lastNode->next) lastNode = lastNode->next;
-    lastNode->next = newNode;
-  } else {
-    _firstNode = newNode;
-  }
-
-  return newNode;
-}
-
-template <typename T>
-void List<T>::removeNode(node_type *nodeToRemove) {
-  if (!nodeToRemove) return;
-  if (nodeToRemove == _firstNode) {
-    _firstNode = nodeToRemove->next;
-  } else {
-    for (node_type *node = _firstNode; node; node = node->next)
-      if (node->next == nodeToRemove) node->next = nodeToRemove->next;
-  }
-}
-
-template class ArduinoJson::Internals::List<JsonPair>;
-template class ArduinoJson::Internals::List<JsonVariant>;

src/Internals/Prettyfier.cpp

@@ -1,87 +0,0 @@
-// 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/Prettyfier.hpp"
-
-using namespace ArduinoJson::Internals;
-
-size_t Prettyfier::write(uint8_t c) {
-  size_t n = _inString ? handleStringChar(c) : handleMarkupChar(c);
-  _previousChar = c;
-  return n;
-}
-
-inline size_t Prettyfier::handleStringChar(uint8_t c) {
-  bool isQuote = c == '"' && _previousChar != '\\';
-
-  if (isQuote) _inString = false;
-
-  return _sink.write(c);
-}
-
-inline size_t Prettyfier::handleMarkupChar(uint8_t c) {
-  switch (c) {
-    case '{':
-    case '[':
-      return handleBlockOpen(c);
-
-    case '}':
-    case ']':
-      return handleBlockClose(c);
-
-    case ':':
-      return handleColon();
-
-    case ',':
-      return handleComma();
-
-    case '"':
-      return handleQuoteOpen();
-
-    default:
-      return handleNormalChar(c);
-  }
-}
-
-inline size_t Prettyfier::handleBlockOpen(uint8_t c) {
-  return indentIfNeeded() + _sink.write(c);
-}
-
-inline size_t Prettyfier::handleBlockClose(uint8_t c) {
-  return unindentIfNeeded() + _sink.write(c);
-}
-
-inline size_t Prettyfier::handleColon() {
-  return _sink.write(':') + _sink.write(' ');
-}
-
-inline size_t Prettyfier::handleComma() {
-  return _sink.write(',') + _sink.println();
-}
-
-inline size_t Prettyfier::handleQuoteOpen() {
-  _inString = true;
-  return indentIfNeeded() + _sink.write('"');
-}
-
-inline size_t Prettyfier::handleNormalChar(uint8_t c) {
-  return indentIfNeeded() + _sink.write(c);
-}
-
-size_t Prettyfier::indentIfNeeded() {
-  if (!inEmptyBlock()) return 0;
-
-  _sink.indent();
-  return _sink.println();
-}
-
-size_t Prettyfier::unindentIfNeeded() {
-  if (inEmptyBlock()) return 0;
-
-  _sink.unindent();
-  return _sink.println();
-}

src/Internals/StaticStringBuilder.cpp

@@ -1,18 +0,0 @@
-// 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/StaticStringBuilder.hpp"
-
-using namespace ArduinoJson::Internals;
-
-size_t StaticStringBuilder::write(uint8_t c) {
-  if (length >= capacity) return 0;
-
-  buffer[length++] = c;
-  buffer[length] = '\0';
-  return 1;
-}

src/JsonArray.cpp

@@ -1,40 +0,0 @@
-// 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/JsonBuffer.hpp"
-#include "../include/ArduinoJson/JsonObject.hpp"
-
-using namespace ArduinoJson;
-using namespace ArduinoJson::Internals;
-
-JsonArray JsonArray::_invalid(NULL);
-
-JsonArray::node_type *JsonArray::getNodeAt(size_t index) const {
-  node_type *node = _firstNode;
-  while (node && index--) node = node->next;
-  return node;
-}
-
-void JsonArray::removeAt(size_t index) { removeNode(getNodeAt(index)); }
-
-void JsonArray::writeTo(JsonWriter &writer) const {
-  writer.beginArray();
-
-  const node_type *child = _firstNode;
-  while (child) {
-    child->content.writeTo(writer);
-
-    child = child->next;
-    if (!child) break;
-
-    writer.writeComma();
-  }
-
-  writer.endArray();
-}

src/JsonBuffer.cpp

@@ -1,42 +0,0 @@
-// 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/JsonBuffer.hpp"
-
-#include "../include/ArduinoJson/Internals/JsonParser.hpp"
-#include "../include/ArduinoJson/JsonArray.hpp"
-#include "../include/ArduinoJson/JsonObject.hpp"
-
-using namespace ArduinoJson;
-using namespace ArduinoJson::Internals;
-
-JsonArray &JsonBuffer::createArray() {
-  JsonArray *ptr = new (this) JsonArray(this);
-  return ptr ? *ptr : JsonArray::invalid();
-}
-
-JsonObject &JsonBuffer::createObject() {
-  JsonObject *ptr = new (this) JsonObject(this);
-  return ptr ? *ptr : JsonObject::invalid();
-}
-
-JsonArray &JsonBuffer::parseArray(char *json, uint8_t nestingLimit) {
-  JsonParser parser(this, json, nestingLimit);
-  return parser.parseArray();
-}
-
-JsonObject &JsonBuffer::parseObject(char *json, uint8_t nestingLimit) {
-  JsonParser parser(this, json, nestingLimit);
-  return parser.parseObject();
-}
-
-char *JsonBuffer::strdup(const char *source, size_t length) {
-  size_t size = length + 1;
-  char *dest = static_cast<char *>(alloc(size));
-  if (dest != NULL) memcpy(dest, source, size);
-  return dest;
-}

src/JsonObject.cpp

@@ -1,44 +0,0 @@
-// 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/JsonObject.hpp"
-
-#include <string.h>  // for strcmp
-
-#include "../include/ArduinoJson/Internals/StaticStringBuilder.hpp"
-#include "../include/ArduinoJson/JsonArray.hpp"
-#include "../include/ArduinoJson/JsonBuffer.hpp"
-
-using namespace ArduinoJson;
-using namespace ArduinoJson::Internals;
-
-JsonObject JsonObject::_invalid(NULL);
-
-JsonObject::node_type *JsonObject::getNodeAt(const char *key) const {
-  for (node_type *node = _firstNode; node; node = node->next) {
-    if (!strcmp(node->content.key, key)) return node;
-  }
-  return NULL;
-}
-
-void JsonObject::writeTo(JsonWriter &writer) const {
-  writer.beginObject();
-
-  const node_type *node = _firstNode;
-  while (node) {
-    writer.writeString(node->content.key);
-    writer.writeColon();
-    node->content.value.writeTo(writer);
-
-    node = node->next;
-    if (!node) break;
-
-    writer.writeComma();
-  }
-
-  writer.endObject();
-}

src/JsonVariant.cpp

@@ -1,110 +0,0 @@
-// 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/JsonVariant.hpp"
-
-#include "../include/ArduinoJson/JsonArray.hpp"
-#include "../include/ArduinoJson/JsonObject.hpp"
-
-#include <errno.h>   // for errno
-#include <stdlib.h>  // for strtol, strtod
-
-using namespace ArduinoJson::Internals;
-
-namespace ArduinoJson {
-
-const char *JsonVariant::asString() const {
-  if (_type == JSON_UNPARSED && _content.asString &&
-      !strcmp("null", _content.asString))
-    return NULL;
-  if (_type == JSON_STRING || _type == JSON_UNPARSED) return _content.asString;
-  return NULL;
-}
-
-JsonFloat JsonVariant::asFloat() const {
-  if (_type >= JSON_FLOAT_0_DECIMALS) return _content.asFloat;
-
-  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN)
-    return static_cast<JsonFloat>(_content.asInteger);
-
-  if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString)
-    return parse<JsonFloat>(_content.asString);
-
-  return 0.0;
-}
-
-String JsonVariant::toString() const {
-  String s;
-  if ((_type == JSON_STRING || _type == JSON_UNPARSED) &&
-      _content.asString != NULL)
-    s = _content.asString;
-  else
-    printTo(s);
-  return s;
-}
-
-template <>
-bool JsonVariant::is<bool>() const {
-  if (_type == JSON_BOOLEAN) return true;
-
-  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
-
-  return !strcmp(_content.asString, "true") ||
-         !strcmp(_content.asString, "false");
-}
-
-template <>
-bool JsonVariant::is<signed long>() const {
-  if (_type == JSON_INTEGER) return true;
-
-  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
-
-  char *end;
-  errno = 0;
-  strtol(_content.asString, &end, 10);
-
-  return *end == '\0' && errno == 0;
-}
-
-template <>
-bool JsonVariant::is<double>() const {
-  if (_type >= JSON_FLOAT_0_DECIMALS) return true;
-
-  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
-
-  char *end;
-  errno = 0;
-  strtod(_content.asString, &end);
-
-  return *end == '\0' && errno == 0 && !is<long>();
-}
-
-void JsonVariant::writeTo(JsonWriter &writer) const {
-  if (_type == JSON_ARRAY)
-    _content.asArray->writeTo(writer);
-
-  else if (_type == JSON_OBJECT)
-    _content.asObject->writeTo(writer);
-
-  else if (_type == JSON_STRING)
-    writer.writeString(_content.asString);
-
-  else if (_type == JSON_UNPARSED)
-    writer.writeRaw(_content.asString);
-
-  else if (_type == JSON_INTEGER)
-    writer.writeInteger(_content.asInteger);
-
-  else if (_type == JSON_BOOLEAN)
-    writer.writeBoolean(_content.asInteger != 0);
-
-  else if (_type >= JSON_FLOAT_0_DECIMALS) {
-    uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
-    writer.writeFloat(_content.asFloat, decimals);
-  }
-}
-}

test/CMakeLists.txt

@@ -1,35 +1,73 @@
 # Copyright Benoit Blanchon 2014-2016
 # MIT License
-# 
+#
 # Arduino JSON library
 # https://github.com/bblanchon/ArduinoJson
 # If you like this project, please add a star!
 
-set(GTEST_DIR ../third-party/gtest-1.7.0)
+include(gtest.cmake)
 
 file(GLOB TESTS_FILES *.hpp *.cpp)
 
-include_directories(
-    ${GTEST_DIR}
-    ${GTEST_DIR}/include)
-
-add_definitions(-DGTEST_HAS_PTHREAD=0)
-
-# Workaround for Visual Studio 2012
-if (MSVC AND MSVC_VERSION EQUAL 1700)
-    add_definitions(-D_VARIADIC_MAX=10)
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+	add_compile_options(
+		-fno-exceptions
+		-fno-rtti
+		-pedantic
+		-Wall
+		-Wcast-align
+		-Wcast-qual
+		-Wconversion
+		-Wctor-dtor-privacy
+		-Wdisabled-optimization
+		-Werror
+		-Wextra
+		-Wformat=2
+		-Winit-self
+		-Wmissing-include-dirs
+		-Wparentheses
+		-Wnon-virtual-dtor
+		-Wold-style-cast
+		-Woverloaded-virtual
+		-Wredundant-decls
+		-Wshadow
+		-Wsign-promo
+		-Wstrict-overflow=5
+		-Wundef
+	)
 endif()
 
-if (MSVC)
+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 # Set warning level
+		/WX # Treats all compiler warnings as errors.
+	)
 endif()
 
-add_executable(ArduinoJsonTests 
-    ${TESTS_FILES}
-    ${GTEST_DIR}/src/gtest-all.cc
-    ${GTEST_DIR}/src/gtest_main.cc)
-
-
-target_link_libraries(ArduinoJsonTests ArduinoJson)
+add_executable(ArduinoJsonTests ${TESTS_FILES})
+target_include_directories(ArduinoJsonTests PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../include)
+target_link_libraries(ArduinoJsonTests gtest)
 
 add_test(ArduinoJsonTests ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ArduinoJsonTests)

test/DynamicJsonBuffer_Basic_Tests.cpp

@@ -5,13 +5,9 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
+#include <ArduinoJson.h>
 #include <gtest/gtest.h>
 
-#define protected public
-#include <ArduinoJson/DynamicJsonBuffer.hpp>
-
-using namespace ArduinoJson;
-
 class DynamicJsonBuffer_Basic_Tests : public testing::Test {
  protected:
   DynamicJsonBuffer buffer;
@@ -42,3 +38,16 @@ TEST_F(DynamicJsonBuffer_Basic_Tests, Alignment) {
     ASSERT_EQ(0, addr & mask);
   }
 }
+
+TEST_F(DynamicJsonBuffer_Basic_Tests, strdup) {
+  char original[] = "hello";
+  char* copy = buffer.strdup(original);
+  strcpy(original, "world");
+  ASSERT_STREQ("hello", copy);
+}
+
+TEST_F(DynamicJsonBuffer_Basic_Tests, strdup_givenNull) {
+  const char* original = NULL;
+  char* copy = buffer.strdup(original);
+  ASSERT_EQ(NULL, copy);
+}

test/Issue67.cpp

@@ -1,48 +0,0 @@
-// 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 <gtest/gtest.h>
-#include <ArduinoJson.h>
-
-class Issue67 : public testing::Test {
- public:
-  void whenInputIs(double value) { _variant = value; }
-
-  void outputMustBe(const char* expected) {
-    char buffer[1024];
-    _variant.printTo(buffer, sizeof(buffer));
-    ASSERT_STREQ(expected, buffer);
-  }
-
- private:
-  JsonVariant _variant;
-};
-
-TEST_F(Issue67, BigPositiveDouble) {
-  whenInputIs(1e100);
-  outputMustBe("1e+100");
-}
-
-TEST_F(Issue67, BigNegativeDouble) {
-  whenInputIs(-1e100);
-  outputMustBe("-1e+100");
-}
-
-TEST_F(Issue67, Zero) {
-  whenInputIs(0.0);
-  outputMustBe("0.00");
-}
-
-TEST_F(Issue67, SmallPositiveDouble) {
-  whenInputIs(111.111);
-  outputMustBe("111.11");
-}
-
-TEST_F(Issue67, SmallNegativeDouble) {
-  whenInputIs(-111.111);
-  outputMustBe("-111.11");
-}

test/Issue90.cpp

@@ -14,13 +14,11 @@
 
 #define SUITE Issue90
 
-using namespace ArduinoJson::Internals;
-
 static const char* superLong =
     "12345678901234567890123456789012345678901234567890123456789012345678901234"
     "5678901234567890123456789012345678901234567890123456789012345678901234567";
 
-static const JsonVariant variant = Unparsed(superLong);
+static const JsonVariant variant = RawJson(superLong);
 
 TEST(SUITE, IsNotALong) { ASSERT_FALSE(variant.is<long>()); }
 

test/JsonArray_CopyFrom_Tests.cpp

@@ -0,0 +1,64 @@
+// 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 <gtest/gtest.h>
+
+TEST(JsonArray_CopyFrom_Tests, OneDimension) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray& array = jsonBuffer.createArray();
+  char json[32];
+  int source[] = {1, 2, 3};
+
+  bool ok = array.copyFrom(source);
+  ASSERT_TRUE(ok);
+
+  array.printTo(json, sizeof(json));
+  ASSERT_STREQ("[1,2,3]", json);
+}
+
+TEST(JsonArray_CopyFrom_Tests, OneDimension_JsonBufferTooSmall) {
+  const size_t SIZE = JSON_ARRAY_SIZE(2);
+  StaticJsonBuffer<SIZE> jsonBuffer;
+  JsonArray& array = jsonBuffer.createArray();
+  char json[32];
+  int source[] = {1, 2, 3};
+
+  bool ok = array.copyFrom(source);
+  ASSERT_FALSE(ok);
+
+  array.printTo(json, sizeof(json));
+  ASSERT_STREQ("[1,2]", json);
+}
+
+TEST(JsonArray_CopyFrom_Tests, TwoDimensions) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray& array = jsonBuffer.createArray();
+  char json[32];
+  int source[][3] = {{1, 2, 3}, {4, 5, 6}};
+
+  bool ok = array.copyFrom(source);
+  ASSERT_TRUE(ok);
+
+  array.printTo(json, sizeof(json));
+  ASSERT_STREQ("[[1,2,3],[4,5,6]]", json);
+}
+
+TEST(JsonArray_CopyFrom_Tests, TwoDimensions_JsonBufferTooSmall) {
+  const size_t SIZE =
+      JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
+  StaticJsonBuffer<SIZE> jsonBuffer;
+  JsonArray& array = jsonBuffer.createArray();
+  char json[32];
+  int source[][3] = {{1, 2, 3}, {4, 5, 6}};
+
+  bool ok = array.copyFrom(source);
+  ASSERT_FALSE(ok);
+
+  array.printTo(json, sizeof(json));
+  ASSERT_STREQ("[[1,2,3],[4,5]]", json);
+}

test/JsonArray_CopyTo_Tests.cpp

@@ -0,0 +1,56 @@
+// 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 <gtest/gtest.h>
+
+TEST(JsonArray_CopyTo_Tests, BiggerOneDimensionIntegerArray) {
+  char json[] = "[1,2,3]";
+
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray& array = jsonBuffer.parseArray(json);
+
+  int destination[4] = {0};
+  size_t result = array.copyTo(destination);
+
+  ASSERT_EQ(3, result);
+  ASSERT_EQ(1, destination[0]);
+  ASSERT_EQ(2, destination[1]);
+  ASSERT_EQ(3, destination[2]);
+  ASSERT_EQ(0, destination[3]);
+}
+
+TEST(JsonArray_CopyTo_Tests, SmallerOneDimensionIntegerArray) {
+  char json[] = "[1,2,3]";
+
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray& array = jsonBuffer.parseArray(json);
+
+  int destination[2] = {0};
+  size_t result = array.copyTo(destination);
+
+  ASSERT_EQ(2, result);
+  ASSERT_EQ(1, destination[0]);
+  ASSERT_EQ(2, destination[1]);
+}
+
+TEST(JsonArray_CopyTo_Tests, TwoOneDimensionIntegerArray) {
+  char json[] = "[[1,2],[3],[4]]";
+
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray& array = jsonBuffer.parseArray(json);
+
+  int destination[3][2] = {{0}};
+  array.copyTo(destination);
+
+  ASSERT_EQ(1, destination[0][0]);
+  ASSERT_EQ(2, destination[0][1]);
+  ASSERT_EQ(3, destination[1][0]);
+  ASSERT_EQ(0, destination[1][1]);
+  ASSERT_EQ(4, destination[2][0]);
+  ASSERT_EQ(0, destination[2][1]);
+}

test/JsonArray_PrintTo_Tests.cpp

@@ -96,6 +96,12 @@ TEST_F(JsonArray_PrintTo_Tests, TwoIntegers) {
   outputMustBe("[1,2]");
 }
 
+TEST_F(JsonArray_PrintTo_Tests, RawJson) {
+  array.add(RawJson("{\"key\":\"value\"}"));
+
+  outputMustBe("[{\"key\":\"value\"}]");
+}
+
 TEST_F(JsonArray_PrintTo_Tests, OneIntegerOverCapacity) {
   array.add(1);
   array.add(2);

test/JsonArray_Subscript_Tests.cpp

@@ -59,6 +59,7 @@ TEST_(StoreBoolean) {
 TEST_(StoreString) {
   _array[0] = "hello";
   EXPECT_STREQ("hello", _array[0].as<const char*>());
+  EXPECT_STREQ("hello", _array[0].as<char*>());  // <- short hand
   EXPECT_TRUE(_array[0].is<const char*>());
   EXPECT_FALSE(_array[0].is<int>());
 }
@@ -69,6 +70,9 @@ TEST_(StoreNestedArray) {
   _array[0] = arr;
 
   EXPECT_EQ(&arr, &_array[0].as<JsonArray&>());
+  EXPECT_EQ(&arr, &_array[0].as<JsonArray>());  // <- short hand
+  EXPECT_EQ(&arr, &_array[0].as<const JsonArray&>());
+  EXPECT_EQ(&arr, &_array[0].as<const JsonArray>());  // <- short hand
   EXPECT_TRUE(_array[0].is<JsonArray&>());
   EXPECT_FALSE(_array[0].is<int>());
 }
@@ -79,6 +83,9 @@ TEST_(StoreNestedObject) {
   _array[0] = obj;
 
   EXPECT_EQ(&obj, &_array[0].as<JsonObject&>());
+  EXPECT_EQ(&obj, &_array[0].as<JsonObject>());  // <- short hand
+  EXPECT_EQ(&obj, &_array[0].as<const JsonObject&>());
+  EXPECT_EQ(&obj, &_array[0].as<const JsonObject>());  // <- short hand
   EXPECT_TRUE(_array[0].is<JsonObject&>());
   EXPECT_FALSE(_array[0].is<int>());
 }

test/JsonObject_Get_Tests.cpp

@@ -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!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class JsonObject_Get_Tests : public ::testing::Test {
+ public:
+  JsonObject_Get_Tests() : _object(_jsonBuffer.createObject()) {}
+
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object;
+};
+
+#define TEST_(name) TEST_F(JsonObject_Get_Tests, name)
+
+TEST_(GetConstCharPointer_GivenStringLiteral) {
+  _object.set("hello", "world");
+  const char* value = _object.get<const char*>("hello");
+  EXPECT_STREQ("world", value);
+}

test/JsonObject_Invalid_Tests.cpp

@@ -5,11 +5,11 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
-#include <gtest/gtest.h>
 #include <ArduinoJson.h>
+#include <gtest/gtest.h>
 
 TEST(JsonObject_Invalid_Tests, SubscriptFails) {
-  ASSERT_FALSE(JsonObject::invalid()[0].success());
+  ASSERT_FALSE(JsonObject::invalid()["key"].success());
 }
 
 TEST(JsonObject_Invalid_Tests, AddFails) {

test/JsonObject_PrintTo_Tests.cpp

@@ -8,8 +8,6 @@
 #include <ArduinoJson.h>
 #include <gtest/gtest.h>
 
-using namespace ArduinoJson::Internals;
-
 class JsonObject_PrintTo_Tests : public testing::Test {
  public:
   JsonObject_PrintTo_Tests() : _object(_jsonBuffer.createObject()) {}
@@ -75,6 +73,12 @@ TEST_F(JsonObject_PrintTo_Tests, TwoIntegers) {
   outputMustBe("{\"a\":1,\"b\":2}");
 }
 
+TEST_F(JsonObject_PrintTo_Tests, RawJson) {
+  _object["a"] = RawJson("[1,2]");
+  _object.set("b", RawJson("[4,5]"));
+  outputMustBe("{\"a\":[1,2],\"b\":[4,5]}");
+}
+
 TEST_F(JsonObject_PrintTo_Tests, TwoDoublesFourDigits) {
   _object["a"] = double_with_n_digits(3.14159265358979323846, 4);
   _object.set("b", 2.71828182845904523536, 4);

test/JsonObject_Set_Tests.cpp

@@ -5,8 +5,8 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
-#include <gtest/gtest.h>
 #include <ArduinoJson.h>
+#include <gtest/gtest.h>
 
 class JsonObject_Set_Tests : public ::testing::Test {
  public:
@@ -107,3 +107,21 @@ TEST_(StoreObjectSubscript) {
 
   EXPECT_EQ(42, _object["a"]);
 }
+
+TEST_(ShouldReturnTrue_WhenAllocationSucceeds) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1) + 15> jsonBuffer;
+  JsonObject& obj = jsonBuffer.createObject();
+
+  bool result = obj.set(std::string("hello"), std::string("world"));
+
+  ASSERT_TRUE(result);
+}
+
+TEST_(ShouldReturnFalse_WhenAllocationFails) {
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1) + 10> jsonBuffer;
+  JsonObject& obj = jsonBuffer.createObject();
+
+  bool result = obj.set(std::string("hello"), std::string("world"));
+
+  ASSERT_FALSE(result);
+}

test/JsonObject_Subscript_Tests.cpp

@@ -68,6 +68,7 @@ TEST_(StoreString) {
   EXPECT_TRUE(_object["hello"].is<const char*>());
   EXPECT_FALSE(_object["hello"].is<long>());
   EXPECT_STREQ("h3110", _object["hello"].as<const char*>());
+  EXPECT_STREQ("h3110", _object["hello"].as<char*>());  // <- short hand
 }
 
 TEST_(StoreArray) {
@@ -75,8 +76,15 @@ TEST_(StoreArray) {
 
   _object["hello"] = arr;
 
-  EXPECT_EQ(&arr, &_object["hello"].asArray());
+  EXPECT_EQ(&arr, &_object["hello"].asArray());  // <- DEPRECATED
+  EXPECT_EQ(&arr, &_object["hello"].as<JsonArray&>());
+  EXPECT_EQ(&arr, &_object["hello"].as<JsonArray>());  // <- short hand
+  EXPECT_EQ(&arr, &_object["hello"].as<const JsonArray&>());
+  EXPECT_EQ(&arr, &_object["hello"].as<const JsonArray>());  // <- short hand
   EXPECT_TRUE(_object["hello"].is<JsonArray&>());
+  EXPECT_TRUE(_object["hello"].is<JsonArray>());
+  EXPECT_TRUE(_object["hello"].is<const JsonArray&>());
+  EXPECT_TRUE(_object["hello"].is<const JsonArray>());
   EXPECT_FALSE(_object["hello"].is<JsonObject&>());
 }
 
@@ -85,8 +93,15 @@ TEST_(StoreObject) {
 
   _object["hello"] = obj;
 
-  EXPECT_EQ(&obj, &_object["hello"].asObject());
+  EXPECT_EQ(&obj, &_object["hello"].asObject());  // DEPRECATED
+  EXPECT_EQ(&obj, &_object["hello"].as<JsonObject&>());
+  EXPECT_EQ(&obj, &_object["hello"].as<JsonObject>());  // <- short hand
+  EXPECT_EQ(&obj, &_object["hello"].as<const JsonObject&>());
+  EXPECT_EQ(&obj, &_object["hello"].as<const JsonObject>());  // <- short hand
   EXPECT_TRUE(_object["hello"].is<JsonObject&>());
+  EXPECT_TRUE(_object["hello"].is<JsonObject>());
+  EXPECT_TRUE(_object["hello"].is<const JsonObject&>());
+  EXPECT_TRUE(_object["hello"].is<const JsonObject>());
   EXPECT_FALSE(_object["hello"].is<JsonArray&>());
 }
 

test/JsonParser_Array_Tests.cpp

@@ -5,12 +5,14 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
-#include <gtest/gtest.h>
 #include <ArduinoJson.h>
+#include <gtest/gtest.h>
 
 class JsonParser_Array_Tests : public testing::Test {
  protected:
-  void whenInputIs(const char *json) { strcpy(_jsonString, json); }
+  void whenInputIs(const char *json) {
+    strcpy(_jsonString, json);
+  }
 
   void whenInputIs(const char *json, size_t len) {
     memcpy(_jsonString, json, len);
@@ -27,7 +29,9 @@ class JsonParser_Array_Tests : public testing::Test {
     EXPECT_EQ(0, _array->size());
   }
 
-  void sizeMustBe(int expected) { ASSERT_EQ(expected, _array->size()); }
+  void sizeMustBe(int expected) {
+    ASSERT_EQ(expected, _array->size());
+  }
 
   template <typename T>
   void firstElementMustBe(T expected) {
@@ -125,6 +129,14 @@ TEST_F(JsonParser_Array_Tests, TwoDoubles) {
   secondElementMustBe(1e2);
 }
 
+TEST_F(JsonParser_Array_Tests, UnsignedLong) {
+  whenInputIs("[4294967295]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe(4294967295UL);
+}
+
 TEST_F(JsonParser_Array_Tests, TwoBooleans) {
   whenInputIs("[true,false]");
 
@@ -338,3 +350,8 @@ TEST_F(JsonParser_Array_Tests, UnfinishedCComment) {
   whenInputIs("[/*COMMENT]");
   parseMustFail();
 }
+
+TEST_F(JsonParser_Array_Tests, DeeplyNested) {
+  whenInputIs("[[[[[[[[[[[[[[[[[[[\"Not too deep\"]]]]]]]]]]]]]]]]]]]");
+  parseMustSucceed();
+}

test/JsonParser_Variant_Tests.cpp

@@ -0,0 +1,98 @@
+// 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 <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonParser_Variant_Test : public testing::Test {
+ protected:
+  void whenInputIs(const char* jsonString) {
+    strcpy(_jsonString, jsonString);
+    _result = _jsonBuffer.parse(_jsonString);
+  }
+
+  template <typename T>
+  void resultMustEqual(T expected) {
+    EXPECT_EQ(expected, _result.as<T>());
+  }
+
+  void resultMustEqual(const char* expected) {
+    EXPECT_STREQ(expected, _result.as<char*>());
+  }
+
+  void resultMustEqual(double expected) {
+    EXPECT_DOUBLE_EQ(expected, _result.as<double>());
+  }
+
+  template <typename T>
+  void resultTypeMustBe() {
+    EXPECT_TRUE(_result.is<T>());
+  }
+
+  void resultMustBeInvalid() {
+    EXPECT_FALSE(_result.success());
+  }
+  void resultMustBeValid() {
+    EXPECT_TRUE(_result.success());
+  }
+
+  template <typename T>
+  void verify(const char* input, T expected) {
+    whenInputIs(input);
+    resultMustBeValid();
+    resultTypeMustBe<T>();
+    resultMustEqual(expected);
+  }
+
+ private:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonVariant _result;
+  char _jsonString[256];
+};
+
+TEST_F(JsonParser_Variant_Test, EmptyObject) {
+  whenInputIs("{}");
+  resultMustBeValid();
+  resultTypeMustBe<JsonObject>();
+}
+
+TEST_F(JsonParser_Variant_Test, EmptyArray) {
+  whenInputIs("[]");
+  resultMustBeValid();
+  resultTypeMustBe<JsonArray>();
+}
+
+TEST_F(JsonParser_Variant_Test, Integer) {
+  verify("42", 42);
+  verify("-42", -42);
+}
+
+TEST_F(JsonParser_Variant_Test, Double) {
+  verify("3.14", 3.14);
+  verify("3.14", 3.14);
+  verify("1E+10", 1E+10);
+  verify("-1E+10", -1E+10);
+  verify("1.234E+10", 1.234E+10);
+  verify("1.79769e+308", 1.79769e+308);
+  verify("-1.79769e+308", -1.79769e+308);
+  verify("1.7976931348623157e+308", 1.7976931348623157e+308);
+  verify("0.017976931348623157e+310", 0.017976931348623157e+310);
+}
+
+TEST_F(JsonParser_Variant_Test, String) {
+  verify("\"hello world\"", "hello world");
+}
+
+TEST_F(JsonParser_Variant_Test, True) {
+  verify("true", true);
+  verify("false", false);
+}
+
+TEST_F(JsonParser_Variant_Test, Invalid) {
+  whenInputIs("{");
+  resultMustBeInvalid();
+}