Set version to 5.5.0

Added Nick Koumaris to the list of donators
Renamed JsonVariant::invalid<T>() to JsonVariant::defaultValue<T>()
2016-05-22 15:00:09 +02:00 · 2016-05-22 14:58:48 +02:00 · 2016-05-18 09:17:45 +02:00 · 2016-05-18 09:15:49 +02:00 · 2016-05-16 20:35:26 +02:00 · 2016-05-15 09:41:53 +02:00
149 changed files with 2738 additions and 1375 deletions
--- a/.clang-format
+++ b/.clang-format
@ -1,3 +1,4 @@
 # http://clang.llvm.org/docs/ClangFormatStyleOptions.html

-BasedOnStyle: Google
+BasedOnStyle: Google
+Standard: Cpp03
--- a/.travis.yml
+++ b/.travis.yml
@ -1,20 +1,117 @@
-language: c++
-compiler:
-  - gcc
-  - clang
-before_install:
-  - "/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16"
-  - sleep 3
-  - export DISPLAY=:1.0
-  - wget http://downloads.arduino.cc/arduino-1.6.5-linux64.tar.xz
-  - tar xf arduino-1.6.5-linux64.tar.xz
-  - sudo mv arduino-1.6.5 /usr/local/share/arduino
-  - sudo ln -s /usr/local/share/arduino/arduino /usr/local/bin/arduino
-  - sudo ln -s $PWD /usr/local/share/arduino/libraries/ArduinoJson
-  - sudo pip install cpp-coveralls
-script:
-  - cmake -DCOVERAGE=true . && make && make test
-  - arduino --verify --board arduino:avr:uno $PWD/examples/JsonParserExample/JsonParserExample.ino
-  - arduino --verify --board arduino:avr:uno $PWD/examples/JsonGeneratorExample/JsonGeneratorExample.ino
-after_success:
-    - if [ "$CC" = "gcc" ]; then coveralls --exclude third-party --gcov-options '\-lp'; fi
+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=platformio BOARD=uno
+    - env: SCRIPT=platformio BOARD=due
+    - env: SCRIPT=platformio BOARD=esp01
+    - env: SCRIPT=platformio BOARD=teensy31
+cache:
+  directories:
+    - "~/.platformio"
+script: scripts/travis/$SCRIPT.sh
--- a/ArduinoJson.h
+++ b/ArduinoJson.h
@ -0,0 +1,14 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+// About this file
+// ---------------
+// This file is here for [PlatformIO](http://platformio.org/).
+// It must be present in the root for the tool to find it.
+// Feel free to ignore this file if your working in another environment.
+
+#include "include/ArduinoJson.h"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,10 +1,74 @@
 ArduinoJson: change log
 =======================

