Set version to 5.6.4

Fixed error in float serialization (issue #324 )
Set version to 5.6.3
2016-07-20 13:16:14 +02:00 · 2016-07-20 13:15:17 +02:00 · 2016-07-19 08:59:42 +02:00 · 2016-07-19 08:57:19 +02:00 · 2016-07-17 18:29:38 +02:00 · 2016-07-17 17:22:58 +02:00
121 changed files with 3293 additions and 2029 deletions
--- a/.clang-format
+++ b/.clang-format
@ -1,3 +1,5 @@
 # http://clang.llvm.org/docs/ClangFormatStyleOptions.html

-BasedOnStyle: Google
+BasedOnStyle: Google
+Standard: Cpp03
+AllowShortFunctionsOnASingleLine: Empty
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.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!
+-->
--- a/.travis.yml
+++ b/.travis.yml
@ -1,15 +1,118 @@
 sudo: false
 language: cpp
+matrix:
+  include:
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.4']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.4
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.5']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.5
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.6']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.6
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.7']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.7
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.8']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.8
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.9']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.9
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-5']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-5
+    - compiler: clang
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.5']
+          packages: ['clang-3.5']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.5
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.6']
+          packages: ['clang-3.6']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.6
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.7']
+          packages: ['clang-3.7']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.7
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
+          packages: ['clang-3.8']
+      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.8
+    - compiler: gcc
+      env: SCRIPT=coverage
+    - os: osx
+      osx_image: beta-xcode6.1
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: beta-xcode6.2
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: beta-xcode6.3
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode6.4
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7.1
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7.2
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: SCRIPT=cmake-osx
+    - env: SCRIPT=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
+    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
+    - env: SCRIPT=arduino VERSION=1.6.8 BOARD=arduino:avr:uno
+    - env: SCRIPT=arduino VERSION=1.6.9 BOARD=arduino:avr:uno
+    - env: SCRIPT=platformio BOARD=uno
+    - env: SCRIPT=platformio BOARD=due
+    - env: SCRIPT=platformio BOARD=esp01
+    - env: SCRIPT=platformio BOARD=teensy31
 cache:
  directories:
    - "~/.platformio"
-env:
-  - COMPILER=gcc
-  - COMPILER=clang
-  - COMPILER=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
-  - COMPILER=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
-  - COMPILER=platformio BOARD=uno
-  - COMPILER=platformio BOARD=due
-  - COMPILER=platformio BOARD=esp01
-  - COMPILER=platformio BOARD=teensy31
-script: scripts/travis/$COMPILER.sh
+script: scripts/travis/$SCRIPT.sh
--- a/ArduinoJson.h
+++ b/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"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,6 +1,79 @@
 ArduinoJson: change log
 =======================

+v5.6.4
+------
+
+* Fixed error in float serialization (issue #324)
+
+v5.6.3
+------
+
+* Improved speed of float serialization (about twice faster)
+* Added `as<JsonArray>()` as a synonym for `as<JsonArray&>()`... (issue #291)
+* Fixed `call of overloaded isinf(double&) is ambiguous` (issue #284)
+
+v5.6.2
+------
+
+* Fixed build when another lib does `#undef isnan` (issue #284)
+
+v5.6.1
+------
+
+* Added missing `#pragma once` (issue #310)
+
+v5.6.0
+------
+
+* ArduinoJson is now a header-only library (issue #199)
+
+v5.5.1
+------
+
+* Fixed compilation error with Intel Galileo (issue #299)
+
+v5.5.0
+------
+
+* Added `JsonVariant::success()` (issue #279)
+* Renamed `JsonVariant::invalid<T>()` to `JsonVariant::defaultValue<T>()`
+
+v5.4.0
+------
+
+* Changed `::String` to `ArduinoJson::String` (issue #275)
+* Changed `::Print` to `ArduinoJson::Print` too
+
+v5.3.0
+------
+
+* Added custom implementation of `ftoa` (issues #266, #267, #269 and #270)
+* Added `JsonVariant JsonBuffer::parse()` (issue #265)
+* Fixed `unsigned long` printed as `signed long` (issue #170)
+
+v5.2.0
+------
+
+* Added `JsonVariant::as<char*>()` as a synonym for `JsonVariant::as<const char*>()` (issue #257)
+* Added example `JsonHttpClient` (issue #256)
+* Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254)
+* Added `RawJson()` to insert pregenerated JSON portions (issue #259)
+
+v5.1.1
+------
+
+* Removed `String` duplication when one replaces a value in a `JsonObject` (PR #232 by @ulion)
+
+v5.1.0
+------
+
+* Added support of `long long` (issue #171)
+* Moved all build settings to `ArduinoJson/Configuration.hpp`
+
+**BREAKING CHANGE**:
+If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
+
 v5.0.8
 ------

@ -44,7 +117,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)
@ -160,14 +233,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;
@ -224,7 +297,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
--- a/CMakeLists.txt
+++ b/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)
--- a/README.md
+++ b/README.md
@ -15,21 +15,24 @@ 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
 --------

-* All Arduino boards
+* All Arduino boards (Uno, Due, Mini, Micro, Yun...)
 * ESP8266
 * Teensy
-* Intel Edison
+* Intel Edison and Galileo
 * PlatformIO
 * Energia
+* RedBearLab boards (BLE Nano...)
 * Computers (Windows, Linux, OSX...)

 See [FAQ: Compatibility issues](https://github.com/bblanchon/ArduinoJson/wiki/Compatibility-issues)
@ -90,31 +93,37 @@ 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'>

 ---

--- a/appveyor.yml
+++ b/appveyor.yml
@ -0,0 +1,18 @@
+version: 5.6.4.{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
+# 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
+- cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
+build_script:
+- cmake --build . --config %CONFIGURATION%
+test_script:
+- ctest -V .
--- a/examples/JsonHttpClient/JsonHttpClient.ino
+++ b/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);
+}
--- a/include/ArduinoJson.h
+++ b/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;
--- a/include/ArduinoJson.hpp
+++ b/include/ArduinoJson.hpp
@ -0,0 +1,21 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "ArduinoJson/DynamicJsonBuffer.hpp"
+#include "ArduinoJson/JsonArray.hpp"
+#include "ArduinoJson/JsonObject.hpp"
+#include "ArduinoJson/StaticJsonBuffer.hpp"
+
+#include "ArduinoJson/Internals/JsonParser.ipp"
+#include "ArduinoJson/JsonArray.ipp"
+#include "ArduinoJson/JsonBuffer.ipp"
+#include "ArduinoJson/JsonObject.ipp"
+#include "ArduinoJson/JsonVariant.ipp"
+
+using namespace ArduinoJson;
--- a/include/ArduinoJson/Configuration.hpp
+++ b/include/ArduinoJson/Configuration.hpp
@ -0,0 +1,89 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#ifdef ARDUINO  // assume this is an embedded platform
+
+// store using float instead of double to reduce the memory usage (issue #134)
+#ifndef ARDUINOJSON_USE_DOUBLE
+#define ARDUINOJSON_USE_DOUBLE 0
+#endif
+
+// store using a long because it usually match the size of a float.
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#define ARDUINOJSON_USE_LONG_LONG 0
+#endif
+#ifndef ARDUINOJSON_USE_INT64
+#define ARDUINOJSON_USE_INT64 0
+#endif
+
+// arduino has its own implementation of String to replace std::string
+#ifndef ARDUINOJSON_USE_ARDUINO_STRING
+#define ARDUINOJSON_USE_ARDUINO_STRING 1
+#endif
+
+// arduino doesn't support STL stream
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#define ARDUINOJSON_ENABLE_STD_STREAM 0
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+#ifdef ARDUINO_ARCH_AVR
+// alignment isn't needed for 8-bit AVR
+#define ARDUINOJSON_ENABLE_ALIGNMENT 0
+#else
+// but must processor needs pointer to be align on word size
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+#endif
+
+#else  // assume this is a computer
+
+// on a computer we have plenty of memory so we can use doubles
+#ifndef ARDUINOJSON_USE_DOUBLE
+#define ARDUINOJSON_USE_DOUBLE 1
+#endif
+
+// use long long when available
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
+#define ARDUINOJSON_USE_LONG_LONG 1
+#else
+#define ARDUINOJSON_USE_LONG_LONG 0
+#endif
+#endif
+
+// use _int64 on old versions of Visual Studio
+#ifndef ARDUINOJSON_USE_INT64
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#define ARDUINOJSON_USE_INT64 1
+#else
+#define ARDUINOJSON_USE_INT64 0
+#endif
+#endif
+
+// on a computer, we can use std::string
+#ifndef ARDUINOJSON_USE_ARDUINO_STRING
+#define ARDUINOJSON_USE_ARDUINO_STRING 0
+#endif
+
+// on a computer, we can assume that the STL is there
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#define ARDUINOJSON_ENABLE_STD_STREAM 1
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+// even if not required, most cpu's are faster with aligned pointers
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+
+#endif
+
+#if ARDUINOJSON_USE_LONG_LONG && ARDUINOJSON_USE_INT64
+#error ARDUINOJSON_USE_LONG_LONG and ARDUINOJSON_USE_INT64 cannot be set together
+#endif
--- a/include/ArduinoJson/Internals/BlockJsonBuffer.hpp
+++ b/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
--- a/include/ArduinoJson/Internals/Comments.hpp
+++ b/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;
+    }
+  }
+}
 }
 }
--- a/include/ArduinoJson/Internals/DummyPrint.hpp
+++ b/include/ArduinoJson/Internals/DummyPrint.hpp
@ -7,7 +7,7 @@

 #pragma once

-#include "../Arduino/Print.hpp"
+#include "../Print.hpp"

 namespace ArduinoJson {
 namespace Internals {
--- a/include/ArduinoJson/Internals/DynamicStringBuilder.hpp
+++ b/include/ArduinoJson/Internals/DynamicStringBuilder.hpp
@ -7,8 +7,8 @@

 #pragma once

-#include "../Arduino/Print.hpp"
-#include "../Arduino/String.hpp"
+#include "../Print.hpp"
+#include "../String.hpp"

 namespace ArduinoJson {
 namespace Internals {
--- a/include/ArduinoJson/Internals/Encoding.hpp
+++ b/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];
+  }
 };
 }
 }
--- a/include/ArduinoJson/Internals/IndentedPrint.hpp
+++ b/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
--- a/include/ArduinoJson/Internals/JsonFloat.hpp
+++ b/include/ArduinoJson/Internals/JsonFloat.hpp
@ -7,15 +7,15 @@

 #pragma once

+#include "../Configuration.hpp"
+
 namespace ArduinoJson {
 namespace Internals {

-#ifdef ARDUINO
-// On embedded platform, we with use float instead of double to keep JsonVariant
-// small (issue #134)
-typedef float JsonFloat;
-#else
+#if ARDUINOJSON_USE_DOUBLE
 typedef double JsonFloat;
+#else
+typedef float JsonFloat;
 #endif
 }
 }
--- a/include/ArduinoJson/Internals/JsonInteger.hpp
+++ b/include/ArduinoJson/Internals/JsonInteger.hpp
@ -7,8 +7,20 @@

 #pragma once

+#include "../Configuration.hpp"
+
 namespace ArduinoJson {
 namespace Internals {
+
+#if ARDUINOJSON_USE_LONG_LONG
+typedef long long JsonInteger;
+typedef unsigned long long JsonUInt;
+#elif ARDUINOJSON_USE_INT64
+typedef __int64 JsonInteger;
+typedef unsigned _int64 JsonUInt;
+#else
 typedef long JsonInteger;
+typedef unsigned long JsonUInt;
+#endif
 }
 }
--- a/include/ArduinoJson/Internals/JsonParser.hpp
+++ b/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 == '.';
+  }
+
+  static inline bool isQuote(char c) {
+    return c == '\'' || c == '\"';
+  }
+
  JsonBuffer *_buffer;
  const char *_readPtr;
  char *_writePtr;
--- a/include/ArduinoJson/Internals/JsonParser.ipp
+++ b/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;
 }
--- a/include/ArduinoJson/Internals/JsonPrintable.hpp
+++ b/include/ArduinoJson/Internals/JsonPrintable.hpp
@ -7,6 +7,7 @@

 #pragma once

+#include "../Configuration.hpp"
 #include "DummyPrint.hpp"
 #include "IndentedPrint.hpp"
 #include "JsonWriter.hpp"
@ -14,7 +15,7 @@
 #include "StaticStringBuilder.hpp"
 #include "DynamicStringBuilder.hpp"

-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+#if ARDUINOJSON_ENABLE_STD_STREAM
 #include "StreamPrintAdapter.hpp"
 #endif

@ -34,7 +35,7 @@ class JsonPrintable {
    return writer.bytesWritten();
  }

-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+#if ARDUINOJSON_ENABLE_STD_STREAM
  std::ostream &printTo(std::ostream &os) const {
    StreamPrintAdapter adapter(os);
    printTo(adapter);
@ -86,7 +87,7 @@ class JsonPrintable {
  const T &downcast() const { return *static_cast<const T *>(this); }
 };

-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+#if ARDUINOJSON_ENABLE_STD_STREAM
 template <typename T>
 inline std::ostream &operator<<(std::ostream &os, const JsonPrintable<T> &v) {
  return v.printTo(os);
--- a/include/ArduinoJson/Internals/JsonVariantAs.hpp
+++ b/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;
+};
+}
+}
--- a/include/ArduinoJson/Internals/JsonVariantContent.hpp
+++ b/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
 };
 }
 }
--- a/include/ArduinoJson/Internals/JsonVariantType.hpp
+++ b/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
--- a/include/ArduinoJson/Internals/JsonWriter.hpp
+++ b/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);
+  }
 };
 }
 }
--- a/include/ArduinoJson/Internals/List.hpp
+++ b/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;
--- a/include/ArduinoJson/Internals/Parse.hpp
+++ b/include/ArduinoJson/Internals/Parse.hpp
@ -0,0 +1,66 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include <stdlib.h>
+
+namespace ArduinoJson {
+namespace Internals {
+template <typename TFloat>
+TFloat parse(const char *);
+
+template <>
+inline float parse<float>(const char *s) {
+  return static_cast<float>(strtod(s, NULL));
+}
+
+template <>
+inline double parse<double>(const char *s) {
+  return strtod(s, NULL);
+}
+
+template <>
+inline long parse<long>(const char *s) {
+  return strtol(s, NULL, 10);
+}
+
+template <>
+inline unsigned long parse<unsigned long>(const char *s) {
+  return strtoul(s, NULL, 10);
+}
+
+template <>
+inline int parse<int>(const char *s) {
+  return atoi(s);
+}
+
+#if ARDUINOJSON_USE_LONG_LONG
+template <>
+inline long long parse<long long>(const char *s) {
+  return strtoll(s, NULL, 10);
+}
+
+template <>
+inline unsigned long long parse<unsigned long long>(const char *s) {
+  return strtoull(s, NULL, 10);
+}
+#endif
+
+#if ARDUINOJSON_USE_INT64
+template <>
+inline __int64 parse<__int64>(const char *s) {
+  return _strtoi64(s, NULL, 10);
+}
+
+template <>
+inline unsigned __int64 parse<unsigned __int64>(const char *s) {
+  return _strtoui64(s, NULL, 10);
+}
+#endif
+}
+}
--- a/include/ArduinoJson/Internals/Prettyfier.hpp
+++ b/include/ArduinoJson/Internals/Prettyfier.hpp
@ -20,24 +20,89 @@ 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) {
+    return unindentIfNeeded() + _sink.write(c);
+  }
+
+  size_t writeBlockOpen(uint8_t c) {
+    return indentIfNeeded() + _sink.write(c);
+  }
+
+  size_t writeColon() {
+    return _sink.write(':') + _sink.write(' ');
+  }
+
+  size_t writeComma() {
+    return _sink.write(',') + _sink.println();
+  }
+
+  size_t writeQuoteOpen() {
+    _inString = true;
+    return indentIfNeeded() + _sink.write('"');
+  }
+
+  size_t writeNormalChar(uint8_t c) {
+    return indentIfNeeded() + _sink.write(c);
+  }
+
+  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;
--- a/include/ArduinoJson/Internals/StaticStringBuilder.hpp
+++ b/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;
--- a/include/ArduinoJson/Internals/StreamPrintAdapter.hpp
+++ b/include/ArduinoJson/Internals/StreamPrintAdapter.hpp
@ -7,9 +7,13 @@

 #pragma once

-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+#include "../Configuration.hpp"

-#include "../Arduino/Print.hpp"
+#if ARDUINOJSON_ENABLE_STD_STREAM
+
+#include "../Print.hpp"
+
+#include <ostream>

 namespace ArduinoJson {
 namespace Internals {
--- a/include/ArduinoJson/JsonArray.hpp
+++ b/include/ArduinoJson/JsonArray.hpp
@ -12,6 +12,10 @@
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonVariant.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsReference.hpp"
+#include "TypeTraits/IsSame.hpp"

 // Returns the size (in bytes) of an array with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@ -36,6 +40,15 @@ 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().
@ -43,59 +56,98 @@ 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(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.
-  FORCE_INLINE bool add(bool value);
-  FORCE_INLINE bool add(float value, uint8_t decimals = 2);
-  FORCE_INLINE bool add(double value, uint8_t decimals = 2);
-  FORCE_INLINE bool add(signed char value);
-  FORCE_INLINE bool add(signed long value);
-  FORCE_INLINE bool add(signed int value);
-  FORCE_INLINE bool add(signed short value);
-  FORCE_INLINE bool add(unsigned char value);
-  FORCE_INLINE bool add(unsigned long value);
-  FORCE_INLINE bool add(unsigned int value);
-  FORCE_INLINE bool add(unsigned short value);
-  FORCE_INLINE bool add(const char *value);
-  FORCE_INLINE bool add(const String &value);
-  FORCE_INLINE bool add(JsonArray &array);
-  FORCE_INLINE bool add(JsonObject &object);
+  //
+  // bool add(bool);
+  // bool add(char);
+  // bool add(long);
+  // bool add(int);
+  // bool add(short);
+  // bool add(float value);
+  // bool add(double value);
+  // bool add(const char*);
  template <typename T>
-  FORCE_INLINE bool add(const T &value);
+  bool add(
+      T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+    return addNode<T>(value);
+  }
+  // bool add(const String&)
+  // bool add(const JsonVariant&);
+  // bool add(JsonArray&);
+  // bool add(JsonObject&);
+  template <typename T>
+  bool add(const T &value,
+           typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+    return addNode<T &>(const_cast<T &>(value));
+  }
+  // bool add(float value, uint8_t decimals);
+  // bool add(double value, uint8_t decimals);
+  template <typename T>
+  bool add(T value, uint8_t decimals,
+           typename TypeTraits::EnableIf<
+               TypeTraits::IsFloatingPoint<T>::value>::type * = 0) {
+    return addNode<JsonVariant>(JsonVariant(value, decimals));
+  }

  // Sets the value at specified index.
-  FORCE_INLINE void set(size_t index, bool value);
-  FORCE_INLINE void set(size_t index, float value, uint8_t decimals = 2);
-  FORCE_INLINE void set(size_t index, double value, uint8_t decimals = 2);
-  FORCE_INLINE void set(size_t index, signed char value);
-  FORCE_INLINE void set(size_t index, signed long value);
-  FORCE_INLINE void set(size_t index, signed int value);
-  FORCE_INLINE void set(size_t index, signed short value);
-  FORCE_INLINE void set(size_t index, unsigned char value);
-  FORCE_INLINE void set(size_t index, unsigned long value);
-  FORCE_INLINE void set(size_t index, unsigned int value);
-  FORCE_INLINE void set(size_t index, unsigned short value);
-  FORCE_INLINE void set(size_t index, const char *value);
-  FORCE_INLINE void set(size_t index, const String &value);
-  FORCE_INLINE void set(size_t index, JsonArray &array);
-  FORCE_INLINE void set(size_t index, JsonObject &object);
+  //
+  // bool set(size_t index, bool value);
+  // bool set(size_t index, long value);
+  // bool set(size_t index, int value);
+  // bool set(size_t index, short value);
  template <typename T>
-  FORCE_INLINE void set(size_t index, const T &value);
+  bool set(
+      size_t index, T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+    return setNodeAt<T>(index, value);
+  }
+  // bool set(size_t index, const String&)
+  // bool set(size_t index, const JsonVariant&);
+  // bool set(size_t index, JsonArray&);
+  // bool set(size_t index, JsonObject&);
+  template <typename T>
+  bool set(size_t index, const T &value,
+           typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+    return setNodeAt<T &>(index, const_cast<T &>(value));
+  }
+  // bool set(size_t index, float value, uint8_t decimals = 2);
+  // bool set(size_t index, double value, uint8_t decimals = 2);
+  template <typename T>
+  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));
+  }

  // Gets the value at the specified index.
-  FORCE_INLINE JsonVariant get(size_t index) const;
+  JsonVariant get(size_t index) const {
+    node_type *node = getNodeAt(index);
+    return node ? node->content : JsonVariant();
+  }

  // 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>() : JsonVariant::defaultValue<T>();
+  }

  // 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()
@ -106,31 +158,111 @@ 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;
+  void writeTo(Internals::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();
+  }
+
+  // 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>
-  void setNodeAt(size_t index, TValue value);
+  bool setNodeAt(size_t index, TValue value) {
+    node_type *node = getNodeAt(index);
+    return node != NULL && setNodeValue<TValue>(node, value);
+  }

  template <typename TValue>
-  bool addNode(TValue);
+  bool addNode(TValue value) {
+    node_type *node = addNewNode();
+    return node != NULL && setNodeValue<TValue>(node, value);
+  }

  template <typename T>
-  FORCE_INLINE void setNodeValue(node_type *, T value);
-
-  // The instance returned by JsonArray::invalid()
-  static JsonArray _invalid;
+  bool setNodeValue(node_type *node, T value) {
+    node->content = value;
+    return true;
+  }
 };
 }
-
-#include "JsonArray.ipp"
--- a/include/ArduinoJson/JsonArray.ipp
+++ b/include/ArduinoJson/JsonArray.ipp
@ -8,213 +8,55 @@
 #pragma once

 #include "JsonArray.hpp"