+v5.5.0
+------
+
+* Added `JsonVariant::success()` (issue #279)
+* Renamed `JsonVariant::invalid<T>()` to `JsonVariant::defaultValue<T>()`
+
+v5.4.0
+------
+
+* Changed `::String` to `ArduinoJson::String` (issue #275)
+* Changed `::Print` to `ArduinoJson::Print` too
+
+v5.3.0
+------
+
+* Added custom implementation of `ftoa` (issues #266, #267, #269 and #270)
+* Added `JsonVariant JsonBuffer::parse()` (issue #265)
+* Fixed `unsigned long` printed as `signed long` (issue #170)
+
+v5.2.0
+------
+
+* Added `JsonVariant::as<char*>()` as a synonym for `JsonVariant::as<const char*>()` (issue #257)
+* Added example `JsonHttpClient` (issue #256)
+* Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254)
+* Added `RawJson()` to insert pregenerated JSON portions (issue #259)
+
+v5.1.1
+------
+
+* Removed `String` duplication when one replaces a value in a `JsonObject` (PR #232 by @ulion)
+
+v5.1.0
+------
+
+* Added support of `long long` (issue #171)
+* Moved all build settings to `ArduinoJson/Configuration.hpp`
+
+**BREAKING CHANGE**:
+If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
+
+v5.0.8
+------
+
+* Made the library compatible with [PlatformIO](http://platformio.org/) (issue #181)
+* Fixed `JsonVariant::is<bool>()` that was incorrectly returning false (issue #214)
+
+v5.0.7
+------
+
+* Made library easier to use from a CMake project: simply `add_subdirectory(ArduinoJson/src)`
+* Changed `String` to be a `typedef` of `std::string` (issues #142 and #161)
+
+**BREAKING CHANGES**:
+- `JsonVariant(true).as<String>()` now returns `"true"` instead of `"1"`
+- `JsonVariant(false).as<String>()` now returns `"false"` instead of `"0"`
+
+v5.0.6
+------
+
+* Added parameter to `DynamicJsonBuffer` constructor to set initial size (issue #152)
+* Fixed warning about library category in Arduino 1.6.6 (issue #147)
+* Examples: Added a loop to wait for serial port to be ready (issue #156)
+
 v5.0.5
 ------

-* Add overload `JsonObjectSuscript::set(value, decimals)` (issue #143)
+* Added overload `JsonObjectSuscript::set(value, decimals)` (issue #143)
 * Use `float` instead of `double` to reduce the size of `JsonVariant` (issue #134)

 v5.0.4
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,4 +1,11 @@
-cmake_minimum_required(VERSION 2.8.4)
+# Copyright Benoit Blanchon 2014-2016
+# MIT License
+# 
+# Arduino JSON library
+# https://github.com/bblanchon/ArduinoJson
+# If you like this project, please add a star!
+
+cmake_minimum_required(VERSION 2.8.12)
 project(ArduinoJson)

 enable_testing()
@ -7,10 +14,6 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)

-if(MSVC)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS -W4)
-endif()
-
 if(${COVERAGE})
 	set(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
 endif()
--- a/LICENSE.md
+++ b/LICENSE.md
@ -1,7 +1,7 @@
 The MIT License (MIT)
 ---------------------

-Copyright © 2014-2015 Benoit BLANCHON
+Copyright © 2014-2016 Benoit BLANCHON

 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

--- a/README.md
+++ b/README.md
@ -1,7 +1,7 @@
 Arduino JSON library
 ====================

-[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master) 
+[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master) [![Star this project](http://githubbadges.com/star.svg?user=bblanchon&repo=ArduinoJson&style=flat&color=fff&background=007ec6)](https://github.com/bblanchon/ArduinoJson)

 *An elegant and efficient JSON library for embedded systems.*

@ -15,7 +15,8 @@ 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
@ -24,11 +25,17 @@ Features
 Works on
 --------

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

+See [FAQ: Compatibility issues](https://github.com/bblanchon/ArduinoJson/wiki/Compatibility-issues)
+
 Quick start
 -----------

@ -85,19 +92,36 @@ From StackOverflow user `thegreendroid`:
 > It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.

 From GitHub user `zacsketches`:
-
 > Thanks for a great library!!!
 > I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
 > ArduinoJson saved me a week's worth of time!!

 [From Reddit user `erm_what_`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusjk8c):
-
 > This is a great library and I wouldn't be able to do the project I'm doing without it. I completely recommend it.

 [From Reddit user `makerhacks`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusqg7b):
-
 > I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.

+[From Twitter user `@hemalchevli`](https://twitter.com/hemalchevli/status/715788439397011456):
+> ArduinoJson library should be used as a benchmark/reference for making libraries. Truly elegant.
+
+Donators
+--------
+
+Special thanks to the following persons and companies who made generous donations to the library author:
+
+* Robert Murphy <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Surge Communications <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Alex Scott <img alt='United Kingdom' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1e7.svg' width='18' height='18'>
+* Firepick Services LLC <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* A B Doodkorte <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
+* Scott Smith <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Johann Stieger <img alt='Austria' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e6-1f1f9.svg' width='18' height='18'>
+* Gustavo Donizeti Gini <img alt='Brazil' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e7-1f1f7.svg' width='18' height='18'>
+* Charles-Henri Hallard <img alt='France' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1eb-1f1f7.svg' width='18' height='18'>
+* Martijn van den Burg <img alt='Netherlands' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f3-1f1f1.svg' width='18' height='18'>
+* Nick Koumaris <img alt='Greece' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1ec-1f1f7.svg' width='18' height='18'>
+
 ---

 Found this library useful? Please star this project or [help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:
--- a/appveyor.yml
+++ b/appveyor.yml
@ -0,0 +1,16 @@
+version: 5.5.0.{build}
+environment:
+  matrix:
+  - CMAKE_GENERATOR: Visual Studio 14 2015
+  - CMAKE_GENERATOR: Visual Studio 12 2013
+  - CMAKE_GENERATOR: Visual Studio 11 2012
+  - CMAKE_GENERATOR: Visual Studio 10 2010
+  - CMAKE_GENERATOR: MinGW Makefiles
+configuration: Debug
+before_build:
+- set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW
+- cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
+build_script:
+- cmake --build . --config %CONFIGURATION%
+test_script:
+- ctest -V .
--- a/examples/IndentedPrintExample/IndentedPrintExample.ino
+++ b/examples/IndentedPrintExample/IndentedPrintExample.ino
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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>

@ -10,7 +11,9 @@ using namespace ArduinoJson::Internals;

 void setup() {
  Serial.begin(9600);
-  // delay(1000); <--needed for some boards (like Teensy)
+  while (!Serial) {
+    // wait serial port initialization
+  }

  IndentedPrint serial(Serial);
  serial.setTabSize(4);
--- a/examples/JsonGeneratorExample/JsonGeneratorExample.ino
+++ b/examples/JsonGeneratorExample/JsonGeneratorExample.ino
@ -1,21 +1,48 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #include <ArduinoJson.h>

 void setup() {
  Serial.begin(9600);
-  // delay(1000); <--needed for some boards (like Teensy)
+  while (!Serial) {
+    // wait serial port initialization
+  }

+  // Memory pool for JSON object tree.
+  //
+  // Inside the brackets, 200 is the size of the pool in bytes.
+  // If the JSON object is more complex, you need to increase that value.
  StaticJsonBuffer<200> jsonBuffer;

+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
+  // It's simpler but less efficient.
+  //
+  // DynamicJsonBuffer  jsonBuffer;
+
+  // Create the root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
  JsonObject& root = jsonBuffer.createObject();
+
+  // Add values in the object
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do root.set<long>("time", 1351824120);
  root["sensor"] = "gps";
  root["time"] = 1351824120;

+  // Add a nested array.
+  //
+  // It's also possible to create the array separately and add it to the
+  // JsonObject but it's less efficient.
  JsonArray& data = root.createNestedArray("data");
  data.add(double_with_n_digits(48.756080, 6));
  data.add(double_with_n_digits(2.302038, 6));
--- 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/examples/JsonParserExample/JsonParserExample.ino
+++ b/examples/JsonParserExample/JsonParserExample.ino
@ -1,32 +1,61 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #include <ArduinoJson.h>

 void setup() {
  Serial.begin(9600);
-  // delay(1000); <--needed for some boards (like Teensy)
+  while (!Serial) {
+    // wait serial port initialization
+  }

+  // Memory pool for JSON object tree.
+  //
+  // Inside the brackets, 200 is the size of the pool in bytes,
+  // If the JSON object is more complex, you need to increase that value.
  StaticJsonBuffer<200> jsonBuffer;

+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
+  // It's simpler but less efficient.
+  //
+  // DynamicJsonBuffer  jsonBuffer;
+
+  // JSON input string.
+  //
+  // It's better to use a char[] as shown here.
+  // If you use a const char* or a String, ArduinoJson will
+  // have to make a copy of the input in the JsonBuffer.
  char json[] =
      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";

+  // Root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
  JsonObject& root = jsonBuffer.parseObject(json);

+  // Test if parsing succeeds.
  if (!root.success()) {
    Serial.println("parseObject() failed");
    return;
  }

+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do root["time"].as<long>();
  const char* sensor = root["sensor"];
  long time = root["time"];
  double latitude = root["data"][0];
  double longitude = root["data"][1];

+  // Print values.
  Serial.println(sensor);
  Serial.println(time);
  Serial.println(latitude, 6);
--- a/examples/JsonUdpBeacon/JsonUdpBeacon.ino
+++ b/examples/JsonUdpBeacon/JsonUdpBeacon.ino
@ -3,7 +3,7 @@
 // You can easily test this program with netcat:
 // $ nc -ulp 8888
 //
-// by Benoit Blanchon, MIT License 2015
+// by Benoit Blanchon, MIT License 2015-2016

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

 #include "ArduinoJson/DynamicJsonBuffer.hpp"
 #include "ArduinoJson/JsonArray.hpp"
--- a/include/ArduinoJson/Arduino/String.hpp
+++ b/include/ArduinoJson/Arduino/String.hpp
@ -1,27 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#pragma once
-
-#ifndef ARDUINO
-
-#include <string>
-
-// This class reproduces Arduino's String class
-class String : public std::string {
- public:
-  String(const char *cstr = "") : std::string(cstr) {}
-  String(const String &str) : std::string(str) {}
-  explicit String(long);
-  explicit String(int);
-  explicit String(double, unsigned char decimalPlaces = 2);
-};
-
-#else
-
-#include <WString.h>
-
-#endif
--- 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/DynamicJsonBuffer.hpp
+++ b/include/ArduinoJson/DynamicJsonBuffer.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

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

 #pragma once

@ -31,7 +32,8 @@ class BlockJsonBuffer : public JsonBuffer {
  };

 public:
-  BlockJsonBuffer() : _head(NULL) {}
+  BlockJsonBuffer(size_t initialSize = 256)
+      : _head(NULL), _nextBlockSize(initialSize) {}

  ~BlockJsonBuffer() {
    Block* currentBlock = _head;
@ -55,8 +57,6 @@ class BlockJsonBuffer : public JsonBuffer {
  }

 private:
-  static const size_t FIRST_BLOCK_CAPACITY = 32;
-
  bool canAllocInHead(size_t bytes) const {
    return _head != NULL && _head->size + bytes <= _head->capacity;
  }
@ -68,10 +68,10 @@ class BlockJsonBuffer : public JsonBuffer {
  }

  void* allocInNewBlock(size_t bytes) {
-    size_t capacity = FIRST_BLOCK_CAPACITY;
-    if (_head != NULL) capacity = _head->capacity * 2;
+    size_t capacity = _nextBlockSize;
    if (bytes > capacity) capacity = bytes;
    if (!addNewBlock(capacity)) return NULL;
+    _nextBlockSize *= 2;
    return allocInHead(bytes);
  }

@ -86,8 +86,9 @@ class BlockJsonBuffer : public JsonBuffer {
    return true;
  }

-  Block* _head;
  TAllocator _allocator;
+  Block* _head;
+  size_t _nextBlockSize;
 };
 }
 }
--- a/include/ArduinoJson/Internals/Comments.hpp
+++ b/include/ArduinoJson/Internals/Comments.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/Internals/DummyPrint.hpp
+++ b/include/ArduinoJson/Internals/DummyPrint.hpp
@ -1,12 +1,13 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

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

 namespace ArduinoJson {
 namespace Internals {
--- a/include/ArduinoJson/Internals/DynamicStringBuilder.hpp
+++ b/include/ArduinoJson/Internals/DynamicStringBuilder.hpp
@ -1,13 +1,14 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

-#include "../Arduino/Print.hpp"
-#include "../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
@ -1,12 +1,13 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

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

 namespace ArduinoJson {
 namespace Internals {
@ -32,8 +33,8 @@ class Encoding {
    }
  }

-private:
-	static const char _escapeTable[];
+ private:
+  static const char _escapeTable[];
 };
 }
 }
--- a/include/ArduinoJson/Internals/ForceInline.hpp
+++ b/include/ArduinoJson/Internals/ForceInline.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

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

 #pragma once

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

 namespace ArduinoJson {
 namespace Internals {
--- a/include/ArduinoJson/Internals/JsonBufferAllocated.hpp
+++ b/include/ArduinoJson/Internals/JsonBufferAllocated.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/Internals/JsonFloat.hpp
+++ b/include/ArduinoJson/Internals/JsonFloat.hpp
@ -1,20 +1,21 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

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

-#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
@ -1,13 +1,26 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

+#include "../Configuration.hpp"
+
 namespace ArduinoJson {
 namespace Internals {
+
+#if ARDUINOJSON_USE_LONG_LONG
+typedef long long JsonInteger;
+typedef unsigned long long JsonUInt;
+#elif ARDUINOJSON_USE_INT64
+typedef __int64 JsonInteger;
+typedef unsigned _int64 JsonUInt;
+#else
 typedef long JsonInteger;
+typedef unsigned long JsonUInt;
+#endif
 }
 }
--- a/include/ArduinoJson/Internals/JsonParser.hpp
+++ b/include/ArduinoJson/Internals/JsonParser.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -26,6 +27,12 @@ class JsonParser {
  JsonArray &parseArray();
  JsonObject &parseObject();

+  JsonVariant parseVariant() {
+    JsonVariant result;
+    parseAnythingTo(&result);
+    return result;
+  }
+
 private:
  bool skip(char charToSkip);

--- a/include/ArduinoJson/Internals/JsonPrintable.hpp
+++ b/include/ArduinoJson/Internals/JsonPrintable.hpp
@ -1,11 +1,13 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

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

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

@ -33,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);
@ -85,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/JsonVariantContent.hpp
+++ b/include/ArduinoJson/Internals/JsonVariantContent.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -19,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
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -15,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
@ -1,12 +1,16 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

-#include "../Arduino/Print.hpp"
+#include "../Polyfills/isInfinity.hpp"
+#include "../Polyfills/isNaN.hpp"
+#include "../Polyfills/normalize.hpp"
+#include "../Print.hpp"
 #include "Encoding.hpp"
 #include "ForceInline.hpp"
 #include "JsonFloat.hpp"
@ -31,49 +35,107 @@ class JsonWriter {
  // number of bytes written.
  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, int 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 correctly so that print(1.999, 2) prints as "2.00"
+    JsonFloat rounding = 0.5;
+    for (uint8_t i = 0; i < digits; ++i) rounding /= 10.0;
+
+    value += rounding;
+
+    // Extract the integer part of the value and print it
+    JsonUInt int_part = static_cast<JsonUInt>(value);
+    JsonFloat remainder = value - static_cast<JsonFloat>(int_part);
+    writeInteger(int_part);
+
+    // Print the decimal point, but only if there are digits beyond
+    if (digits > 0) {
+      writeRaw('.');
+    }
+
+    // Extract digits from the remainder one at a time
+    while (digits-- > 0) {
+      remainder *= 10.0;
+      JsonUInt toPrint = JsonUInt(remainder);
+      writeInteger(JsonUInt(remainder));
+      remainder -= static_cast<JsonFloat>(toPrint);
+    }
+
+    if (powersOf10 < 0) {
+      writeRaw("e-");
+      writeInteger(-powersOf10);
+    }
+
+    if (powersOf10 > 0) {
+      writeRaw('e');
+      writeInteger(powersOf10);
+    }
  }

-  void writeRaw(const char *s) { return write(s); }
+  void writeInteger(JsonUInt value) {
+    char buffer[22];
+
+    uint8_t i = 0;
+    do {
+      buffer[i++] = static_cast<char>(value % 10 + '0');
+      value /= 10;
+    } while (value);
+
+    while (i > 0) {
+      writeRaw(buffer[--i]);
+    }
+  }
+
+  void writeRaw(const char *s) { _length += _sink.print(s); }
+  void writeRaw(char c) { _length += _sink.write(c); }

 protected:
-  void write(char c) { _length += _sink.write(c); }
-  FORCE_INLINE void write(const char *s) { _length += _sink.print(s); }
-
  Print &_sink;
  size_t _length;

--- a/include/ArduinoJson/Internals/List.hpp
+++ b/include/ArduinoJson/Internals/List.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/Internals/ListConstIterator.hpp
+++ b/include/ArduinoJson/Internals/ListConstIterator.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/Internals/ListIterator.hpp
+++ b/include/ArduinoJson/Internals/ListIterator.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/Internals/ListNode.hpp
+++ b/include/ArduinoJson/Internals/ListNode.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- 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
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/Internals/ReferenceType.hpp
+++ b/include/ArduinoJson/Internals/ReferenceType.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/Internals/StaticStringBuilder.hpp
+++ b/include/ArduinoJson/Internals/StaticStringBuilder.hpp
@ -1,12 +1,13 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

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

 namespace ArduinoJson {
 namespace Internals {
--- a/include/ArduinoJson/Internals/StreamPrintAdapter.hpp
+++ b/include/ArduinoJson/Internals/StreamPrintAdapter.hpp
@ -1,14 +1,19 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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 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 {
@ -31,4 +36,4 @@ class StreamPrintAdapter : public Print {
 }
 }

-#endif // ARDUINOJSON_ENABLE_STD_STREAM
+#endif  // ARDUINOJSON_ENABLE_STD_STREAM
--- a/include/ArduinoJson/Internals/Unparsed.hpp
+++ b/include/ArduinoJson/Internals/Unparsed.hpp
@ -1,20 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#pragma once
-
-namespace ArduinoJson {
-namespace Internals {
-class Unparsed {
- public:
-  explicit Unparsed(const char* str) : _str(str) {}
-  operator const char*() const { return _str; }
-
- private:
-  const char* _str;
-};
-}
-}
--- a/include/ArduinoJson/JsonArray.hpp
+++ b/include/ArduinoJson/JsonArray.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -11,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.
@ -35,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().
@ -48,42 +62,74 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  FORCE_INLINE 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);
+  FORCE_INLINE bool add(
+      T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+    return addNode<T>(value);
+  }
+  // bool add(const String&)
+  // bool add(const JsonVariant&);
+  // bool add(JsonArray&);
+  // bool add(JsonObject&);
+  template <typename T>
+  FORCE_INLINE bool add(
+      const T &value,
+      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+    return addNode<T &>(const_cast<T &>(value));
+  }
+  // bool add(float value, uint8_t decimals);
+  // bool add(double value, uint8_t decimals);
+  template <typename T>
+  FORCE_INLINE bool add(
+      T value, uint8_t decimals,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
+          * = 0) {
+    return addNode<JsonVariant>(JsonVariant(value, decimals));
+  }

  // 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);
+  FORCE_INLINE bool set(
+      size_t index, T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+    return setNodeAt<T>(index, value);
+  }
+  // bool set(size_t index, const String&)
+  // bool set(size_t index, const JsonVariant&);
+  // bool set(size_t index, JsonArray&);
+  // bool set(size_t index, JsonObject&);
+  template <typename T>
+  FORCE_INLINE bool set(
+      size_t index, const T &value,
+      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+    return setNodeAt<T &>(index, const_cast<T &>(value));
+  }
+  // bool set(size_t index, float value, uint8_t decimals = 2);
+  // bool set(size_t index, double value, uint8_t decimals = 2);
+  template <typename T>
+  FORCE_INLINE bool set(
+      size_t index, T value, uint8_t decimals,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
+          * = 0) {
+    return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
+  }

  // Gets the value at the specified index.
  FORCE_INLINE JsonVariant get(size_t index) const;
@ -115,17 +161,70 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  // Serialize the array to the specified JsonWriter.
  void writeTo(Internals::JsonWriter &writer) const;

+  // Imports a 1D array
+  template <typename T, size_t N>
+  bool copyFrom(T(&array)[N]) {
+    return copyFrom(array, N);
+  }
+
+  // Imports a 1D array
+  template <typename T>
+  bool copyFrom(T *array, size_t len) {
+    bool ok = true;
+    for (size_t i = 0; i < len; i++) {
+      ok &= add(array[i]);
+    }
+    return ok;
+  }
+
+  // Imports a 2D array
+  template <typename T, size_t N1, size_t N2>
+  bool copyFrom(T(&array)[N1][N2]) {
+    bool ok = true;
+    for (size_t i = 0; i < N1; i++) {
+      JsonArray &nestedArray = createNestedArray();
+      for (size_t j = 0; j < N2; j++) {
+        ok &= nestedArray.add(array[i][j]);
+      }
+    }
+    return ok;
+  }
+
+  // Exports a 1D array
+  template <typename T, size_t N>
+  size_t copyTo(T(&array)[N]) const {
+    return copyTo(array, N);
+  }
+
+  // Exports a 1D array
+  template <typename T>
+  size_t copyTo(T *array, size_t len) const {
+    size_t i = 0;
+    for (const_iterator it = begin(); it != end() && i < len; ++it)
+      array[i++] = *it;
+    return i;
+  }
+
+  // Exports a 2D array
+  template <typename T, size_t N1, size_t N2>
+  void copyTo(T(&array)[N1][N2]) const {
+    size_t i = 0;
+    for (const_iterator it = begin(); it != end() && i < N1; ++it) {
+      it->asArray().copyTo(array[i++]);
+    }
+  }
+
 private:
  node_type *getNodeAt(size_t index) const;

  template <typename TValue>
-  void setNodeAt(size_t index, TValue value);
+  bool setNodeAt(size_t index, TValue value);

  template <typename TValue>
  bool addNode(TValue);

  template <typename T>
-  FORCE_INLINE void setNodeValue(node_type *, T value);
+  FORCE_INLINE bool setNodeValue(node_type *, T value);

  // The instance returned by JsonArray::invalid()
  static JsonArray _invalid;
--- a/include/ArduinoJson/JsonArray.ipp
+++ b/include/ArduinoJson/JsonArray.ipp
@ -1,12 +1,14 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

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

 namespace ArduinoJson {
@ -19,157 +21,30 @@ 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);
+  return node != NULL && setNodeValue<TValue>(node, value);
+}
+
+template <typename TValue>
+inline bool JsonArray::setNodeAt(size_t index, TValue value) {
+  node_type *node = getNodeAt(index);
+  return node != NULL && setNodeValue<TValue>(node, value);
+}
+
+template <typename TValue>
+inline bool JsonArray::setNodeValue(node_type *node, TValue value) {
+  node->content = value;
  return true;
 }

-inline 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 bool JsonArray::setNodeValue(node_type *node, String &value) {
+  const char *copy = _buffer->strdup(value);
+  if (!copy) return false;
+  node->content = copy;
+  return true;
 }

 inline JsonVariant JsonArray::get(size_t index) const {
@ -180,7 +55,7 @@ inline JsonVariant JsonArray::get(size_t index) const {
 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>();
+  return node ? node->content.as<T>() : JsonVariant::defaultValue<T>();
 }

 template <typename T>
@ -196,24 +71,31 @@ inline const JsonArraySubscript JsonVariantBase<TImplem>::operator[](
 }

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

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

-template <>
-inline JsonArray &JsonVariant::as<JsonArray &>() const {
+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
@ -1,12 +1,14 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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 "JsonSubscriptBase.hpp"
+#include "Configuration.hpp"
+#include "JsonVariantBase.hpp"

 #ifdef _MSC_VER
 #pragma warning(push)
@ -14,20 +16,30 @@
 #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;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonArray::CanSet<T>::value,
+                                JsonArraySubscript>::type&
+  operator=(T src) {
+    _array.set<T>(_index, src);
+    return *this;
  }

  FORCE_INLINE bool success() const { return _index < _array.size(); }
@ -58,7 +70,7 @@ 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);
--- a/include/ArduinoJson/JsonBuffer.hpp
+++ b/include/ArduinoJson/JsonBuffer.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -10,7 +11,7 @@
 #include <stdint.h>  // for uint8_t
 #include <string.h>

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

 #if defined(__clang__)
@ -93,6 +94,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;
@ -106,12 +122,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
  }

--- a/include/ArduinoJson/JsonObject.hpp
+++ b/include/ArduinoJson/JsonObject.hpp
@ -1,17 +1,22 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

-#include "Arduino/String.hpp"
+#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.
@ -35,6 +40,15 @@ 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().
@ -49,43 +63,41 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
  FORCE_INLINE JsonVariant operator[](JsonObjectKey key) const;

  // 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);
+  FORCE_INLINE bool set(
+      JsonObjectKey key, T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type* = 0) {
+    return setNodeAt<T>(key, value);
+  }
+  // bool set(Key, String&);
+  // bool set(Key, JsonArray&);
+  // bool set(Key, JsonObject&);
+  // bool set(Key, JsonVariant&);
  template <typename T>
-  FORCE_INLINE bool set(const String& key, const T& value);
+  FORCE_INLINE bool set(
+      JsonObjectKey key, const T& value,
+      typename TypeTraits::EnableIf<CanSet<T&>::value>::type* = 0) {
+    return setNodeAt<T&>(key, const_cast<T&>(value));
+  }
+  // bool set(Key, float value, uint8_t decimals);
+  // bool set(Key, double value, uint8_t decimals);
+  template <typename TValue>
+  FORCE_INLINE bool set(
+      JsonObjectKey key, TValue value, uint8_t decimals,
+      typename TypeTraits::EnableIf<
+          TypeTraits::IsFloatingPoint<TValue>::value>::type* = 0) {
+    return setNodeAt<const JsonVariant&>(key, JsonVariant(value, decimals));
+  }

  // Gets the value associated with the specified key.
  FORCE_INLINE JsonVariant get(JsonObjectKey) const;
@ -100,13 +112,11 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,

  // 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);
+  FORCE_INLINE 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);
+  FORCE_INLINE JsonObject& createNestedObject(JsonObjectKey key);

  // Tells weither the specified key is present and associated with a value.
  FORCE_INLINE bool containsKey(JsonObjectKey key) const;
@ -124,24 +134,17 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,

 private:
  // Returns the list node that matches the specified key.
-  node_type* getNodeAt(JsonObjectKey key) const;
+  node_type* getNodeAt(const char* 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* getOrCreateNodeAt(const char* key);

  template <typename T>
-  FORCE_INLINE void setNodeKey(node_type*, T key);
+  FORCE_INLINE bool setNodeAt(JsonObjectKey key, T value);
+
+  FORCE_INLINE bool setNodeKey(node_type*, JsonObjectKey key);

  template <typename T>
-  FORCE_INLINE void setNodeValue(node_type*, T value);
+  FORCE_INLINE bool setNodeValue(node_type*, T value);

  // The instance returned by JsonObject::invalid()
  static JsonObject _invalid;
--- a/include/ArduinoJson/JsonObject.ipp
+++ b/include/ArduinoJson/JsonObject.ipp
@ -1,30 +1,32 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

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

 namespace ArduinoJson {

 inline JsonVariant JsonObject::get(JsonObjectKey key) const {
-  node_type *node = getNodeAt(key);
+  node_type *node = getNodeAt(key.c_str());
  return node ? node->content.value : JsonVariant();
 }

 template <typename T>
 inline T JsonObject::get(JsonObjectKey key) const {
-  node_type *node = getNodeAt(key);
-  return node ? node->content.value.as<T>() : JsonVariant::invalid<T>();
+  node_type *node = getNodeAt(key.c_str());
+  return node ? node->content.value.as<T>() : JsonVariant::defaultValue<T>();
 }

 template <typename T>
 inline bool JsonObject::is(JsonObjectKey key) const {
-  node_type *node = getNodeAt(key);
+  node_type *node = getNodeAt(key.c_str());
  return node ? node->content.value.is<T>() : false;
 }

@ -43,165 +45,49 @@ inline JsonVariant JsonObject::operator[](JsonObjectKey key) const {
 }

 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);
+  return getNodeAt(key.c_str()) != NULL;
 }

 inline void JsonObject::remove(JsonObjectKey key) {
-  removeNode(getNodeAt(key));
+  removeNode(getNodeAt(key.c_str()));
 }

-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);
+inline bool JsonObject::setNodeAt(JsonObjectKey key, T value) {
+  node_type *node = getNodeAt(key.c_str());
+  if (!node) {
+    node = addNewNode();
+    if (!node || !setNodeKey(node, key)) return false;
+  }
+  return setNodeValue<T>(node, value);
 }

-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);
+inline bool JsonObject::setNodeKey(node_type *node, JsonObjectKey key) {
+  if (key.needs_copy()) {
+    node->content.key = _buffer->strdup(key.c_str());
+    if (node->content.key == NULL) return false;
+  } else {
+    node->content.key = key.c_str();
+  }
+  return true;
+}
+
+template <typename TValue>
+inline bool JsonObject::setNodeValue(node_type *node, TValue value) {
+  node->content.value = value;
  return true;
 }

 template <>
-inline 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);
+  return node->content.value;
+}
+
+template <>
+inline bool JsonObject::setNodeValue(node_type *node, const String &value) {
+  node->content.value = _buffer->strdup(value);
+  return node->content.value;
 }

 template <typename TImplem>
@ -217,24 +103,31 @@ operator[](const String &key) const {
 }

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

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

-template <>
-inline JsonObject &JsonVariant::as<JsonObject &>() const {
+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
@ -1,24 +1,27 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

-#include "Arduino/String.hpp"
+#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
@ -1,12 +1,15 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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 "JsonSubscriptBase.hpp"
+#include "Configuration.hpp"
+#include "JsonVariantBase.hpp"
+#include "TypeTraits/EnableIf.hpp"

 #ifdef _MSC_VER
 #pragma warning(push)
@ -16,23 +19,30 @@
 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;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonObject::CanSet<T>::value,
+                                JsonObjectSubscript<TKey> >::type&
+  operator=(T src) {
+    _object.set<T>(_key, src);
+    return *this;
  }

  FORCE_INLINE bool success() const { return _object.containsKey(_key); }
@ -51,7 +61,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>
@ -70,7 +80,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);
@ -81,6 +91,7 @@ inline std::ostream& operator<<(
  return source.printTo(os);
 }
 #endif
+
 }  // namespace ArduinoJson

 #ifdef _MSC_VER
--- a/include/ArduinoJson/JsonPair.hpp
+++ b/include/ArduinoJson/JsonPair.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -13,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,82 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#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
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

@ -12,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 {

@ -30,6 +37,9 @@ 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) {}

@ -40,24 +50,52 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  // 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>
+  FORCE_INLINE JsonVariant(
+      T value, uint8_t decimals = 2,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
+          * = 0) {
+    using namespace Internals;
+    _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
+    _content.asFloat = static_cast<JsonFloat>(value);
+  }

  // 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>
+  FORCE_INLINE JsonVariant(
+      T value, typename TypeTraits::EnableIf<
+                   TypeTraits::IsSignedIntegral<T>::value>::type * = 0) {
+    using namespace Internals;
+    if (value >= 0) {
+      _type = JSON_POSITIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(value);
+    } else {
+      _type = JSON_NEGATIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(-value);
+    }
+  }
+  // JsonVariant(unsigned short)
+  // JsonVariant(unsigned int)
+  // JsonVariant(unsigned long)
+  template <typename T>
+  FORCE_INLINE JsonVariant(
+      T value, typename TypeTraits::EnableIf<
+                   TypeTraits::IsUnsignedIntegral<T>::value>::type * = 0) {
+    using namespace Internals;
+    _type = JSON_POSITIVE_INTEGER;
+    _content.asInteger = static_cast<JsonUInt>(value);
+  }

  // Create a JsonVariant containing a string.
  FORCE_INLINE JsonVariant(const char *value);

  // Create a JsonVariant containing an unparsed string
-  FORCE_INLINE JsonVariant(Internals::Unparsed value);
+  FORCE_INLINE JsonVariant(RawJson value);

  // Create a JsonVariant containing a reference to an array.
  FORCE_INLINE JsonVariant(JsonArray &array);
@ -66,25 +104,191 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  FORCE_INLINE JsonVariant(JsonObject &object);

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

  // Tells weither the variant has the specified type.
  // Returns true if the variant has type type T, false otherwise.
+  //
+  // short as<short>() const;
+  // int as<int>() const;
+  // long as<long>() const;
  template <typename T>
-  bool is() const;
+  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 T 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>
+  FORCE_INLINE JsonVariant(T value,
+                           typename TypeTraits::EnableIf<
+                               TypeTraits::IsSame<T, char>::value>::type * = 0);
+
+  String toString() const;
  Internals::JsonFloat asFloat() const;
  Internals::JsonInteger asInteger() const;
+  Internals::JsonUInt asUnsignedInteger() const;
+  bool isBoolean() const;
+  bool isFloat() const;
+  bool isInteger() const;
+  bool isArray() const { return _type == Internals::JSON_ARRAY; }
+  bool isObject() const { return _type == Internals::JSON_OBJECT; }
+  bool isString() const { return _type == Internals::JSON_STRING; }

  // The current type of the variant
  Internals::JsonVariantType _type;
@ -100,6 +304,29 @@ inline JsonVariant float_with_n_digits(float value, uint8_t digits) {
 inline JsonVariant double_with_n_digits(double value, uint8_t digits) {
  return JsonVariant(value, digits);
 }
+
+template <typename T>
+struct JsonVariant::IsConstructibleFrom {
+  static const bool value =
+      TypeTraits::IsIntegral<T>::value ||
+      TypeTraits::IsFloatingPoint<T>::value ||
+      TypeTraits::IsSame<T, bool>::value ||
+      TypeTraits::IsSame<T, char *>::value ||
+      TypeTraits::IsSame<T, const char *>::value ||
+      TypeTraits::IsSame<T, 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;
+};
 }

 // Include inline implementations
--- a/include/ArduinoJson/JsonVariant.ipp
+++ b/include/ArduinoJson/JsonVariant.ipp
@ -1,12 +1,17 @@
-// Copyright Benoit Blanchon 2014-2015
+// Copyright Benoit Blanchon 2014-2016
 // MIT License
 //
 // Arduino JSON library
 // https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!

 #pragma once

+#include "Configuration.hpp"
 #include "JsonVariant.hpp"
+#include "Internals/Parse.hpp"
+
+#include <string.h>

 namespace ArduinoJson {

@ -21,23 +26,11 @@ inline JsonVariant::JsonVariant(const char *value) {
  _content.asString = value;
 }

-inline JsonVariant::JsonVariant(Internals::Unparsed value) {
+inline JsonVariant::JsonVariant(RawJson value) {
  _type = Internals::JSON_UNPARSED;
  _content.asString = value;
 }

-inline JsonVariant::JsonVariant(double value, uint8_t decimals) {
-  using namespace Internals;
-  _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
-  _content.asFloat = static_cast<JsonFloat>(value);
-}
-
-inline JsonVariant::JsonVariant(float value, uint8_t decimals) {
-  using namespace Internals;
-  _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
-  _content.asFloat = static_cast<JsonFloat>(value);
-}
-
 inline JsonVariant::JsonVariant(JsonArray &array) {
  _type = Internals::JSON_ARRAY;
  _content.asArray = &array;
@ -48,202 +41,46 @@ inline JsonVariant::JsonVariant(JsonObject &object) {
  _content.asObject = &object;
 }

-inline JsonVariant::JsonVariant(signed char value) {
+inline Internals::JsonInteger JsonVariant::asInteger() 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 _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(signed int value) {
+inline Internals::JsonUInt JsonVariant::asUnsignedInteger() 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:
+    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(signed long value) {
-  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
-}
-
-inline JsonVariant::JsonVariant(signed short value) {
-  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
-}
-
-inline JsonVariant::JsonVariant(unsigned char value) {
-  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
-}
-
-inline JsonVariant::JsonVariant(unsigned int value) {
-  using namespace Internals;
-  _type = JSON_INTEGER;
-  _content.asInteger = static_cast<JsonInteger>(value);
-}
-
-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 <>
-inline bool JsonVariant::is<bool>() const {
-  return _type == Internals::JSON_BOOLEAN;
-}
-
-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
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -19,31 +20,7 @@ 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>(); }

  // Gets the variant as an array.
  // Returns a reference to the JsonArray or JsonArray::invalid() if the
@ -58,6 +35,11 @@ class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
  FORCE_INLINE operator JsonObject &() const { return as<JsonObject &>(); }
  FORCE_INLINE JsonObject &asObject() const { return as<JsonObject &>(); }

+  template <typename T>
+  FORCE_INLINE operator T() const {
+    return as<T>();
+  }
+
  template <typename T>
  FORCE_INLINE const T as() const {
    return impl()->template as<T>();
--- a/include/ArduinoJson/Polyfills/isInfinity.hpp
+++ b/include/ArduinoJson/Polyfills/isInfinity.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
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#include <float.h>
+#else
+#include <math.h>
+#endif
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+template <typename T>
+bool isInfinity(T x) {
+  return !_finite(x);
+}
+#else
+template <typename T>
+bool isInfinity(T x) {
+  return isinf(x);
+}
+
+#ifdef __GLIBC__
+template <>
+inline bool isInfinity<double>(double x) {
+  return isinfl(x);
+}
+
+template <>
+inline bool isInfinity<float>(float x) {
+  return isinff(x);
+}
+#endif
+#endif
+}
+}
--- a/include/ArduinoJson/Polyfills/isNaN.hpp
+++ b/include/ArduinoJson/Polyfills/isNaN.hpp
@ -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
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#include <float.h>
+#else
+#include <math.h>
+#endif
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+// If Visual Studo <= 2012
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+template <typename T>
+bool isNaN(T x) {
+  return _isnan(x) != 0;
+}
+#else
+template <typename T>
+bool isNaN(T x) {
+  return isnan(x);
+}
+
+#ifdef __GLIBC__
+template <>
+inline bool isNaN<double>(double x) {
+  return isnanl(x);
+}
+
+template <>
+inline bool isNaN<float>(float x) {
+  return isnanf(x);
+}
+#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
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

@ -11,6 +12,7 @@
 #include <stddef.h>
 #include <stdint.h>

+namespace ArduinoJson {
 // This class reproduces Arduino's Print class
 class Print {
 public:
@ -18,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/RawJson.hpp
+++ b/include/ArduinoJson/RawJson.hpp
@ -0,0 +1,21 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+
+// A special type of data that can be used to insert pregenerated JSON portions.
+class RawJson {
+ public:
+  explicit RawJson(const char* str) : _str(str) {}
+  operator const char*() const { return _str; }
+
+ private:
+  const char* _str;
+};
+}
--- a/include/ArduinoJson/StaticJsonBuffer.hpp
+++ b/include/ArduinoJson/StaticJsonBuffer.hpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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

--- a/include/ArduinoJson/String.hpp
+++ b/include/ArduinoJson/String.hpp
@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Configuration.hpp"
+
+#if ARDUINOJSON_USE_ARDUINO_STRING
+
+#include <WString.h>
+
+#else
+
+#include <string>
+
+namespace ArduinoJson {
+typedef std::string String;
+}
+
+#endif
--- 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
@ -2,16 +2,21 @@
  "name": "Json",
  "keywords": "json, rest, http, web",
  "description": "An elegant and efficient JSON library for embedded systems",
-  "repository":
-  {
+  "repository": {
    "type": "git",
    "url": "https://github.com/bblanchon/ArduinoJson.git"
  },
-  "authors":
-  {
+  "version": "5.5.0",
+  "authors": {
    "name": "Benoit Blanchon",
    "url": "http://blog.benoitblanchon.fr"
  },
+  "exclude": [
+    "scripts",
+    "src/ArduinoJson.h",
+    "test",
+    "third-party"
+  ],
  "frameworks": "arduino",
-  "platforms": "atmelavr"  
-}
+  "platforms": "*"
+}
--- a/library.properties
+++ b/library.properties
@ -1,8 +1,9 @@
 name=ArduinoJson
-version=5.0.5
+version=5.5.0
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.
 paragraph=Like this project? Please star it on GitHub!
+category=Data Processing
 url=https://github.com/bblanchon/ArduinoJson
 architectures=*
--- a/scripts/build-old-arduino-package.sh
+++ b/scripts/build-old-arduino-package.sh
--- 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
@ -0,0 +1,16 @@
+#!/bin/sh -eux
+
+/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16
+sleep 3
+export DISPLAY=:1.0
+
+mkdir -p /tmp/arduino
+curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tar.xz | tar xJ -C /tmp/arduino --strip 1 ||
+curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tgz | tar xz -C /tmp/arduino --strip 1 
+export PATH=$PATH:/tmp/arduino/
+  
+ln -s $PWD /tmp/arduino/libraries/ArduinoJson
+
+for EXAMPLE in $PWD/examples/*/*.ino; do
+	arduino --verify --board $BOARD $EXAMPLE
+done
--- 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
@ -0,0 +1,10 @@
+#!/bin/sh -eux
+
+curl https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1
+
+/tmp/bin/cmake -DCOVERAGE=true .
+make 
+make test
+
+pip install --user cpp-coveralls
+coveralls --exclude third-party --gcov-options '\-lp'; fi
--- a/scripts/travis/platformio.sh
+++ b/scripts/travis/platformio.sh
@ -0,0 +1,10 @@
+#!/bin/sh -eux
+
+pip install --user platformio
+
+rm -r test
+
+for EXAMPLE in JsonParserExample JsonGeneratorExample
+do
+	platformio ci examples/$EXAMPLE/$EXAMPLE.ino -l '.' -b $BOARD
+done
--- a/src/Arduino/Print.cpp
+++ b/src/Arduino/Print.cpp
@ -1,71 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#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/Arduino/String.cpp
+++ b/src/Arduino/String.cpp
@ -1,31 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#ifndef ARDUINO
-
-#include "../../include/ArduinoJson/Arduino/String.hpp"
-
-#include <stdio.h>  // for sprintf()
-
-String::String(double value, unsigned char digits) {
-  char tmp[32];
-  sprintf(tmp, "%.*f", digits, value);
-  *this = tmp;
-}
-
-String::String(long value) {
-  char tmp[32];
-  sprintf(tmp, "%ld", value);
-  *this = tmp;
-}
-
-String::String(int value) {
-  char tmp[32];
-  sprintf(tmp, "%d", value);
-  *this = tmp;
-}
-
-#endif
--- a/src/ArduinoJson.h
+++ b/src/ArduinoJson.h
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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
 // ---------------
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -1,9 +1,16 @@
+# Copyright Benoit Blanchon 2014-2016
+# MIT License
+# 
+# Arduino JSON library
+# https://github.com/bblanchon/ArduinoJson
+# If you like this project, please add a star!
+
 file(GLOB_RECURSE HPP_FILES ../include/*.hpp)
 file(GLOB_RECURSE IPP_FILES ../include/*.ipp)
 file(GLOB_RECURSE CPP_FILES *.cpp)

 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
-	add_definitions(
+	add_compile_options(
 		-fno-exceptions
 		-fno-rtti
 		-pedantic
@ -33,19 +40,32 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 	)
 endif()

-if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU)")
-	add_definitions(
-		-Wlogical-op
-		-Wnoexcept
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	add_compile_options(
 		-Wstrict-null-sentinel
 	)
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)
+		add_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy
+	endif()
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)
+		add_compile_options(-Wnoexcept)
+	endif()
 endif()

 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	add_definitions(
+	add_compile_options(
 		-Wc++11-compat
 		-Wdeprecated-register
 	)
 endif()

+if(MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+	add_compile_options(-W4)
+endif()
+
 add_library(ArduinoJson ${CPP_FILES} ${HPP_FILES} ${IPP_FILES})
+
+target_include_directories(ArduinoJson INTERFACE ${CMAKE_CURRENT_LIST_DIR}/../include)
--- a/src/Internals/Comments.cpp
+++ b/src/Internals/Comments.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

--- a/src/Internals/Encoding.cpp
+++ b/src/Internals/Encoding.cpp
@ -1,12 +1,14 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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";
+const char ArduinoJson::Internals::Encoding::_escapeTable[] =
+    "\"\"\\\\b\bf\fn\nr\rt\t";
--- a/src/Internals/IndentedPrint.cpp
+++ b/src/Internals/IndentedPrint.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

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

 #include "../../include/ArduinoJson/Internals/JsonParser.hpp"

@ -194,7 +195,7 @@ bool JsonParser::parseStringTo(JsonVariant *destination) {
  if (hasQuotes) {
    *destination = value;
  } else {
-    *destination = Unparsed(value);
+    *destination = RawJson(value);
  }
  return true;
 }
--- a/src/Internals/List.cpp
+++ b/src/Internals/List.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

--- a/src/Internals/Prettyfier.cpp
+++ b/src/Internals/Prettyfier.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

--- a/src/Internals/StaticStringBuilder.cpp
+++ b/src/Internals/StaticStringBuilder.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

--- a/src/JsonArray.cpp
+++ b/src/JsonArray.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

@ -20,20 +21,6 @@ JsonArray::node_type *JsonArray::getNodeAt(size_t index) const {
  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 {
--- a/src/JsonBuffer.cpp
+++ b/src/JsonBuffer.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

@ -33,6 +34,11 @@ JsonObject &JsonBuffer::parseObject(char *json, uint8_t nestingLimit) {
  return parser.parseObject();
 }

+JsonVariant JsonBuffer::parse(char *json, uint8_t nestingLimit) {
+  JsonParser parser(this, json, nestingLimit);
+  return parser.parseVariant();
+}
+
 char *JsonBuffer::strdup(const char *source, size_t length) {
  size_t size = length + 1;
  char *dest = static_cast<char *>(alloc(size));
--- a/src/JsonObject.cpp
+++ b/src/JsonObject.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

@ -17,35 +18,7 @@ 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 {
+JsonObject::node_type *JsonObject::getNodeAt(const char *key) const {
  for (node_type *node = _firstNode; node; node = node->next) {
    if (!strcmp(node->content.key, key)) return node;
  }
--- a/src/JsonVariant.cpp
+++ b/src/JsonVariant.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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"

@ -16,31 +17,7 @@ using namespace ArduinoJson::Internals;

 namespace ArduinoJson {

-template <typename TFloat>
-static TFloat parse(const char *);
-
-template <>
-FORCE_INLINE float parse<float>(const char *s) {
-  return static_cast<float>(strtod(s, NULL));
-}
-
-template <>
-FORCE_INLINE double parse<double>(const char *s) {
-  return strtod(s, NULL);
-}
-
-template <>
-FORCE_INLINE long parse<long>(const char *s) {
-  return strtol(s, NULL, 10);
-}
-
-template <>
-FORCE_INLINE int parse<int>(const char *s) {
-  return atoi(s);
-}
-
-template <>
-const char *JsonVariant::as<const char *>() const {
+const char *JsonVariant::asString() const {
  if (_type == JSON_UNPARSED && _content.asString &&
      !strcmp("null", _content.asString))
    return NULL;
@ -49,53 +26,44 @@ const char *JsonVariant::as<const char *>() const {
 }

 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);
+  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;
  }
-
-  return 0L;
 }

-template <>
-String JsonVariant::as<String>() const {
+String JsonVariant::toString() const {
+  String s;
  if ((_type == JSON_STRING || _type == JSON_UNPARSED) &&
      _content.asString != NULL)
-    return String(_content.asString);
-
-  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN)
-    return String(_content.asInteger);
-
-  if (_type >= JSON_FLOAT_0_DECIMALS) {
-    uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
-    return String(_content.asFloat, decimals);
-  }
-
-  String s;
-  printTo(s);
+    s = _content.asString;
+  else
+    printTo(s);
  return s;
 }

-template <>
-bool JsonVariant::is<signed long>() const {
-  if (_type == JSON_INTEGER) return true;
+bool JsonVariant::isBoolean() 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");
+}
+
+bool JsonVariant::isInteger() const {
+  if (_type == JSON_POSITIVE_INTEGER || _type == JSON_NEGATIVE_INTEGER)
+    return true;

  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;

@ -106,8 +74,7 @@ bool JsonVariant::is<signed long>() const {
  return *end == '\0' && errno == 0;
 }

-template <>
-bool JsonVariant::is<double>() const {
+bool JsonVariant::isFloat() const {
  if (_type >= JSON_FLOAT_0_DECIMALS) return true;

  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
@ -120,27 +87,39 @@ bool JsonVariant::is<double>() const {
 }

 void JsonVariant::writeTo(JsonWriter &writer) const {
-  if (_type == JSON_ARRAY)
-    _content.asArray->writeTo(writer);
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return;

-  else if (_type == JSON_OBJECT)
-    _content.asObject->writeTo(writer);
+    case JSON_ARRAY:
+      _content.asArray->writeTo(writer);
+      return;

-  else if (_type == JSON_STRING)
-    writer.writeString(_content.asString);
+    case JSON_OBJECT:
+      _content.asObject->writeTo(writer);
+      return;

-  else if (_type == JSON_UNPARSED)
-    writer.writeRaw(_content.asString);
+    case JSON_STRING:
+      writer.writeString(_content.asString);
+      return;

-  else if (_type == JSON_INTEGER)
-    writer.writeInteger(_content.asInteger);
+    case JSON_UNPARSED:
+      writer.writeRaw(_content.asString);
+      return;

-  else if (_type == JSON_BOOLEAN)
-    writer.writeBoolean(_content.asInteger != 0);
+    case JSON_NEGATIVE_INTEGER:
+      writer.writeRaw('-');
+    case JSON_POSITIVE_INTEGER:
+      writer.writeInteger(_content.asInteger);
+      return;

-  else if (_type >= JSON_FLOAT_0_DECIMALS) {
-    uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
-    writer.writeFloat(_content.asFloat, decimals);
+    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);
  }
 }
 }
--- a/test/ArduinoString_Tests.cpp
+++ b/test/ArduinoString_Tests.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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>
@ -218,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
@ -1,10 +1,15 @@
+# Copyright Benoit Blanchon 2014-2016
+# MIT License
+# 
+# Arduino JSON library
+# https://github.com/bblanchon/ArduinoJson
+# If you like this project, please add a star!
+
 set(GTEST_DIR ../third-party/gtest-1.7.0)

-file(GLOB_RECURSE INC_FILES ../include/*.h)
 file(GLOB TESTS_FILES *.hpp *.cpp)

 include_directories(
-	../include
    ${GTEST_DIR}
    ${GTEST_DIR}/include)

@ -12,15 +17,19 @@ add_definitions(-DGTEST_HAS_PTHREAD=0)

 # Workaround for Visual Studio 2012
 if (MSVC AND MSVC_VERSION EQUAL 1700)
-  add_definitions(-D_VARIADIC_MAX=10)
+    add_definitions(-D_VARIADIC_MAX=10)
+endif()
+
+if (MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()

 add_executable(ArduinoJsonTests 
    ${TESTS_FILES}
-	${INC_FILES}
    ${GTEST_DIR}/src/gtest-all.cc
    ${GTEST_DIR}/src/gtest_main.cc)

+
 target_link_libraries(ArduinoJsonTests ArduinoJson)

 add_test(ArduinoJsonTests ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ArduinoJsonTests)
--- a/test/DynamicJsonBuffer_Array_Tests.cpp
+++ b/test/DynamicJsonBuffer_Array_Tests.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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>
--- a/test/DynamicJsonBuffer_Basic_Tests.cpp
+++ b/test/DynamicJsonBuffer_Basic_Tests.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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>

--- a/test/DynamicJsonBuffer_NoMemory_Tests.cpp
+++ b/test/DynamicJsonBuffer_NoMemory_Tests.cpp
@ -1,8 +1,9 @@
-// Copyright Benoit Blanchon 2014-2015
+// 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>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
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
Benoit Blanchon	ce63e9c3c3	Added comments in examples	2016-02-01 13:31:07 +01:00
Benoit Blanchon	77b7124cf1	Set version to 5.0.8	2016-01-31 21:57:08 +01:00
Benoit Blanchon	6a608d4b49	Fixed `JsonVariant::is<bool>()` that was incorrectly returning false (issue #214 )	2016-01-31 21:56:04 +01:00
Benoît Blanchon	01924618bd	Merge pull request #215 from ivankravets/patch-1 Use tagged source code from repo	2016-01-31 21:00:46 +01:00
Ivan Kravets	666e2fd0ce	Use tagged source code from repo http://docs.platformio.org/en/latest/librarymanager/config.html#version	2016-01-31 21:24:37 +02:00
Benoit Blanchon	0cfc25d751	Added Johann Stieger to the list of donators	2016-01-07 22:40:12 +01:00
Benoit Blanchon	b6d8e6c989	Updated copyright year from 2015 to 2016	2016-01-07 22:39:57 +01:00
Benoit Blanchon	ab2502f7b8	Fix misspelled PlatformIO	2015-12-23 14:42:22 +01:00
Ivan Kravets	c57e6f3bd8	Made the library compatible with platform.io (issue #181 )	2015-12-22 23:43:44 +01:00
Benoit Blanchon	b54f1ffc1d	Travis: build with Arduino 1.5.8 and 1.6.7	2015-12-22 22:01:30 +01:00
Benoit Blanchon	bd0ea42277	Added a badge with the number of stars	2015-11-25 21:22:49 +01:00
Benoit Blanchon	7ae43bc4f8	Set version to 5.0.7	2015-11-25 21:15:11 +01:00
Benoit Blanchon	056682327b	Changed `String` to be a `typedef` of `std::string` (issues #142 and #161 )	2015-11-25 21:09:18 +01:00
Benoit Blanchon	8b66a25f66	Removed a useless line of code	2015-11-22 10:18:21 +01:00
Benoit Blanchon	96245dd3b4	Made library easier to use from a CMake project: simply add_subdirectory(ArduinoJson/src)	2015-11-19 21:53:27 +01:00
Benoit Blanchon	9cc49da68a	Moved to the new Travis infrastructure	2015-11-19 21:31:23 +01:00
Benoit Blanchon	224918b463	Set version to 5.0.6	2015-11-09 23:10:14 +01:00
Benoit Blanchon	cbeefa2503	Examples: Added a loop to wait for serial port to be ready (issue #156 )	2015-11-09 22:56:49 +01:00
Benoit Blanchon	6d68806633	Added donators list	2015-11-09 22:55:29 +01:00
Benoit Blanchon	ba3617c22f	Added parameter to `DynamicJsonBuffer` constructor to set initial size (issue #152 )	2015-11-09 21:37:40 +01:00
Benoît Blanchon	b7d9bb2765	Merge pull request #150 from marvinroger/patch-1 Add library category	2015-11-06 14:50:18 +01:00
Marvin Roger	74b42e2251	Add library category	2015-11-06 14:30:20 +01:00