+#include "JsonObject.hpp"
 #include "JsonArraySubscript.hpp"

 namespace ArduinoJson {

-inline JsonArraySubscript JsonArray::operator[](size_t index) {
-  return JsonArraySubscript(*this, index);
-}
-
-inline JsonVariant JsonArray::operator[](size_t index) const {
-  return get(index);
-}
-
-inline bool JsonArray::add(bool value) { return addNode<bool>(value); }
-
-inline bool JsonArray::add(float value, uint8_t decimals) {
-  return addNode<const JsonVariant &>(JsonVariant(value, decimals));
-}
-
-inline bool JsonArray::add(double value, uint8_t decimals) {
-  return addNode<const JsonVariant &>(JsonVariant(value, decimals));
-}
-
-inline bool JsonArray::add(signed char value) {
-  return addNode<signed char>(value);
-}
-
-inline bool JsonArray::add(signed long value) {
-  return addNode<signed long>(value);
-}
-
-inline bool JsonArray::add(signed int value) {
-  return addNode<signed int>(value);
-}
-
-inline bool JsonArray::add(signed short value) {
-  return addNode<signed short>(value);
-}
-
-inline bool JsonArray::add(unsigned char value) {
-  return addNode<unsigned char>(value);
-}
-
-inline bool JsonArray::add(unsigned long value) {
-  return addNode<unsigned long>(value);
-}
-
-inline bool JsonArray::add(unsigned int value) {
-  return addNode<unsigned int>(value);
-}
-
-inline bool JsonArray::add(unsigned short value) {
-  return addNode<unsigned short>(value);
-}
-
-inline bool JsonArray::add(const char *value) {
-  return addNode<const char *>(value);
-}
-
-inline bool JsonArray::add(const String &value) {
-  return addNode<const String &>(value);
-}
-
-inline bool JsonArray::add(JsonArray &array) {
-  return addNode<JsonArray &>(array);
-}
-
-inline bool JsonArray::add(JsonObject &object) {
-  return addNode<JsonObject &>(object);
-}
-
-template <typename T>
-inline bool JsonArray::add(const T &variant) {
-  return addNode<const JsonVariant &>(variant);
-}
-
-template <typename TValue>
-inline bool JsonArray::addNode(TValue value) {
-  node_type *node = addNewNode();
-  if (node == NULL) return false;
-  setNodeValue<TValue>(node, value);
+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 void JsonArray::set(size_t index, bool value) {
-  return setNodeAt<bool>(index, value);
-}
-
-inline void JsonArray::set(size_t index, float value, uint8_t decimals) {
-  return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
-}
-
-inline void JsonArray::set(size_t index, double value, uint8_t decimals) {
-  return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
-}
-
-inline void JsonArray::set(size_t index, signed char value) {
-  return setNodeAt<signed char>(index, value);
-}
-
-inline void JsonArray::set(size_t index, signed long value) {
-  return setNodeAt<signed long>(index, value);
-}
-
-inline void JsonArray::set(size_t index, signed int value) {
-  return setNodeAt<signed int>(index, value);
-}
-
-inline void JsonArray::set(size_t index, signed short value) {
-  return setNodeAt<signed short>(index, value);
-}
-
-inline void JsonArray::set(size_t index, unsigned char value) {
-  return setNodeAt<unsigned char>(index, value);
-}
-
-inline void JsonArray::set(size_t index, unsigned long value) {
-  return setNodeAt<unsigned long>(index, value);
-}
-
-inline void JsonArray::set(size_t index, unsigned int value) {
-  return setNodeAt<unsigned int>(index, value);
-}
-
-inline void JsonArray::set(size_t index, unsigned short value) {
-  return setNodeAt<unsigned short>(index, value);
-}
-
-inline void JsonArray::set(size_t index, const char *value) {
-  return setNodeAt<const char *>(index, value);
-}
-
-inline void JsonArray::set(size_t index, const String &value) {
-  return setNodeAt<const String &>(index, value);
-}
-
-inline void JsonArray::set(size_t index, JsonArray &array) {
-  return setNodeAt<JsonArray &>(index, array);
-}
-
-inline void JsonArray::set(size_t index, JsonObject &object) {
-  return setNodeAt<JsonObject &>(index, object);
-}
-
-template <typename T>
-inline void JsonArray::set(size_t index, const T &variant) {
-  return setNodeAt<const JsonVariant &>(index, variant);
-}
-
-template <typename TValue>
-inline void JsonArray::setNodeAt(size_t index, TValue value) {
-  node_type *node = getNodeAt(index);
-  if (node == NULL) return;
-  setNodeValue<TValue>(node, value);
-}
-
-template <typename TValue>
-inline void JsonArray::setNodeValue(node_type *node, TValue value) {
-  node->content = value;
-}
-
 template <>
-inline void JsonArray::setNodeValue(node_type *node, const String &value) {
-  node->content = _buffer->strdup(value);
-}
-
-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 &>() {
+inline JsonArray &JsonVariant::defaultValue<JsonArray>() {
  return JsonArray::invalid();
 }

 template <>
-inline JsonArray const &JsonVariant::invalid<JsonArray const &>() {
+inline JsonArray &JsonVariant::defaultValue<JsonArray &>() {
  return JsonArray::invalid();
 }

 template <>
-inline JsonArray &JsonVariant::as<JsonArray &>() const {
+inline const JsonArray &JsonVariant::defaultValue<const JsonArray>() {
+  return JsonArray::invalid();
+}
+
+template <>
+inline const JsonArray &JsonVariant::defaultValue<const JsonArray &>() {
+  return JsonArray::invalid();
+}
+
+inline JsonArray &JsonVariant::asArray() const {
  if (_type == Internals::JSON_ARRAY) return *_content.asArray;
  return JsonArray::invalid();
 }

-template <>
-inline const JsonArray &JsonVariant::as<const JsonArray &>() const {
-  if (_type == Internals::JSON_ARRAY) return *_content.asArray;
-  return JsonArray::invalid();
+inline JsonArray &JsonArray::createNestedArray() {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  add(array);
+  return array;
+}
+
+inline JsonArray &JsonObject::createNestedArray(JsonObjectKey key) {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  setNodeAt<const JsonVariant &>(key, array);
+  return array;
 }
 }
--- a/include/ArduinoJson/JsonArraySubscript.hpp
+++ b/include/ArduinoJson/JsonArraySubscript.hpp
@ -7,7 +7,8 @@

 #pragma once

-#include "JsonSubscriptBase.hpp"
+#include "Configuration.hpp"
+#include "JsonVariantBase.hpp"

 #ifdef _MSC_VER
 #pragma warning(push)
@ -15,28 +16,42 @@
 #endif

 namespace ArduinoJson {
-class JsonArraySubscript : public JsonSubscriptBase<JsonArraySubscript> {
+class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
 public:
  FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
      : _array(array), _index(index) {}

-  using JsonSubscriptBase<JsonArraySubscript>::operator=;
-
  JsonArraySubscript& operator=(const JsonArraySubscript& src) {
-    return assign<const JsonVariant&>(src);
+    _array.set<const JsonVariant&>(_index, src);
+    return *this;
  }

  template <typename T>
-  JsonArraySubscript& operator=(const T& src) {
-    return assign<const JsonVariant&>(src);
+  typename TypeTraits::EnableIf<JsonArray::CanSet<T&>::value,
+                                JsonArraySubscript>::type&
+  operator=(const T& src) {
+    _array.set<T&>(_index, const_cast<T&>(src));
+    return *this;
  }

-  FORCE_INLINE bool success() const { return _index < _array.size(); }
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonArray::CanSet<T>::value,
+                                JsonArraySubscript>::type&
+  operator=(T src) {
+    _array.set<T>(_index, src);
+    return *this;
+  }

-  FORCE_INLINE operator JsonVariant() const { return _array.get(_index); }
+  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);
  }

@ -59,13 +74,23 @@ class JsonArraySubscript : public JsonSubscriptBase<JsonArraySubscript> {
  const size_t _index;
 };

-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+#if ARDUINOJSON_ENABLE_STD_STREAM
 inline std::ostream& operator<<(std::ostream& os,
                                const JsonArraySubscript& source) {
  return source.printTo(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
--- a/include/ArduinoJson/JsonBuffer.hpp
+++ b/include/ArduinoJson/JsonBuffer.hpp
@ -11,12 +11,16 @@
 #include <stdint.h>  // for uint8_t
 #include <string.h>

-#include "Arduino/String.hpp"
 #include "JsonVariant.hpp"
+#include "String.hpp"

 #if defined(__clang__)
+#pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wnon-virtual-dtor"
 #elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic push
+#endif
 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif

@ -94,6 +98,21 @@ class JsonBuffer {
    return parseObject(json.c_str(), nesting);
  }

+  // Generalized version of parseArray() and parseObject(), also works for
+  // integral types.
+  JsonVariant parse(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+
+  // Same with a const char*.
+  // With this overload, the JsonBuffer will make a copy of the string
+  JsonVariant parse(const char *json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parse(strdup(json), nesting);
+  }
+
+  // Same as above with a String class
+  JsonVariant parse(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parse(json.c_str(), nesting);
+  }
+
  // Duplicate a string
  char *strdup(const char *src) {
    return src ? strdup(src, strlen(src)) : NULL;
@ -107,12 +126,11 @@ class JsonBuffer {
 protected:
  // Preserve aligment if nessary
  static FORCE_INLINE size_t round_size_up(size_t bytes) {
-#if defined ARDUINO_ARCH_AVR
-    // alignment isn't needed for 8-bit AVR
-    return bytes;
-#else
+#if ARDUINOJSON_ENABLE_ALIGNMENT
    const size_t x = sizeof(void *) - 1;
    return (bytes + x) & ~x;
+#else
+    return bytes;
 #endif
  }

@ -135,3 +153,11 @@ class JsonBuffer {
  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
--- a/include/ArduinoJson/JsonBuffer.ipp
+++ b/include/ArduinoJson/JsonBuffer.ipp
@ -0,0 +1,46 @@
+// 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();
+}
+
+inline char *ArduinoJson::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;
+}
--- a/include/ArduinoJson/JsonObject.hpp
+++ b/include/ArduinoJson/JsonObject.hpp
@ -7,12 +7,16 @@

 #pragma once

-#include "Arduino/String.hpp"
+#include "String.hpp"
 #include "Internals/JsonBufferAllocated.hpp"
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonPair.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsReference.hpp"
+#include "TypeTraits/IsSame.hpp"

 // Returns the size (in bytes) of an object with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@ -36,117 +40,162 @@ 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);
+  JsonObjectSubscript<const char*> operator[](const char* key);
+  JsonObjectSubscript<const String&> operator[](const String& key);

  // Gets the value associated with the specified key.
-  FORCE_INLINE JsonVariant operator[](JsonObjectKey key) const;
+  JsonVariant operator[](JsonObjectKey key) const {
+    return get(key);
+  }

  // Sets the specified key with the specified value.
-  FORCE_INLINE bool set(const char* key, bool value);
-  FORCE_INLINE bool set(const char* key, float value, uint8_t decimals = 2);
-  FORCE_INLINE bool set(const char* key, double value, uint8_t decimals = 2);
-  FORCE_INLINE bool set(const char* key, signed char value);
-  FORCE_INLINE bool set(const char* key, signed long value);
-  FORCE_INLINE bool set(const char* key, signed int value);
-  FORCE_INLINE bool set(const char* key, signed short value);
-  FORCE_INLINE bool set(const char* key, unsigned char value);
-  FORCE_INLINE bool set(const char* key, unsigned long value);
-  FORCE_INLINE bool set(const char* key, unsigned int value);
-  FORCE_INLINE bool set(const char* key, unsigned short value);
-  FORCE_INLINE bool set(const char* key, const char* value);
-  FORCE_INLINE bool set(const char* key, const String& value);
-  FORCE_INLINE bool set(const char* key, JsonArray& array);
-  FORCE_INLINE bool set(const char* key, JsonObject& object);
-  FORCE_INLINE bool set(const char* key, const JsonVariant& value);
+  // bool set(TKey key, bool value);
+  // bool set(TKey key, char value);
+  // bool set(TKey key, long value);
+  // bool set(TKey key, int value);
+  // bool set(TKey key, short value);
+  // bool set(TKey key, float value);
+  // bool set(TKey key, double value);
+  // bool set(TKey key, const char* value);
+  // bool set(TKey key, RawJson value);
  template <typename T>
-  FORCE_INLINE bool set(const char* key, const T& value);
-
-  FORCE_INLINE bool set(const String& key, bool value);
-  FORCE_INLINE bool set(const String& key, float value, uint8_t decimals = 2);
-  FORCE_INLINE bool set(const String& key, double value, uint8_t decimals = 2);
-  FORCE_INLINE bool set(const String& key, signed char value);
-  FORCE_INLINE bool set(const String& key, signed long value);
-  FORCE_INLINE bool set(const String& key, signed int value);
-  FORCE_INLINE bool set(const String& key, signed short value);
-  FORCE_INLINE bool set(const String& key, unsigned char value);
-  FORCE_INLINE bool set(const String& key, unsigned long value);
-  FORCE_INLINE bool set(const String& key, unsigned int value);
-  FORCE_INLINE bool set(const String& key, unsigned short value);
-  FORCE_INLINE bool set(const String& key, const char* value);
-  FORCE_INLINE bool set(const String& key, const String& value);
-  FORCE_INLINE bool set(const String& key, JsonArray& array);
-  FORCE_INLINE bool set(const String& key, JsonObject& object);
-  FORCE_INLINE bool set(const String& key, const JsonVariant& value);
+  bool set(
+      JsonObjectKey key, T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type* = 0) {
+    return setNodeAt<T>(key, value);
+  }
+  // bool set(Key, String&);
+  // bool set(Key, JsonArray&);
+  // bool set(Key, JsonObject&);
+  // bool set(Key, JsonVariant&);
  template <typename T>
-  FORCE_INLINE bool set(const String& key, const T& value);
+  bool set(JsonObjectKey key, const T& value,
+           typename TypeTraits::EnableIf<CanSet<T&>::value>::type* = 0) {
+    return setNodeAt<T&>(key, const_cast<T&>(value));
+  }
+  // bool set(Key, float value, uint8_t decimals);
+  // bool set(Key, double value, uint8_t decimals);
+  template <typename TValue>
+  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));
+  }

  // Gets the value associated with the specified key.
-  FORCE_INLINE JsonVariant get(JsonObjectKey) const;
+  JsonVariant get(JsonObjectKey key) const {
+    node_type* node = getNodeAt(key.c_str());
+    return node ? node->content.value : JsonVariant();
+  }

  // Gets the value associated with the specified key.
  template <typename T>
-  FORCE_INLINE T get(JsonObjectKey) const;
+  typename Internals::JsonVariantAs<T>::type get(JsonObjectKey key) const {
+    node_type* node = getNodeAt(key.c_str());
+    return node ? node->content.value.as<T>() : JsonVariant::defaultValue<T>();
+  }

  // Checks the type of the value associated with the specified key.
  template <typename T>
-  FORCE_INLINE bool is(JsonObjectKey) const;
+  bool is(JsonObjectKey key) const {
+    node_type* node = getNodeAt(key.c_str());
+    return node ? node->content.value.is<T>() : false;
+  }

  // Creates and adds a JsonArray.
  // This is a shortcut for JsonBuffer::createArray() and JsonObject::add().
-  FORCE_INLINE JsonArray& createNestedArray(const char* key);
-  FORCE_INLINE JsonArray& createNestedArray(const String& key);
+  JsonArray& createNestedArray(JsonObjectKey key);

  // Creates and adds a JsonObject.
  // This is a shortcut for JsonBuffer::createObject() and JsonObject::add().
-  FORCE_INLINE JsonObject& createNestedObject(const char* key);
-  FORCE_INLINE JsonObject& createNestedObject(const String& key);
+  JsonObject& createNestedObject(JsonObjectKey key);

  // Tells weither the specified key is present and associated with a value.
-  FORCE_INLINE bool containsKey(JsonObjectKey key) const;
+  bool containsKey(JsonObjectKey key) const {
+    return getNodeAt(key.c_str()) != NULL;
+  }

  // Removes the specified key and the associated value.
-  void remove(JsonObjectKey key);
+  void remove(JsonObjectKey key) {
+    removeNode(getNodeAt(key.c_str()));
+  }

  // Returns a reference an invalid JsonObject.
  // This object is meant to replace a NULL pointer.
  // This is used when memory allocation or JSON parsing fail.
-  static JsonObject& invalid() { return _invalid; }
+  static JsonObject& invalid() {
+    static JsonObject instance(NULL);
+    return instance;
+  }

  // Serialize the object to the specified JsonWriter
-  void writeTo(Internals::JsonWriter& writer) const;
+  void writeTo(Internals::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();
+  }

 private:
  // Returns the list node that matches the specified key.
-  node_type* getNodeAt(JsonObjectKey key) const;
-
-  node_type* getOrCreateNodeAt(JsonObjectKey key);
-
-  template <typename TKey, typename TValue>
-  FORCE_INLINE bool setNodeAt(TKey key, TValue value);
-
-  template <typename TKey>
-  JsonArray& createArrayAt(TKey key);
-
-  template <typename TKey>
-  JsonObject& createObjectAt(TKey key);
+  node_type* getNodeAt(const char* key) const {
+    for (node_type* node = _firstNode; node; node = node->next) {
+      if (!strcmp(node->content.key, key)) return node;
+    }
+    return NULL;
+  }

  template <typename T>
-  FORCE_INLINE void setNodeKey(node_type*, T key);
+  bool setNodeAt(JsonObjectKey key, T value) {
+    node_type* node = getNodeAt(key.c_str());
+    if (!node) {
+      node = addNewNode();
+      if (!node || !setNodeKey(node, key)) return false;
+    }
+    return setNodeValue<T>(node, value);
+  }
+
+  bool 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 T>
-  FORCE_INLINE void setNodeValue(node_type*, T value);
-
-  // The instance returned by JsonObject::invalid()
-  static JsonObject _invalid;
+  bool setNodeValue(node_type* node, T value) {
+    node->content.value = value;
+    return true;
+  }
 };
 }
-
-#include "JsonObject.ipp"
--- a/include/ArduinoJson/JsonObject.ipp
+++ b/include/ArduinoJson/JsonObject.ipp
@ -7,235 +7,60 @@

 #pragma once

+#include "JsonArray.hpp"
 #include "JsonObject.hpp"
 #include "JsonObjectSubscript.hpp"

 namespace ArduinoJson {

-inline JsonVariant JsonObject::get(JsonObjectKey key) const {
-  node_type *node = getNodeAt(key);
-  return node ? node->content.value : JsonVariant();
-}
-
-template <typename T>
-inline T JsonObject::get(JsonObjectKey key) const {
-  node_type *node = getNodeAt(key);
-  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);
-  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) != NULL;
-}
-
-inline JsonArray &JsonObject::createNestedArray(const char *key) {
-  return createArrayAt<const char *>(key);
-}
-
-inline JsonArray &JsonObject::createNestedArray(const String &key) {
-  return createArrayAt<const String &>(key);
-}
-
-inline JsonObject &JsonObject::createNestedObject(const char *key) {
-  return createObjectAt<const char *>(key);
-}
-
-inline JsonObject &JsonObject::createNestedObject(const String &key) {
-  return createObjectAt<const String &>(key);
-}
-
-inline void JsonObject::remove(JsonObjectKey key) {
-  removeNode(getNodeAt(key));
-}
-
-inline bool JsonObject::set(const char *key, bool value) {
-  return setNodeAt<const char *, bool>(key, value);
-}
-inline bool JsonObject::set(const char *key, float value, uint8_t decimals) {
-  return setNodeAt<const char *, const JsonVariant &>(
-      key, JsonVariant(value, decimals));
-}
-inline bool JsonObject::set(const char *key, double value, uint8_t decimals) {
-  return setNodeAt<const char *, const JsonVariant &>(
-      key, JsonVariant(value, decimals));
-}
-inline bool JsonObject::set(const char *key, signed char value) {
-  return setNodeAt<const char *, signed char>(key, value);
-}
-inline bool JsonObject::set(const char *key, signed long value) {
-  return setNodeAt<const char *, signed long>(key, value);
-}
-inline bool JsonObject::set(const char *key, signed int value) {
-  return setNodeAt<const char *, signed int>(key, value);
-}
-inline bool JsonObject::set(const char *key, signed short value) {
-  return setNodeAt<const char *, signed short>(key, value);
-}
-inline bool JsonObject::set(const char *key, unsigned char value) {
-  return setNodeAt<const char *, unsigned char>(key, value);
-}
-inline bool JsonObject::set(const char *key, unsigned long value) {
-  return setNodeAt<const char *, unsigned long>(key, value);
-}
-inline bool JsonObject::set(const char *key, unsigned int value) {
-  return setNodeAt<const char *, unsigned int>(key, value);
-}
-inline bool JsonObject::set(const char *key, unsigned short value) {
-  return setNodeAt<const char *, unsigned short>(key, value);
-}
-inline bool JsonObject::set(const char *key, const char *value) {
-  return setNodeAt<const char *, const char *>(key, value);
-}
-inline bool JsonObject::set(const char *key, const String &value) {
-  return setNodeAt<const char *, const String &>(key, value);
-}
-inline bool JsonObject::set(const char *key, JsonArray &array) {
-  return setNodeAt<const char *, JsonArray &>(key, array);
-}
-inline bool JsonObject::set(const char *key, JsonObject &object) {
-  return setNodeAt<const char *, JsonObject &>(key, object);
-}
-inline bool JsonObject::set(const char *key, const JsonVariant &value) {
-  return setNodeAt<const char *, const JsonVariant &>(key, value);
-}
-template <typename T>
-inline bool JsonObject::set(const char *key, const T &value) {
-  return setNodeAt<const char *, JsonVariant>(key, value);
-}
-inline bool JsonObject::set(const String &key, bool value) {
-  return setNodeAt<const String &, bool>(key, value);
-}
-inline bool JsonObject::set(const String &key, float value, uint8_t decimals) {
-  return setNodeAt<const String &, const JsonVariant &>(
-      key, JsonVariant(value, decimals));
-}
-inline bool JsonObject::set(const String &key, double value, uint8_t decimals) {
-  return setNodeAt<const String &, const JsonVariant &>(
-      key, JsonVariant(value, decimals));
-}
-inline bool JsonObject::set(const String &key, signed char value) {
-  return setNodeAt<const String &, signed char>(key, value);
-}
-inline bool JsonObject::set(const String &key, signed long value) {
-  return setNodeAt<const String &, signed long>(key, value);
-}
-inline bool JsonObject::set(const String &key, signed int value) {
-  return setNodeAt<const String &, signed int>(key, value);
-}
-inline bool JsonObject::set(const String &key, signed short value) {
-  return setNodeAt<const String &, signed short>(key, value);
-}
-inline bool JsonObject::set(const String &key, unsigned char value) {
-  return setNodeAt<const String &, unsigned char>(key, value);
-}
-inline bool JsonObject::set(const String &key, unsigned long value) {
-  return setNodeAt<const String &, unsigned long>(key, value);
-}
-inline bool JsonObject::set(const String &key, unsigned int value) {
-  return setNodeAt<const String &, unsigned int>(key, value);
-}
-inline bool JsonObject::set(const String &key, unsigned short value) {
-  return setNodeAt<const String &, unsigned short>(key, value);
-}
-inline bool JsonObject::set(const String &key, const char *value) {
-  return setNodeAt<const String &, const char *>(key, value);
-}
-inline bool JsonObject::set(const String &key, const String &value) {
-  return setNodeAt<const String &, const String &>(key, value);
-}
-inline bool JsonObject::set(const String &key, JsonArray &array) {
-  return setNodeAt<const String &, JsonArray &>(key, array);
-}
-inline bool JsonObject::set(const String &key, JsonObject &object) {
-  return setNodeAt<const String &, JsonObject &>(key, object);
-}
-inline bool JsonObject::set(const String &key, const JsonVariant &value) {
-  return setNodeAt<const String &, const JsonVariant &>(key, value);
-}
-template <typename T>
-inline bool JsonObject::set(const String &key, const T &value) {
-  return setNodeAt<const String &, JsonVariant>(key, value);
-}
-
-template <typename TKey, typename TValue>
-inline bool JsonObject::setNodeAt(TKey key, TValue value) {
-  node_type *node = getOrCreateNodeAt(key);
-  if (!node) return false;
-  setNodeKey<TKey>(node, key);
-  setNodeValue<TValue>(node, value);
-  return true;
-}
-
 template <>
-inline void JsonObject::setNodeKey(node_type *node, const char *key) {
-  node->content.key = key;
-}
-
-template <>
-inline void JsonObject::setNodeKey(node_type *node, const String &key) {
-  node->content.key = _buffer->strdup(key);
-}
-
-template <typename TValue>
-inline void JsonObject::setNodeValue(node_type *node, TValue value) {
-  node->content.value = value;
-}
-
-template <>
-inline void JsonObject::setNodeValue(node_type *node, const String &value) {
+inline bool JsonObject::setNodeValue(node_type *node, String &value) {
  node->content.value = _buffer->strdup(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];
+  return node->content.value;
 }

 template <>
-inline JsonObject const &JsonVariant::invalid<JsonObject const &>() {
+inline bool JsonObject::setNodeValue(node_type *node, const String &value) {
+  node->content.value = _buffer->strdup(value);
+  return node->content.value;
+}
+
+template <>
+inline const JsonObject &JsonVariant::defaultValue<const JsonObject &>() {
  return JsonObject::invalid();
 }

 template <>
-inline JsonObject &JsonVariant::invalid<JsonObject &>() {
+inline const JsonObject &JsonVariant::defaultValue<const JsonObject>() {
  return JsonObject::invalid();
 }

 template <>
-inline JsonObject &JsonVariant::as<JsonObject &>() const {
+inline JsonObject &JsonVariant::defaultValue<JsonObject &>() {
+  return JsonObject::invalid();
+}
+
+template <>
+inline JsonObject &JsonVariant::defaultValue<JsonObject>() {
+  return JsonObject::invalid();
+}
+
+inline JsonObject &JsonVariant::asObject() const {
  if (_type == Internals::JSON_OBJECT) return *_content.asObject;
  return JsonObject::invalid();
 }

-template <>
-inline const JsonObject &JsonVariant::as<const JsonObject &>() const {
-  if (_type == Internals::JSON_OBJECT) return *_content.asObject;
-  return JsonObject::invalid();
+inline JsonObject &JsonObject::createNestedObject(JsonObjectKey key) {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &array = _buffer->createObject();
+  setNodeAt<const JsonVariant &>(key, array);
+  return array;
+}
+
+inline JsonObject &JsonArray::createNestedObject() {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  add(object);
+  return object;
 }
 }
--- a/include/ArduinoJson/JsonObjectKey.hpp
+++ b/include/ArduinoJson/JsonObjectKey.hpp
@ -7,19 +7,21 @@

 #pragma once

-#include "Arduino/String.hpp"
+#include "String.hpp"

 namespace ArduinoJson {

+// Represents a key in a JsonObject
 class JsonObjectKey {
 public:
-  JsonObjectKey() {}
-  JsonObjectKey(const char* key) : _data(key) {}
-  JsonObjectKey(const String& key) : _data(key.c_str()) {}
+  JsonObjectKey(const char* key) : _value(key), _needs_copy(false) {}
+  JsonObjectKey(const String& key) : _value(key.c_str()), _needs_copy(true) {}

-  operator const char*() const { return _data; }
+  const char* c_str() const { return _value; }
+  bool needs_copy() const { return _needs_copy; }

 private:
-  const char* _data;
+  const char* _value;
+  bool _needs_copy;
 };
 }
--- a/include/ArduinoJson/JsonObjectSubscript.hpp
+++ b/include/ArduinoJson/JsonObjectSubscript.hpp
@ -7,7 +7,9 @@

 #pragma once

-#include "JsonSubscriptBase.hpp"
+#include "Configuration.hpp"
+#include "JsonVariantBase.hpp"
+#include "TypeTraits/EnableIf.hpp"

 #ifdef _MSC_VER
 #pragma warning(push)
@ -17,31 +19,42 @@
 namespace ArduinoJson {

 template <typename TKey>
-class JsonObjectSubscript
-    : public JsonSubscriptBase<JsonObjectSubscript<TKey> > {
+class JsonObjectSubscript : public JsonVariantBase<JsonObjectSubscript<TKey> > {
 public:
  FORCE_INLINE JsonObjectSubscript(JsonObject& object, TKey key)
      : _object(object), _key(key) {}

-  using JsonSubscriptBase<JsonObjectSubscript<TKey> >::operator=;
-
  JsonObjectSubscript<TKey>& operator=(const JsonObjectSubscript<TKey>& src) {
-    return JsonSubscriptBase<JsonObjectSubscript<TKey> >::template assign<
-        JsonVariant>(src);
+    _object.set<const JsonVariant&>(_key, src);
+    return *this;
  }

  template <typename T>
-  JsonObjectSubscript<TKey>& operator=(const T& src) {
-    return JsonSubscriptBase<JsonObjectSubscript<TKey> >::template assign<
-        JsonVariant>(src);
+  typename TypeTraits::EnableIf<JsonObject::CanSet<T&>::value,
+                                JsonObjectSubscript<TKey> >::type&
+  operator=(const T& src) {
+    _object.set<T&>(_key, const_cast<T&>(src));
+    return *this;
  }

-  FORCE_INLINE bool success() const { return _object.containsKey(_key); }
+  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 operator JsonVariant() const { return _object.get(_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 {
+  FORCE_INLINE typename Internals::JsonVariantAs<TValue>::type as() const {
    return _object.get<TValue>(_key);
  }

@ -52,7 +65,7 @@ class JsonObjectSubscript

  template <typename TValue>
  FORCE_INLINE bool set(TValue value) {
-    return _object.set(_key, value);
+    return _object.set<TValue>(_key, value);
  }

  template <typename TValue>
@ -60,7 +73,9 @@ class JsonObjectSubscript
    return _object.set(_key, value, decimals);
  }

-  FORCE_INLINE JsonVariant get() { return _object.get(_key); }
+  FORCE_INLINE JsonVariant get() {
+    return _object.get(_key);
+  }

  void writeTo(Internals::JsonWriter& writer) const {
    _object.get(_key).writeTo(writer);
@ -71,7 +86,7 @@ class JsonObjectSubscript
  TKey _key;
 };

-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+#if ARDUINOJSON_ENABLE_STD_STREAM
 inline std::ostream& operator<<(
    std::ostream& os, const JsonObjectSubscript<const String&>& source) {
  return source.printTo(os);
@ -82,6 +97,29 @@ inline std::ostream& operator<<(
  return source.printTo(os);
 }
 #endif
+
+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);
+}
+
+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];
+}
+
 }  // namespace ArduinoJson

 #ifdef _MSC_VER
--- a/include/ArduinoJson/JsonPair.hpp
+++ b/include/ArduinoJson/JsonPair.hpp
@ -14,7 +14,7 @@ namespace ArduinoJson {

 // A key value pair for JsonObject.
 struct JsonPair {
-  JsonObjectKey key;
+  const char* key;
  JsonVariant value;
 };
 }
--- a/include/ArduinoJson/JsonSubscriptBase.hpp
+++ b/include/ArduinoJson/JsonSubscriptBase.hpp
@ -1,83 +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 "JsonVariantBase.hpp"
-
-namespace ArduinoJson {
-
-template <typename TImpl>
-class JsonSubscriptBase : public JsonVariantBase<TImpl> {
- public:
-  FORCE_INLINE TImpl& operator=(bool value) { return assign<bool>(value); }
-
-  FORCE_INLINE TImpl& operator=(float value) { return assign<float>(value); }
-
-  FORCE_INLINE TImpl& operator=(double value) { return assign<double>(value); }
-
-  FORCE_INLINE TImpl& operator=(signed char value) {
-    return assign<signed char>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(signed long value) {
-    return assign<signed long>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(signed int value) {
-    return assign<signed int>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(signed short value) {
-    return assign<signed short>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(unsigned char value) {
-    return assign<unsigned char>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(unsigned long value) {
-    return assign<unsigned long>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(unsigned int value) {
-    return assign<unsigned int>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(unsigned short value) {
-    return assign<unsigned short>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(const char* value) {
-    return assign<const char*>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(const String& value) {
-    return assign<const String&>(value);
-  }
-
-  FORCE_INLINE TImpl& operator=(JsonArray& array) {
-    return assign<JsonArray&>(array);
-  }
-
-  FORCE_INLINE TImpl& operator=(JsonObject& object) {
-    return assign<JsonObject&>(object);
-  }
-
-  FORCE_INLINE TImpl& operator=(JsonVariant value) {
-    return assign<const JsonVariant&>(value);
-  }
-
- protected:
-  template <typename TValue>
-  FORCE_INLINE TImpl& assign(TValue value) {
-    TImpl* that = static_cast<TImpl*>(this);
-    that->template set<TValue>(value);
-    return *that;
-  }
-};
-}
--- a/include/ArduinoJson/JsonVariant.hpp
+++ b/include/ArduinoJson/JsonVariant.hpp
@ -13,8 +13,14 @@
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/JsonVariantContent.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/RemoveConst.hpp"
+#include "TypeTraits/RemoveReference.hpp"

 namespace ArduinoJson {

@ -31,61 +37,295 @@ class JsonObject;
 // - a reference to a JsonArray or JsonObject
 class JsonVariant : public JsonVariantBase<JsonVariant> {
 public:
+  template <typename T>
+  struct IsConstructibleFrom;
+
  // 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
  // the JSON string.
-  FORCE_INLINE JsonVariant(float value, uint8_t decimals = 2);
-  FORCE_INLINE JsonVariant(double value, uint8_t decimals = 2);
+  // JsonVariant(double value, uint8_t decimals);
+  // JsonVariant(float value, uint8_t decimals);
+  template <typename T>
+  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.
-  FORCE_INLINE JsonVariant(signed char value);
-  FORCE_INLINE JsonVariant(signed long value);
-  FORCE_INLINE JsonVariant(signed int value);
-  FORCE_INLINE JsonVariant(signed short value);
-  FORCE_INLINE JsonVariant(unsigned char value);
-  FORCE_INLINE JsonVariant(unsigned long value);
-  FORCE_INLINE JsonVariant(unsigned int value);
-  FORCE_INLINE JsonVariant(unsigned short value);
+  // JsonVariant(signed short)
+  // JsonVariant(signed int)
+  // JsonVariant(signed long)
+  template <typename T>
+  JsonVariant(T value,
+              typename TypeTraits::EnableIf<
+                  TypeTraits::IsSignedIntegral<T>::value>::type * = 0) {
+    using namespace Internals;
+    if (value >= 0) {
+      _type = JSON_POSITIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(value);
+    } else {
+      _type = JSON_NEGATIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(-value);
+    }
+  }
+  // JsonVariant(unsigned short)
+  // JsonVariant(unsigned int)
+  // JsonVariant(unsigned long)
+  template <typename T>
+  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);
+  JsonVariant(JsonArray &array) {
+    _type = Internals::JSON_ARRAY;
+    _content.asArray = &array;
+  }

  // Create a JsonVariant containing a reference to an object.
-  FORCE_INLINE JsonVariant(JsonObject &object);
+  JsonVariant(JsonObject &object) {
+    _type = Internals::JSON_OBJECT;
+    _content.asObject = &object;
+  }

  // Get the variant as the specified type.
-  // See cast operators for details.
+  //
+  // short as<signed short>() const;
+  // int as<signed int>() const;
+  // long as<signed long>() const;
  template <typename T>
-  T as() const;
+  const typename TypeTraits::EnableIf<TypeTraits::IsSignedIntegral<T>::value,
+                                      T>::type
+  as() const {
+    return static_cast<T>(asInteger());
+  }
+  //
+  // short as<unsigned short>() const;
+  // int as<unsigned int>() const;
+  // long as<unsigned long>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsUnsignedIntegral<T>::value,
+                                      T>::type
+  as() const {
+    return static_cast<T>(asUnsignedInteger());
+  }
+  //
+  // double as<double>() const;
+  // float as<float>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                      T>::type
+  as() const {
+    return static_cast<T>(asFloat());
+  }
+  //
+  // const String as<String>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, String>::value,
+                                      T>::type
+  as() const {
+    return toString();
+  }
+  //
+  // const char* as<const char*>() const;
+  // const char* as<char*>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
+                                    TypeTraits::IsSame<T, char *>::value,
+                                const char *>::type
+  as() const {
+    return asString();
+  }
+  //
+  // const bool as<bool>() const
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
+                                      T>::type
+  as() const {
+    return asInteger() != 0;
+  }
+  //
+  // JsonArray& as<JsonArray> const;
+  // JsonArray& as<JsonArray&> const;
+  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();
+  }

  // Tells weither the variant has the specified type.
  // Returns true if the variant has type type T, false otherwise.
+  //
+  // short as<short>() const;
+  // int as<int>() const;
+  // long as<long>() const;
  template <typename T>
-  bool is() const;
+  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value,
+                                      bool>::type
+  is() const {
+    return isInteger();
+  }
+  //
+  // double is<double>() const;
+  // float is<float>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                      bool>::type
+  is() const {
+    return isFloat();
+  }
+  //
+  // const bool is<bool>() const
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
+                                      bool>::type
+  is() const {
+    return isBoolean();
+  }
+  //
+  // bool is<const char*>() const;
+  // bool is<char*>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
+                                    TypeTraits::IsSame<T, char *>::value,
+                                bool>::type
+  is() const {
+    return isString();
+  }
+  //
+  // bool is<JsonArray> const;
+  // bool is<JsonArray&> const;
+  // bool is<const JsonArray&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<
+          typename TypeTraits::RemoveConst<
+              typename TypeTraits::RemoveReference<T>::type>::type,
+          JsonArray>::value,
+      bool>::type
+  is() const {
+    return isArray();
+  }
+  //
+  // JsonObject& as<JsonObject> const;
+  // JsonObject& as<JsonObject&> const;
+  // JsonObject& as<const JsonObject&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<
+          typename TypeTraits::RemoveConst<
+              typename TypeTraits::RemoveReference<T>::type>::type,
+          JsonObject>::value,
+      bool>::type
+  is() const {
+    return isObject();
+  }
+
+  // Returns true if the variant has a value
+  bool success() const {
+    return _type != Internals::JSON_UNDEFINED;
+  }

  // Serialize the variant to a JsonWriter
  void writeTo(Internals::JsonWriter &writer) const;

-  // TODO: rename
+  // Value returned if the variant has an incompatible type
  template <typename T>
-  static T invalid();
+  static typename Internals::JsonVariantAs<T>::type defaultValue() {
+    return T();
+  }
+
+  const char *asString() const;
+  JsonArray &asArray() const;
+  JsonObject &asObject() const;

 private:
+  // It's not allowed to store a char
+  template <typename T>
+  JsonVariant(T value, typename TypeTraits::EnableIf<
+                           TypeTraits::IsSame<T, char>::value>::type * = 0);
+
+  String toString() const;
  Internals::JsonFloat asFloat() const;
  Internals::JsonInteger asInteger() const;
+  Internals::JsonUInt asUnsignedInteger() const;
+  bool isBoolean() const;
+  bool isFloat() const;
+  bool isInteger() const;
+  bool isArray() const {
+    return _type == Internals::JSON_ARRAY;
+  }
+  bool isObject() const {
+    return _type == Internals::JSON_OBJECT;
+  }
+  bool isString() const {
+    return _type == Internals::JSON_STRING;
+  }

  // The current type of the variant
  Internals::JsonVariantType _type;
@ -101,7 +341,27 @@ 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);
 }
-}

-// Include inline implementations
-#include "JsonVariant.ipp"
+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, RawJson>::value ||
+      TypeTraits::IsSame<T, JsonArray &>::value ||
+      TypeTraits::IsSame<T, const JsonArray &>::value ||
+      TypeTraits::IsSame<T, JsonArraySubscript &>::value ||
+      TypeTraits::IsSame<T, const JsonArraySubscript &>::value ||
+      TypeTraits::IsSame<T, JsonObject &>::value ||
+      TypeTraits::IsSame<T, const JsonObject &>::value ||
+      TypeTraits::IsSame<T, JsonObjectSubscript<const char *> &>::value ||
+      TypeTraits::IsSame<T, const JsonObjectSubscript<const char *> &>::value ||
+      TypeTraits::IsSame<T, JsonObjectSubscript<String> &>::value ||
+      TypeTraits::IsSame<T, const JsonObjectSubscript<String> &>::value ||
+      TypeTraits::IsSame<T, JsonVariant &>::value ||
+      TypeTraits::IsSame<T, const JsonVariant &>::value;
+};
+}
--- a/include/ArduinoJson/JsonVariant.ipp
+++ b/include/ArduinoJson/JsonVariant.ipp
@ -7,242 +7,171 @@

 #pragma once

+#include "Configuration.hpp"
 #include "JsonVariant.hpp"
+#include "Internals/Parse.hpp"
+#include "JsonArray.hpp"
+#include "JsonObject.hpp"
+
+#include <string.h>  // for strcmp
+#include <errno.h>   // for errno
+#include <stdlib.h>  // for strtol, strtod

 namespace ArduinoJson {

-inline JsonVariant::JsonVariant(bool value) {
+inline Internals::JsonInteger JsonVariant::asInteger() const {
  using namespace Internals;
-  _type = JSON_BOOLEAN;
-  _content.asInteger = static_cast<JsonInteger>(value);
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return 0;
+    case JSON_POSITIVE_INTEGER:
+    case JSON_BOOLEAN:
+      return _content.asInteger;
+    case JSON_NEGATIVE_INTEGER:
+      return -static_cast<Internals::JsonInteger>(_content.asInteger);
+    case JSON_STRING:
+    case JSON_UNPARSED:
+      if (!_content.asString) return 0;
+      if (!strcmp("true", _content.asString)) return 1;
+      return parse<Internals::JsonInteger>(_content.asString);
+    default:
+      return static_cast<Internals::JsonInteger>(_content.asFloat);
+  }
 }

-inline 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(double value, uint8_t decimals) {
+inline Internals::JsonUInt JsonVariant::asUnsignedInteger() const {
  using namespace Internals;
-  _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
-  _content.asFloat = static_cast<JsonFloat>(value);
+  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 JsonVariant::JsonVariant(float value, uint8_t decimals) {
+inline const char *JsonVariant::asString() const {
  using namespace Internals;
-  _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
-  _content.asFloat = static_cast<JsonFloat>(value);
+  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 JsonVariant::JsonVariant(JsonArray &array) {
-  _type = Internals::JSON_ARRAY;
-  _content.asArray = &array;
-}
-
-inline JsonVariant::JsonVariant(JsonObject &object) {
-  _type = Internals::JSON_OBJECT;
-  _content.asObject = &object;
-}
-
-inline JsonVariant::JsonVariant(signed char value) {
+inline Internals::JsonFloat JsonVariant::asFloat() const {
  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
+  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 JsonVariant::JsonVariant(signed int value) {
+inline String JsonVariant::toString() const {
  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
+  String s;
+  if ((_type == JSON_STRING || _type == JSON_UNPARSED) &&
+      _content.asString != NULL)
+    s = _content.asString;
+  else
+    printTo(s);
+  return s;
 }

-inline JsonVariant::JsonVariant(signed long value) {
+inline bool JsonVariant::isBoolean() const {
  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
+  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 JsonVariant::JsonVariant(signed short value) {
+inline bool JsonVariant::isInteger() const {
  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
+  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 JsonVariant::JsonVariant(unsigned char value) {
+inline bool JsonVariant::isFloat() const {
  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
+  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>();
 }

-inline JsonVariant::JsonVariant(unsigned int value) {
+inline void JsonVariant::writeTo(Internals::JsonWriter &writer) const {
  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return;
+
+    case JSON_ARRAY:
+      _content.asArray->writeTo(writer);
+      return;
+
+    case JSON_OBJECT:
+      _content.asObject->writeTo(writer);
+      return;
+
+    case JSON_STRING:
+      writer.writeString(_content.asString);
+      return;
+
+    case JSON_UNPARSED:
+      writer.writeRaw(_content.asString);
+      return;
+
+    case JSON_NEGATIVE_INTEGER:
+      writer.writeRaw('-');
+    case JSON_POSITIVE_INTEGER:
+      writer.writeInteger(_content.asInteger);
+      return;
+
+    case JSON_BOOLEAN:
+      writer.writeBoolean(_content.asInteger != 0);
+      return;
+
+    default:
+      uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
+      writer.writeFloat(_content.asFloat, decimals);
+  }
 }

-inline JsonVariant::JsonVariant(unsigned long value) {
-  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
-}
-
-inline JsonVariant::JsonVariant(unsigned short value) {
-  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
-}
-
-template <>
-String JsonVariant::as<String>() const;
-
-template <>
-const char *JsonVariant::as<const char *>() const;
-
-template <>
-inline bool JsonVariant::as<bool>() const {
-  return asInteger() != 0;
-}
-
-template <>
-inline signed char JsonVariant::as<signed char>() const {
-  return static_cast<signed char>(asInteger());
-}
-
-template <>
-inline unsigned char JsonVariant::as<unsigned char>() const {
-  return static_cast<unsigned char>(asInteger());
-}
-
-template <>
-inline signed short JsonVariant::as<signed short>() const {
-  return static_cast<signed short>(asInteger());
-}
-
-template <>
-inline unsigned short JsonVariant::as<unsigned short>() const {
-  return static_cast<unsigned short>(asInteger());
-}
-
-template <>
-inline signed int JsonVariant::as<signed int>() const {
-  return static_cast<signed int>(asInteger());
-}
-
-template <>
-inline unsigned int JsonVariant::as<unsigned int>() const {
-  return static_cast<unsigned int>(asInteger());
-}
-
-template <>
-inline unsigned long JsonVariant::as<unsigned long>() const {
-  return static_cast<unsigned long>(asInteger());
-}
-
-template <>
-inline signed long JsonVariant::as<signed long>() const {
-  return static_cast<unsigned long>(asInteger());
-}
-
-template <>
-inline double JsonVariant::as<double>() const {
-  return static_cast<double>(asFloat());
-}
-
-template <>
-inline float JsonVariant::as<float>() const {
-  return static_cast<float>(asFloat());
-}
-
-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>();
-}
-
-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+#if ARDUINOJSON_ENABLE_STD_STREAM
 inline std::ostream &operator<<(std::ostream &os, const JsonVariant &source) {
  return source.printTo(os);
 }
--- a/include/ArduinoJson/JsonVariantBase.hpp
+++ b/include/ArduinoJson/JsonVariantBase.hpp
@ -7,8 +7,9 @@

 #pragma once

-#include "Internals/ForceInline.hpp"
+#include "Internals/JsonVariantAs.hpp"
 #include "JsonObjectKey.hpp"
+#include "Polyfills/attributes.hpp"

 namespace ArduinoJson {

@ -20,54 +21,52 @@ class JsonObjectSubscript;
 template <typename TImpl>
 class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
 public:
-  // Gets the variant as a boolean value.
-  // Returns false if the variant is not a boolean value.
-  FORCE_INLINE operator bool() const { return as<bool>(); }
-
-  // Gets the variant as a floating-point value.
-  // Returns 0.0 if the variant is not a floating-point value
-  FORCE_INLINE operator double() const { return as<double>(); }
-  FORCE_INLINE operator float() const { return as<float>(); }
-
-  // Gets the variant as an integer value.
-  // Returns 0 if the variant is not an integer value.
-  FORCE_INLINE operator signed long() const { return as<signed long>(); }
-  FORCE_INLINE operator signed char() const { return as<signed char>(); }
-  FORCE_INLINE operator signed int() const { return as<signed int>(); }
-  FORCE_INLINE operator signed short() const { return as<signed short>(); }
-  FORCE_INLINE operator unsigned char() const { return as<unsigned char>(); }
-  FORCE_INLINE operator unsigned int() const { return as<unsigned int>(); }
-  FORCE_INLINE operator unsigned long() const { return as<unsigned long>(); }
-  FORCE_INLINE operator unsigned short() const { return as<unsigned short>(); }
-
-  // Gets the variant as a string.
-  // Returns NULL if variant is not a string.
-  FORCE_INLINE operator const char *() const { return as<const char *>(); }
-  FORCE_INLINE const char *asString() const { return as<const char *>(); }
-  FORCE_INLINE operator String() const { return as<String>(); }
+  // 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 const T as() const {
+  FORCE_INLINE operator T() const {
+    return as<T>();
+  }
+
+  template <typename T>
+  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.
@ -87,7 +86,9 @@ class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
  void writeTo(Internals::JsonWriter &writer) const;

 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>
--- a/include/ArduinoJson/Internals/ForceInline.hpp
+++ b/include/ArduinoJson/Internals/ForceInline.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
--- a/include/ArduinoJson/Polyfills/math.hpp
+++ b/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
--- a/include/ArduinoJson/Polyfills/normalize.hpp
+++ b/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
+}
+}
--- a/include/ArduinoJson/Arduino/Print.hpp
+++ b/include/ArduinoJson/Arduino/Print.hpp
@ -12,6 +12,7 @@
 #include <stddef.h>
 #include <stdint.h>

+namespace ArduinoJson {
 // This class reproduces Arduino's Print class
 class Print {
 public:
@ -19,12 +20,17 @@ class Print {

  virtual size_t write(uint8_t) = 0;

-  size_t print(const char[]);
-  size_t print(double, int = 2);
-  size_t print(int);
-  size_t print(long);
-  size_t println();
+  size_t print(const char* s) {
+    size_t n = 0;
+    while (*s) {
+      n += write(*s++);
+    }
+    return n;
+  }
+
+  size_t println() { return write('\r') + write('\n'); }
 };
+}

 #else

--- a/include/ArduinoJson/Internals/Unparsed.hpp
+++ b/include/ArduinoJson/Internals/Unparsed.hpp
@ -8,14 +8,14 @@
 #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) {}
+  explicit RawJson(const char* str) : _str(str) {}
  operator const char*() const { return _str; }

 private:
  const char* _str;
 };
 }
-}
--- a/include/ArduinoJson/StaticJsonBuffer.hpp
+++ b/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
--- a/include/ArduinoJson/Arduino/String.hpp
+++ b/include/ArduinoJson/Arduino/String.hpp
@ -7,13 +7,18 @@

 #pragma once

-#ifndef ARDUINO
+#include "Configuration.hpp"

-#include <string>
-typedef std::string String;
-
-#else
+#if ARDUINOJSON_USE_ARDUINO_STRING

 #include <WString.h>

+#else
+
+#include <string>
+
+namespace ArduinoJson {
+typedef std::string String;
+}
+
 #endif
--- a/include/ArduinoJson/TypeTraits/EnableIf.hpp
+++ b/include/ArduinoJson/TypeTraits/EnableIf.hpp
@ -0,0 +1,22 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that return the type T if Condition is true.
+template <bool Condition, typename T = void>
+struct EnableIf {};
+
+template <typename T>
+struct EnableIf<true, T> {
+  typedef T type;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/IsFloatingPoint.hpp
+++ b/include/ArduinoJson/TypeTraits/IsFloatingPoint.hpp
@ -0,0 +1,21 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is a floating point type
+template <typename T>
+struct IsFloatingPoint {
+  static const bool value = IsSame<T, float>::value || IsSame<T, double>::value;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/IsIntegral.hpp
+++ b/include/ArduinoJson/TypeTraits/IsIntegral.hpp
@ -0,0 +1,26 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+#include "IsSame.hpp"
+#include "IsSignedIntegral.hpp"
+#include "IsUnsignedIntegral.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is an integral type.
+template <typename T>
+struct IsIntegral {
+  static const bool value = TypeTraits::IsSignedIntegral<T>::value ||
+                            TypeTraits::IsUnsignedIntegral<T>::value ||
+                            TypeTraits::IsSame<T, char>::value;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/IsReference.hpp
+++ b/include/ArduinoJson/TypeTraits/IsReference.hpp
@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is a reference
+template <typename T>
+struct IsReference {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsReference<T&> {
+  static const bool value = true;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/IsSame.hpp
+++ b/include/ArduinoJson/TypeTraits/IsSame.hpp
@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if types T and U are the same.
+template <typename T, typename U>
+struct IsSame {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsSame<T, T> {
+  static const bool value = true;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/IsSignedIntegral.hpp
+++ b/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;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/IsUnsignedIntegral.hpp
+++ b/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;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/RemoveConst.hpp
+++ b/include/ArduinoJson/TypeTraits/RemoveConst.hpp
@ -0,0 +1,23 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct RemoveConst {
+  typedef T type;
+};
+template <typename T>
+struct RemoveConst<const T> {
+  typedef T type;
+};
+}
+}
--- a/include/ArduinoJson/TypeTraits/RemoveReference.hpp
+++ b/include/ArduinoJson/TypeTraits/RemoveReference.hpp
@ -0,0 +1,23 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that return the type T without the reference modifier.
+template <typename T>
+struct RemoveReference {
+  typedef T type;
+};
+template <typename T>
+struct RemoveReference<T&> {
+  typedef T type;
+};
+}
+}
--- a/library.json
+++ b/library.json
@ -6,7 +6,7 @@
    "type": "git",
    "url": "https://github.com/bblanchon/ArduinoJson.git"
  },
-  "version": "5.0.8",
+  "version": "5.6.4",
  "authors": {
    "name": "Benoit Blanchon",
    "url": "http://blog.benoitblanchon.fr"
--- a/library.properties
+++ b/library.properties
@ -1,5 +1,5 @@
 name=ArduinoJson
-version=5.0.8
+version=5.6.4
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.
--- a/scripts/build-arduino-package.sh
+++ b/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
--- a/scripts/build-old-arduino-package.sh
+++ b/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
--- a/scripts/create-build-envs.sh
+++ b/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
--- a/scripts/travis/arduino.sh
+++ b/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
--- a/scripts/travis/clang.sh
+++ b/scripts/travis/clang.sh
@ -1,10 +0,0 @@
-#!/bin/sh -eux
-
-export CC=clang
-export CXX=clang++
-
-curl -sS https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1
-
-/tmp/bin/cmake .
-make 
-make test
--- a/scripts/travis/cmake-osx.sh
+++ b/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
--- a/scripts/travis/cmake.sh
+++ b/scripts/travis/cmake.sh
@ -0,0 +1,9 @@
+#!/bin/sh -eux
+
+URL=https://cmake.org/files/v3.4/cmake-3.4.3-Linux-x86_64.tar.gz
+
+curl -sS $URL | tar xz -C /tmp --strip 1
+
+/tmp/bin/cmake -DCMAKE_CXX_COMPILER=$CMAKE_CXX_COMPILER .
+make 
+make test
--- a/scripts/travis/coverage.sh
+++ b/scripts/travis/coverage.sh
@ -1,8 +1,5 @@
 #!/bin/sh -eux

-export CC=gcc
-export CXX=g++
-
 curl https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1

 /tmp/bin/cmake -DCOVERAGE=true .
--- a/src/Arduino/Print.cpp
+++ b/src/Arduino/Print.cpp
@ -1,72 +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!
-
-#ifndef ARDUINO
-
-#include "../../include/ArduinoJson/Arduino/Print.hpp"
-
-#include <math.h>   // for isnan() and isinf()
-#include <stdio.h>  // for sprintf()
-
-// only for GCC 4.9+
-#if defined(__GNUC__) && \
-    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
-#pragma GCC diagnostic ignored "-Wfloat-conversion"
-#endif
-
-// Visual Studo 2012 didn't have isnan, nor isinf
-#if defined(_MSC_VER) && _MSC_VER <= 1700
-#include <float.h>
-#define isnan(x) _isnan(x)
-#define isinf(x) (!_finite(x))
-#endif
-
-size_t Print::print(const char s[]) {
-  size_t n = 0;
-  while (*s) {
-    n += write(*s++);
-  }
-  return n;
-}
-
-size_t Print::print(double value, int digits) {
-  // https://github.com/arduino/Arduino/blob/db8cbf24c99dc930b9ccff1a43d018c81f178535/hardware/arduino/sam/cores/arduino/Print.cpp#L218
-  if (isnan(value)) return print("nan");
-  if (isinf(value)) return print("inf");
-
-  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 trying to use scientific notation, since we have sprintf
-    sprintf(tmp, "%g", value);
-  } else {
-    // Here we have the exact same output as Arduino's implementation
-    sprintf(tmp, "%.*f", digits, value);
-  }
-
-  return print(tmp);
-}
-
-size_t Print::print(long value) {
-  char tmp[32];
-  sprintf(tmp, "%ld", value);
-  return print(tmp);
-}
-
-size_t Print::print(int value) {
-  char tmp[32];
-  sprintf(tmp, "%d", value);
-  return print(tmp);
-}
-
-size_t Print::println() { return write('\r') + write('\n'); }
-
-#endif
--- a/src/ArduinoJson.h
+++ b/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"
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -1,66 +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_definitions(
-		-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_definitions(
-		-Wlogical-op
-		-Wnoexcept
-		-Wstrict-null-sentinel
-	)
-endif()
-
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	add_definitions(
-		-Wc++11-compat
-		-Wdeprecated-register
-	)
-endif()
-
-if(MSVC)
-	add_definitions(
-		-D_CRT_SECURE_NO_WARNINGS
-		-W4)
-endif()
-
-add_library(ArduinoJson ${CPP_FILES} ${HPP_FILES} ${IPP_FILES})
-
-target_include_directories(ArduinoJson INTERFACE ${CMAKE_CURRENT_LIST_DIR}/../include)
--- a/src/Internals/Comments.cpp
+++ b/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;
-    }
-  }
-}
--- a/src/Internals/Encoding.cpp
+++ b/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";
--- a/src/Internals/IndentedPrint.cpp
+++ b/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;
-}
--- a/src/Internals/List.cpp
+++ b/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>;
--- a/src/Internals/Prettyfier.cpp
+++ b/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();
-}
--- a/src/Internals/StaticStringBuilder.cpp
+++ b/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;
-}
--- a/src/JsonArray.cpp
+++ b/src/JsonArray.cpp
@ -1,54 +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;
-}
-
-JsonArray &JsonArray::createNestedArray() {
-  if (!_buffer) return JsonArray::invalid();
-  JsonArray &array = _buffer->createArray();
-  add(array);
-  return array;
-}
-
-JsonObject &JsonArray::createNestedObject() {
-  if (!_buffer) return JsonObject::invalid();
-  JsonObject &object = _buffer->createObject();
-  add(object);
-  return object;
-}
-
-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();
-}
--- a/src/JsonBuffer.cpp
+++ b/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;
-}
--- a/src/JsonObject.cpp
+++ b/src/JsonObject.cpp
@ -1,72 +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::getOrCreateNodeAt(JsonObjectKey key) {
-  node_type *existingNode = getNodeAt(key);
-  if (existingNode) return existingNode;
-
-  node_type *newNode = addNewNode();
-  return newNode;
-}
-
-template <typename TKey>
-JsonArray &JsonObject::createArrayAt(TKey key) {
-  if (!_buffer) return JsonArray::invalid();
-  JsonArray &array = _buffer->createArray();
-  setNodeAt<TKey, const JsonVariant &>(key, array);
-  return array;
-}
-template JsonArray &JsonObject::createArrayAt<const char *>(const char *);
-template JsonArray &JsonObject::createArrayAt<const String &>(const String &);
-
-template <typename TKey>
-JsonObject &JsonObject::createObjectAt(TKey key) {
-  if (!_buffer) return JsonObject::invalid();
-  JsonObject &array = _buffer->createObject();
-  setNodeAt<TKey, const JsonVariant &>(key, array);
-  return array;
-}
-template JsonObject &JsonObject::createObjectAt<const char *>(const char *);
-template JsonObject &JsonObject::createObjectAt<const String &>(const String &);
-
-JsonObject::node_type *JsonObject::getNodeAt(JsonObjectKey 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();
-}
--- a/src/JsonVariant.cpp
+++ b/src/JsonVariant.cpp
@ -1,149 +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 {
-
-template <typename TFloat>
-static TFloat parse(const char *);
-
-template <>
-float parse<float>(const char *s) {
-  return static_cast<float>(strtod(s, NULL));
-}
-
-template <>
-double parse<double>(const char *s) {
-  return strtod(s, NULL);
-}
-
-template <>
-long parse<long>(const char *s) {
-  return strtol(s, NULL, 10);
-}
-
-template <>
-int parse<int>(const char *s) {
-  return atoi(s);
-}
-
-template <>
-const char *JsonVariant::as<const char *>() 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;
-}
-
-JsonInteger JsonVariant::asInteger() const {
-  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN) return _content.asInteger;
-
-  if (_type >= JSON_FLOAT_0_DECIMALS)
-    return static_cast<JsonInteger>(_content.asFloat);
-
-  if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString) {
-    if (!strcmp("true", _content.asString)) return 1;
-    return parse<JsonInteger>(_content.asString);
-  }
-
-  return 0L;
-}
-
-template <>
-String JsonVariant::as<String>() 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);
-  }
-}
-}
--- a/test/ArduinoString_Tests.cpp
+++ b/test/ArduinoString_Tests.cpp
@ -219,3 +219,27 @@ TEST_F(ArduinoStringTests, JsonObject_PrettyPrintTo) {
  object.prettyPrintTo(json);
  ASSERT_EQ(String("{\r\n  \"key\": \"value\"\r\n}"), json);
 }
+
+TEST_F(ArduinoStringTests, JsonBuffer_GrowWhenAddingNewKey) {
+  JsonObject &object = _jsonBuffer.createObject();
+  String key1("hello"), key2("world");
+
+  object[key1] = 1;
+  size_t sizeBefore = _jsonBuffer.size();
+  object[key2] = 2;
+  size_t sizeAfter = _jsonBuffer.size();
+
+  ASSERT_GT(sizeAfter - sizeBefore, key2.size());
+}
+
+TEST_F(ArduinoStringTests, JsonBuffer_DontGrowWhenReusingKey) {
+  JsonObject &object = _jsonBuffer.createObject();
+  String key("hello");
+
+  object[key] = 1;
+  size_t sizeBefore = _jsonBuffer.size();
+  object[key] = 2;
+  size_t sizeAfter = _jsonBuffer.size();
+
+  ASSERT_EQ(sizeBefore, sizeAfter);
+}
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -5,26 +5,69 @@
 # 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
+		-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()

-add_executable(ArduinoJsonTests 
-    ${TESTS_FILES}
-    ${GTEST_DIR}/src/gtest-all.cc
-    ${GTEST_DIR}/src/gtest_main.cc)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	add_compile_options(
+		-Wstrict-null-sentinel
+	)

-target_link_libraries(ArduinoJsonTests ArduinoJson)
+	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_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)
--- a/test/DynamicJsonBuffer_Basic_Tests.cpp
+++ b/test/DynamicJsonBuffer_Basic_Tests.cpp
@ -6,11 +6,7 @@
 // If you like this project, please add a star!

 #include <gtest/gtest.h>
-
-#define protected public
-#include <ArduinoJson/DynamicJsonBuffer.hpp>
-
-using namespace ArduinoJson;
+#include <ArduinoJson.h>

 class DynamicJsonBuffer_Basic_Tests : public testing::Test {
 protected:
--- a/test/GbathreeBug.cpp
+++ b/test/GbathreeBug.cpp
@ -6,7 +6,6 @@
 // If you like this project, please add a star!

 #include <gtest/gtest.h>
-#define ARDUINOJSON_ENABLE_STD_STREAM
 #include <ArduinoJson.h>

 class GbathreeBug : public testing::Test {
--- a/test/Issue67.cpp
+++ b/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");
-}
--- a/test/Issue90.cpp
+++ b/test/Issue90.cpp
@ -7,18 +7,18 @@

 #include <gtest/gtest.h>
 #include <limits.h>  // for LONG_MAX
-#define ARDUINOJSON_ENABLE_STD_STREAM
+
+#define ARDUINOJSON_USE_LONG_LONG 0
+#define ARDUINOJSON_USE_INT64 0
 #include <ArduinoJson.h>

 #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>()); }

--- a/test/JsonArray_Add_Tests.cpp
+++ b/test/JsonArray_Add_Tests.cpp
@ -6,7 +6,6 @@
 // If you like this project, please add a star!

 #include <gtest/gtest.h>
-#define ARDUINOJSON_ENABLE_STD_STREAM
 #include <ArduinoJson.h>

 class JsonArray_Add_Tests : public ::testing::Test {
--- a/test/JsonArray_Basic_Tests.cpp
+++ b/test/JsonArray_Basic_Tests.cpp
@ -6,7 +6,6 @@
 // If you like this project, please add a star!

 #include <gtest/gtest.h>
-#define ARDUINOJSON_ENABLE_STD_STREAM
 #include <ArduinoJson.h>

 #define TEST_(name) TEST(JsonArray_Basic_Tests, name)
--- a/test/JsonArray_CopyFrom_Tests.cpp
+++ b/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);
+}
--- a/test/JsonArray_CopyTo_Tests.cpp
+++ b/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]);
+}
--- a/test/JsonArray_PrintTo_Tests.cpp
+++ b/test/JsonArray_PrintTo_Tests.cpp
@ -64,10 +64,25 @@ TEST_F(JsonArray_PrintTo_Tests, OneDoubleDefaultDigits) {
 }

 TEST_F(JsonArray_PrintTo_Tests, OneDoubleFourDigits) {
+  array.add(3.14159265358979323846, 4);
+  outputMustBe("[3.1416]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneDoubleFourDigits_AlternativeSyntax) {
  array.add(double_with_n_digits(3.14159265358979323846, 4));
  outputMustBe("[3.1416]");
 }

+TEST_F(JsonArray_PrintTo_Tests, OneFloatDefaultDigits) {
+  array.add(3.14159f);
+  outputMustBe("[3.14]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneFloatFourDigits) {
+  array.add(3.14159f, 4);
+  outputMustBe("[3.1416]");
+}
+
 TEST_F(JsonArray_PrintTo_Tests, OneInteger) {
  array.add(1);

@ -81,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);
--- a/test/JsonArray_Set_Tests.cpp
+++ b/test/JsonArray_Set_Tests.cpp
@ -6,7 +6,6 @@
 // If you like this project, please add a star!

 #include <gtest/gtest.h>
-#define ARDUINOJSON_ENABLE_STD_STREAM
 #include <ArduinoJson.h>

 class JsonArray_Set_Tests : public ::testing::Test {
--- a/test/JsonArray_Subscript_Tests.cpp
+++ b/test/JsonArray_Subscript_Tests.cpp
@ -5,9 +5,9 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!

-#include <gtest/gtest.h>
-#define ARDUINOJSON_ENABLE_STD_STREAM
 #include <ArduinoJson.h>
+#include <gtest/gtest.h>
+#include <stdint.h>

 class JsonArray_Subscript_Tests : public ::testing::Test {
 protected:
@ -33,6 +33,15 @@ TEST_(StoreInteger) {
  EXPECT_FALSE(_array[0].is<double>());
 }

+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+TEST_(StoreLongLong) {
+  _array[0] = 9223372036854775807;
+  EXPECT_EQ(9223372036854775807, _array[0].as<long long>());
+  EXPECT_TRUE(_array[0].is<int>());
+  EXPECT_FALSE(_array[0].is<double>());
+}
+#endif
+
 TEST_(StoreDouble) {
  _array[0] = 123.45;
  EXPECT_EQ(123.45, _array[0].as<double>());
@ -50,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>());
 }
@ -60,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>());
 }
@ -70,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>());
 }
--- a/test/JsonObject_Iterator_Tests.cpp
+++ b/test/JsonObject_Iterator_Tests.cpp
@ -6,7 +6,6 @@
 // If you like this project, please add a star!

 #include <gtest/gtest.h>
-#define ARDUINOJSON_ENABLE_STD_STREAM
 #include <ArduinoJson.h>

 class JsonObject_Iterator_Test : public testing::Test {
--- a/test/JsonObject_PrintTo_Tests.cpp
+++ b/test/JsonObject_PrintTo_Tests.cpp
@ -5,10 +5,8 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!

-#include <gtest/gtest.h>
 #include <ArduinoJson.h>
-
-using namespace ArduinoJson::Internals;
+#include <gtest/gtest.h>

 class JsonObject_PrintTo_Tests : public testing::Test {
 public:
@ -75,10 +73,17 @@ 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);
-  outputMustBe("{\"a\":3.1416,\"b\":2.7183}");
+  _object.set("c", double_with_n_digits(3.14159265358979323846, 3));
+  outputMustBe("{\"a\":3.1416,\"b\":2.7183,\"c\":3.142}");
 }

 TEST_F(JsonObject_PrintTo_Tests, TwoDoubleDefaultDigits) {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Benoit Blanchon	a498abc14a	Set version to 5.6.4	2016-07-20 13:16:14 +02:00
Benoit Blanchon	c64340a9bb	Fixed error in float serialization (issue #324 )	2016-07-20 13:15:17 +02:00
Benoit Blanchon	79d80a5dbf	Set version to 5.6.3	2016-07-19 08:59:42 +02:00
Benoit Blanchon	7ebff5949f	Fixed `call of overloaded isinf(double&) is ambiguous` (issue #284 )	2016-07-19 08:57:19 +02:00
Benoit Blanchon	434080572c	AppVeyor: Disabled build on MinGW32	2016-07-17 18:29:38 +02:00
Benoit Blanchon	c87a0e97ab	Added `as<JsonArray>()` as a synonym for `as<JsonArray&>()`... (issue #291 )	2016-07-17 17:22:58 +02:00
Benoit Blanchon	2dbd94951c	Improved speed of float serialization (about twice faster)	2016-07-10 16:12:49 +02:00
Benoit Blanchon	1e044f50c7	Set version to 5.6.2	2016-06-30 20:23:58 +02:00
Benoit Blanchon	a7aa98510c	Restored Travis build on all clang version	2016-06-30 20:23:21 +02:00
Benoit Blanchon	729ab56878	Fixed build when another lib does `#undef isnan` (issue #284 )	2016-06-30 20:22:47 +02:00
Benoit Blanchon	907b627e16	Set version to 5.6.1	2016-06-24 09:24:44 +02:00
Benoit Blanchon	10fcca20f8	Added missing `#pragma once` (issue #310 )	2016-06-23 21:27:24 +02:00
Benoit Blanchon	59cd1f1433	Fix packaging script	2016-06-22 21:51:37 +02:00
Benoit Blanchon	4a2c570270	Set version to 5.6.0	2016-06-22 21:42:55 +02:00
Benoit Blanchon	8c7edbd9c3	ArduinoJson is now a header-only library (issue #199 )	2016-06-22 21:41:19 +02:00
Benoit Blanchon	0801e16327	Added GitHub issue template	2016-06-15 10:13:43 +02:00
Benoit Blanchon	0df2a365f5	Set version to 5.5.1	2016-06-06 22:12:48 +02:00
Benoit Blanchon	c7d6d33e6c	Fixed compilation error with Intel Galileo (issue #299 )	2016-06-06 22:10:28 +02:00
Benoit Blanchon	c705f3cfeb	Disabled build on Clang 3.5, 3.6, 3.7 and 3.8 because llvm.org/apt is down	2016-06-06 22:09:34 +02:00
Benoit Blanchon	7fecb36aee	Added Kestutis Liaugminas to the list of donators	2016-06-03 20:16:47 +02:00
Benoit Blanchon	657a2ea8d9	Added Jon Williams to the list of donators	2016-05-23 11:02:19 +02:00
Benoit Blanchon	dd064f4c96	Added Arduino 1.6.9 to the continuous integration	2016-05-22 22:24:31 +02:00
Benoit Blanchon	3bc05b97ea	Set version to 5.5.0	2016-05-22 15:00:09 +02:00
Benoit Blanchon	bbd515f6f6	Added Nick Koumaris to the list of donators	2016-05-22 14:58:48 +02:00
Benoit Blanchon	9b3e3a3d9c	Renamed `JsonVariant::invalid<T>()` to `JsonVariant::defaultValue<T>()`	2016-05-18 09:17:45 +02:00
Benoit Blanchon	a3a2ca4796	Added `JsonVariant::success()` (issue #279 )	2016-05-18 09:15:49 +02:00
Benoit Blanchon	eab13dc565	Added Martijn van den Burg to the list of donators	2016-05-16 20:35:26 +02:00
Benoit Blanchon	bebd1c400c	Added OSX build on Travis	2016-05-15 09:41:53 +02:00
Benoit Blanchon	36d1bb2f52	Added Charles-Henri Hallard to the list of donator	2016-05-08 20:59:59 +02:00
Benoit Blanchon	ae32695c3e	Set version to 5.4.0	2016-05-06 08:46:13 +02:00
Benoit Blanchon	c5d19a4dbd	Changed `::String` to `ArduinoJson::String` (issue #275 )	2016-05-06 08:44:31 +02:00
Benoit Blanchon	78728c6547	Set version to 5.3.0	2016-04-30 09:49:45 +02:00
Benoit Blanchon	a8032f81d9	Added `JsonVariant JsonBuffer::parse()` (issue #265 )	2016-04-30 09:47:53 +02:00
Benoit Blanchon	a138791964	Added custom implementation of `ftoa` (issues #266 , #267 , #269 and #270 )	2016-04-28 18:54:14 +02:00
Benoit Blanchon	f9f002c8f7	Fix `unsigned long` printed as `signed long` (issue #170 )	2016-04-28 08:42:59 +02:00
Benoit Blanchon	f192d5c12e	Set version to 5.2.0	2016-04-16 16:17:19 +02:00
Benoit Blanchon	a6724bd03f	Added `RawJson()` to insert pregenerated JSON portions (issue #259 )	2016-04-16 16:15:01 +02:00
Benoit Blanchon	c77c3f33ef	Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254 )	2016-04-14 20:06:38 +02:00
Benoit Blanchon	623aeee9bf	Added example `JsonHttpClient` (issue #256 )	2016-04-08 20:11:36 +02:00
Benoit Blanchon	a241d53d28	Added `JsonVariant::as<char>()` as a synonym for `JsonVariant::as<const char>()` (issue #257 )	2016-04-05 20:47:04 +02:00
Benoit Blanchon	11500d2ff5	Fixed strange Markdown rendering in README	2016-04-05 10:27:50 +02:00
Benoit Blanchon	85708bc94f	Added Arduino 1.6.8 to the continuous integration	2016-04-05 09:49:12 +02:00
Benoit Blanchon	ba6e8856f2	Added Tweet from @hemalchevli	2016-04-04 22:23:51 +02:00
Benoit Blanchon	c8448b0abf	Added Gustavo Donizeti Gini to the list of donators	2016-02-29 09:27:52 +01:00
Benoit Blanchon	e35248ffc4	Set version to 5.1.1	2016-02-23 21:30:01 +01:00
ulion	b47a3b566a	Removed duplication when one replaces a value in a (PR #232 by @ulion)	2016-02-23 21:27:52 +01:00
Benoit Blanchon	6ab23bd523	Added RedBearLab BLE Nano to the list of supported platforms	2016-02-17 10:24:37 +01:00
Benoit Blanchon	987afff0e9	Travis: added GCC 4.4, 4.5, 4.7, 4.8, 4.9, 5.2 and Clang 3.5, 3.6, 3.7	2016-02-17 10:15:40 +01:00
Benoit Blanchon	564c62f3b3	Set version to 5.1.0	2016-02-14 16:20:33 +01:00
Benoit Blanchon	8733f95e51	Added support of `long long` (issue #171 ) Moved all build settings to `ArduinoJson/Configuration.hpp` Added AppVeyor settings in source tree	2016-02-14 16:18:13 +01:00