Set version to 5.1.0

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

.clang-format

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

.gitignore

@@ -4,3 +4,5 @@
 /bin
 /lib
 /sftp-config.json
+.tags
+.tags_sorted_by_file

.travis.yml

@@ -1,20 +1,15 @@
-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
+cache:
+  directories:
+    - "~/.platformio"
+env:
+  - COMPILER=gcc
+  - COMPILER=clang
+  - COMPILER=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
+  - COMPILER=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
+  - COMPILER=platformio BOARD=uno
+  - COMPILER=platformio BOARD=due
+  - COMPILER=platformio BOARD=esp01
+  - COMPILER=platformio BOARD=teensy31
+script: scripts/travis/$COMPILER.sh

ArduinoJson.h

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

CHANGELOG.md

@@ -1,6 +1,49 @@
 ArduinoJson: change log
 =======================
 
+v5.1.0
+------
+
+* Added support of `long long` (issue #171)
+* Moved all build settings to `ArduinoJson/Configuration.hpp`
+
+**BREAKING CHANGE**:
+If you defined `ARDUINOJSON_ENABLE_STD_STREAM`, you now need to define it to `1`.
+
+v5.0.8
+------
+
+* Made the library compatible with [PlatformIO](http://platformio.org/) (issue #181)
+* Fixed `JsonVariant::is<bool>()` that was incorrectly returning false (issue #214)
+
+v5.0.7
+------
+
+* Made library easier to use from a CMake project: simply `add_subdirectory(ArduinoJson/src)`
+* Changed `String` to be a `typedef` of `std::string` (issues #142 and #161)
+
+**BREAKING CHANGES**:
+- `JsonVariant(true).as<String>()` now returns `"true"` instead of `"1"`
+- `JsonVariant(false).as<String>()` now returns `"false"` instead of `"0"`
+
+v5.0.6
+------
+
+* Added parameter to `DynamicJsonBuffer` constructor to set initial size (issue #152)
+* Fixed warning about library category in Arduino 1.6.6 (issue #147)
+* Examples: Added a loop to wait for serial port to be ready (issue #156)
+
+v5.0.5
+------
+
+* Added overload `JsonObjectSuscript::set(value, decimals)` (issue #143)
+* Use `float` instead of `double` to reduce the size of `JsonVariant` (issue #134)
+
+v5.0.4
+------
+
+* Fixed ambiguous overload with `JsonArraySubscript` and `JsonObjectSubscript` (issue #122)
+
 v5.0.3
 ------
 

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()

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:
 

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.*
 
@@ -21,37 +21,54 @@ Features
 * Small footprint
 * MIT License
 
+Works on
+--------
+
+* All Arduino boards
+* ESP8266
+* Teensy
+* Intel Edison
+* PlatformIO
+* Energia
+* Computers (Windows, Linux, OSX...)
+
+See [FAQ: Compatibility issues](https://github.com/bblanchon/ArduinoJson/wiki/Compatibility-issues)
+
 Quick start
 -----------
 
 #### Decoding / Parsing
 
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+```c++
+char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    StaticJsonBuffer<200> jsonBuffer;
+StaticJsonBuffer<200> jsonBuffer;
 
-    JsonObject& root = jsonBuffer.parseObject(json);
+JsonObject& root = jsonBuffer.parseObject(json);
 
-    const char* sensor = root["sensor"];
-    long time          = root["time"];
-    double latitude    = root["data"][0];
-    double longitude   = root["data"][1];
+const char* sensor = root["sensor"];
+long time          = root["time"];
+double latitude    = root["data"][0];
+double longitude   = root["data"][1];
+```
 
 #### Encoding / Generating
 
-    StaticJsonBuffer<200> jsonBuffer;
+```c++
+StaticJsonBuffer<200> jsonBuffer;
 
-    JsonObject& root = jsonBuffer.createObject();
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
+JsonObject& root = jsonBuffer.createObject();
+root["sensor"] = "gps";
+root["time"] = 1351824120;
 
-    JsonArray& data = root.createNestedArray("data");
-    data.add(48.756080, 6);  // 6 is the number of decimals to print
-    data.add(2.302038, 6);   // if not specified, 2 digits are printed
+JsonArray& data = root.createNestedArray("data");
+data.add(48.756080, 6);  // 6 is the number of decimals to print
+data.add(2.302038, 6);   // if not specified, 2 digits are printed
 
-    root.printTo(Serial);
-    // This prints:
-    // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+root.printTo(Serial);
+// This prints:
+// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+```
 
 
 Documentation
@@ -86,6 +103,19 @@ From GitHub user `zacsketches`:
 
 > I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.
 
+Donators
+--------
+
+Special thanks to the following persons and companies who made generous donations to the library author:
+
+* Robert Murphy
+* Surge Communications
+* Alex Scott
+* Firepick Services LLC
+* A B Doodkorte
+* Scott Smith
+* Johann Stieger
+
 ---
 
 Found this library useful? Please star this project or [help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:

appveyor.yml

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

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,6 +11,9 @@ using namespace ArduinoJson::Internals;
 
 void setup() {
   Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
   IndentedPrint serial(Serial);
   serial.setTabSize(4);

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,20 +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);
+  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));

examples/JsonParserExample/JsonParserExample.ino

@@ -1,31 +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);
+  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);

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>

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"

include/ArduinoJson/Arduino/Print.hpp

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

include/ArduinoJson/Arduino/String.hpp

@@ -1,23 +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
 
 #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(double, unsigned char decimalPlaces = 2);
-};
+typedef std::string String;
 
 #else
 

include/ArduinoJson/Configuration.hpp

@@ -0,0 +1,79 @@
+// 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 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 assume that the STL is there
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#define ARDUINOJSON_ENABLE_STD_STREAM 1
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+// even if not required, most cpu's are faster with aligned pointers
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+
+#endif
+
+#if ARDUINOJSON_USE_LONG_LONG && ARDUINOJSON_USE_INT64
+#error ARDUINOJSON_USE_LONG_LONG and ARDUINOJSON_USE_INT64 cannot be set together
+#endif

include/ArduinoJson/DynamicJsonBuffer.hpp

@@ -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
 

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

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
 

include/ArduinoJson/Internals/DummyPrint.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
 

include/ArduinoJson/Internals/DynamicStringBuilder.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
 

include/ArduinoJson/Internals/Encoding.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
 
@@ -32,8 +33,8 @@ class Encoding {
     }
   }
 
-private:
-	static const char _escapeTable[];
+ private:
+  static const char _escapeTable[];
 };
 }
 }

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
 

include/ArduinoJson/Internals/IndentedPrint.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
 

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
 

include/ArduinoJson/Internals/JsonFloat.hpp

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

include/ArduinoJson/Internals/JsonInteger.hpp

@@ -0,0 +1,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
+
+#include "../Configuration.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+#if ARDUINOJSON_USE_LONG_LONG
+typedef long long JsonInteger;
+#elif ARDUINOJSON_USE_INT64
+typedef __int64 JsonInteger;
+#else
+typedef long JsonInteger;
+#endif
+}
+}

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
 

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);

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -1,11 +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 "JsonFloat.hpp"
+#include "JsonInteger.hpp"
+
 namespace ArduinoJson {
 
 // Forward declarations
@@ -13,15 +17,14 @@ class JsonArray;
 class JsonObject;
 
 namespace Internals {
-
 // A union that defines the actual content of a JsonVariant.
 // The enum JsonVariantType determines which member is in use.
 union JsonVariantContent {
-  double asDouble;       // asDouble is also used for float
-  long asLong;           // asLong is also used for bool, char, short and int
-  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
+  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
 };
 }
 }

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
 
@@ -19,17 +20,17 @@ enum JsonVariantType {
   JSON_UNPARSED,   // the JsonVariant contains an unparsed string
   JSON_STRING,     // the JsonVariant stores a const char*
   JSON_BOOLEAN,    // the JsonVariant stores a bool
-  JSON_LONG,       // the JsonVariant stores a long
+  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
 
-  // The following values are reserved for double values
+  // The following values are reserved for float values
   // Multiple values are used for double, depending on the number of decimal
   // digits that must be printed in the JSON output.
   // This little trick allow to save one extra member in JsonVariant
-  JSON_DOUBLE_0_DECIMALS
-  // JSON_DOUBLE_1_DECIMAL
-  // JSON_DOUBLE_2_DECIMALS
+  JSON_FLOAT_0_DECIMALS
+  // JSON_FLOAT_1_DECIMAL
+  // JSON_FLOAT_2_DECIMALS
   // ...
 };
 }

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -1,14 +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 "../Arduino/Print.hpp"
 #include "Encoding.hpp"
 #include "ForceInline.hpp"
+#include "JsonFloat.hpp"
+#include "JsonInteger.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -60,9 +63,9 @@ class JsonWriter {
     }
   }
 
-  void writeLong(long value) { _length += _sink.print(value); }
+  void writeInteger(JsonInteger value) { _length += _sink.print(value); }
 
-  void writeDouble(double value, uint8_t decimals) {
+  void writeFloat(JsonFloat value, uint8_t decimals) {
     _length += _sink.print(value, decimals);
   }
 

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
 

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
 

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
 

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
 

include/ArduinoJson/Internals/Parse.hpp

@@ -0,0 +1,51 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#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 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);
+}
+#endif
+
+#if ARDUINOJSON_USE_INT64
+template <>
+inline __int64 parse<__int64>(const char *s) {
+  return _strtoi64(s, NULL, 10);
+}
+#endif
+}
+}

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
 

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
 

include/ArduinoJson/Internals/StaticStringBuilder.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
 
@@ -14,7 +15,7 @@ namespace Internals {
 // A Print implementation that allows to write in a char[]
 class StaticStringBuilder : public Print {
  public:
-  StaticStringBuilder(char *buf, int size)
+  StaticStringBuilder(char *buf, size_t size)
       : buffer(buf), capacity(size - 1), length(0) {
     buffer[0] = '\0';
   }
@@ -23,8 +24,8 @@ class StaticStringBuilder : public Print {
 
  private:
   char *buffer;
-  int capacity;
-  int length;
+  size_t capacity;
+  size_t length;
 };
 }
 }

include/ArduinoJson/Internals/StreamPrintAdapter.hpp

@@ -1,15 +1,20 @@
-// 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"
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
 
 #include "../Arduino/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

include/ArduinoJson/Internals/Unparsed.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
 

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,40 +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);
-  FORCE_INLINE bool add(const JsonVariant &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(
+      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);
-  FORCE_INLINE void set(size_t index, const JsonVariant &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 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;
@@ -117,13 +165,13 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   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;

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,155 +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);
-}
-
-inline bool JsonArray::add(const JsonVariant &object) {
-  return addNode<const JsonVariant &>(object);
-}
-
 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);
-}
-
-inline void JsonArray::set(size_t index, const JsonVariant &object) {
-  return setNodeAt<const JsonVariant &>(index, object);
-}
-
-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 {
@@ -203,15 +80,22 @@ inline JsonArray const &JsonVariant::invalid<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;
 }
 }

include/ArduinoJson/JsonArraySubscript.hpp

@@ -1,20 +1,46 @@
-// 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)
+#pragma warning(disable : 4522)
+#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) {
+    _array.set<const JsonVariant&>(_index, src);
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonArray::CanSet<T&>::value,
+                                JsonArraySubscript>::type&
+  operator=(const T& src) {
+    _array.set<T&>(_index, const_cast<T&>(src));
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonArray::CanSet<T>::value,
+                                JsonArraySubscript>::type&
+  operator=(T src) {
+    _array.set<T>(_index, src);
+    return *this;
+  }
 
   FORCE_INLINE bool success() const { return _index < _array.size(); }
 
@@ -44,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);
@@ -52,3 +78,7 @@ inline std::ostream& operator<<(std::ostream& os,
 #endif
 
 }  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

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
 
@@ -106,12 +107,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
   }
 

include/ArduinoJson/JsonObject.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,6 +13,10 @@
 #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,38 +63,40 @@ 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);
-  FORCE_INLINE bool set(const String& key, bool value);
-  FORCE_INLINE bool set(const String& key, float value, uint8_t decimals = 2);
-  FORCE_INLINE bool set(const String& key, double value, uint8_t decimals = 2);
-  FORCE_INLINE bool set(const String& key, signed char value);
-  FORCE_INLINE bool set(const String& key, signed long value);
-  FORCE_INLINE bool set(const String& key, signed int value);
-  FORCE_INLINE bool set(const String& key, signed short value);
-  FORCE_INLINE bool set(const String& key, unsigned char value);
-  FORCE_INLINE bool set(const String& key, unsigned long value);
-  FORCE_INLINE bool set(const String& key, unsigned int value);
-  FORCE_INLINE bool set(const String& key, unsigned short value);
-  FORCE_INLINE bool set(const String& key, const char* value);
-  FORCE_INLINE bool set(const String& key, const String& value);
-  FORCE_INLINE bool set(const String& key, JsonArray& array);
-  FORCE_INLINE bool set(const String& key, JsonObject& object);
-  FORCE_INLINE bool set(const String& key, const JsonVariant& value);
+  // bool set(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);
+  template <typename T>
+  FORCE_INLINE bool set(
+      JsonObjectKey key, T value,
+      typename TypeTraits::EnableIf<
+          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type* = 0) {
+    return setNodeAt<T>(key, value);
+  }
+  // bool set(Key, String&);
+  // bool set(Key, JsonArray&);
+  // bool set(Key, JsonObject&);
+  // bool set(Key, JsonVariant&);
+  template <typename T>
+  FORCE_INLINE bool set(
+      JsonObjectKey key, const T& value,
+      typename TypeTraits::EnableIf<CanSet<T&>::value>::type* = 0) {
+    return setNodeAt<T&>(key, const_cast<T&>(value));
+  }
+  // bool set(Key, float value, uint8_t decimals);
+  // bool set(Key, double value, uint8_t decimals);
+  template <typename TValue>
+  FORCE_INLINE bool set(
+      JsonObjectKey key, TValue value, uint8_t decimals,
+      typename TypeTraits::EnableIf<
+          TypeTraits::IsFloatingPoint<TValue>::value>::type* = 0) {
+    return setNodeAt<const JsonVariant&>(key, JsonVariant(value, decimals));
+  }
 
   // Gets the value associated with the specified key.
   FORCE_INLINE JsonVariant get(JsonObjectKey) const;
@@ -95,13 +111,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;
@@ -119,24 +133,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;

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);
+  node_type *node = getNodeAt(key.c_str());
   return node ? node->content.value.as<T>() : JsonVariant::invalid<T>();
 }
 
 template <typename T>
 inline bool JsonObject::is(JsonObjectKey key) const {
-  node_type *node = getNodeAt(key);
+  node_type *node = getNodeAt(key.c_str());
   return node ? node->content.value.is<T>() : false;
 }
 
@@ -43,157 +45,46 @@ 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);
-}
-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::setNodeAt(JsonObjectKey key, T value) {
+  node_type *node = getNodeAt(key.c_str());
+  if (!node) node = addNewNode();
+  return node && setNodeKey(node, key) && 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>
@@ -218,15 +109,22 @@ inline JsonObject &JsonVariant::invalid<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;
 }
 }

include/ArduinoJson/JsonObjectKey.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,15 +11,17 @@
 
 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;
 };
 }

include/ArduinoJson/JsonObjectSubscript.hpp

@@ -1,23 +1,49 @@
-// 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)
+#pragma warning(disable : 4522)
+#endif
 
 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) {
+    _object.set<const JsonVariant&>(_key, src);
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonObject::CanSet<T&>::value,
+                                JsonObjectSubscript<TKey> >::type&
+  operator=(const T& src) {
+    _object.set<T&>(_key, const_cast<T&>(src));
+    return *this;
+  }
+
+  template <typename T>
+  typename TypeTraits::EnableIf<JsonObject::CanSet<T>::value,
+                                JsonObjectSubscript<TKey> >::type&
+  operator=(T src) {
+    _object.set<T>(_key, src);
+    return *this;
+  }
 
   FORCE_INLINE bool success() const { return _object.containsKey(_key); }
 
@@ -35,7 +61,12 @@ 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>
+  FORCE_INLINE bool set(TValue value, uint8_t decimals) {
+    return _object.set(_key, value, decimals);
   }
 
   FORCE_INLINE JsonVariant get() { return _object.get(_key); }
@@ -49,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);
@@ -60,4 +91,9 @@ inline std::ostream& operator<<(
   return source.printTo(os);
 }
 #endif
-}
+
+}  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

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

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<JsonVariant>(value);
-  }
-
- private:
-  template <typename TValue>
-  FORCE_INLINE TImpl& assign(TValue value) {
-    TImpl* that = static_cast<TImpl*>(this);
-    that->template set<TValue>(value);
-    return *that;
-  }
-};
-}

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
 
@@ -14,6 +15,12 @@
 #include "Internals/JsonVariantType.hpp"
 #include "Internals/Unparsed.hpp"
 #include "JsonVariantBase.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,18 +50,31 @@ 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(short)
+  // JsonVariant(int)
+  // JsonVariant(long)
+  template <typename T>
+  FORCE_INLINE JsonVariant(
+      T value,
+      typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value>::type * =
+          0) {
+    using namespace Internals;
+    _type = JSON_INTEGER;
+    _content.asInteger = static_cast<JsonInteger>(value);
+  }
 
   // Create a JsonVariant containing a string.
   FORCE_INLINE JsonVariant(const char *value);
@@ -66,9 +89,70 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   FORCE_INLINE JsonVariant(JsonObject &object);
 
   // Get the variant as the specified type.
-  // See cast operators for details.
+  // short as<short>() const;
+  // int as<int>() const;
+  // long as<long>() const;
   template <typename T>
-  T as() const;
+  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value, T>::type
+  as() const {
+    return static_cast<T>(asInteger());
+  }
+  // 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,
+                                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.
@@ -82,7 +166,15 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   template <typename T>
   static T invalid();
 
+  const char *asString() const;
+  JsonArray &asArray() const;
+  JsonObject &asObject() const;
+
  private:
+  String toString() const;
+  Internals::JsonFloat asFloat() const;
+  Internals::JsonInteger asInteger() const;
+
   // The current type of the variant
   Internals::JsonVariantType _type;
 
@@ -97,6 +189,28 @@ inline JsonVariant float_with_n_digits(float value, uint8_t digits) {
 inline JsonVariant double_with_n_digits(double value, uint8_t digits) {
   return JsonVariant(value, digits);
 }
+
+template <typename T>
+struct JsonVariant::IsConstructibleFrom {
+  static const bool value =
+      TypeTraits::IsIntegral<T>::value ||
+      TypeTraits::IsFloatingPoint<T>::value ||
+      TypeTraits::IsSame<T, bool>::value ||
+      TypeTraits::IsSame<T, char *>::value ||
+      TypeTraits::IsSame<T, const char *>::value ||
+      TypeTraits::IsSame<T, JsonArray &>::value ||
+      TypeTraits::IsSame<T, const JsonArray &>::value ||
+      TypeTraits::IsSame<T, JsonArraySubscript &>::value ||
+      TypeTraits::IsSame<T, const JsonArraySubscript &>::value ||
+      TypeTraits::IsSame<T, JsonObject &>::value ||
+      TypeTraits::IsSame<T, const JsonObject &>::value ||
+      TypeTraits::IsSame<T, JsonObjectSubscript<const char *> &>::value ||
+      TypeTraits::IsSame<T, const JsonObjectSubscript<const char *> &>::value ||
+      TypeTraits::IsSame<T, JsonObjectSubscript<String> &>::value ||
+      TypeTraits::IsSame<T, const JsonObjectSubscript<String> &>::value ||
+      TypeTraits::IsSame<T, JsonVariant &>::value ||
+      TypeTraits::IsSame<T, const JsonVariant &>::value;
+};
 }
 
 // Include inline implementations

include/ArduinoJson/JsonVariant.ipp

@@ -1,18 +1,24 @@
-// 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 {
 
 inline JsonVariant::JsonVariant(bool value) {
-  _type = Internals::JSON_BOOLEAN;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_BOOLEAN;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(const char *value) {
@@ -25,18 +31,6 @@ inline JsonVariant::JsonVariant(Internals::Unparsed value) {
   _content.asString = value;
 }
 
-inline JsonVariant::JsonVariant(double value, uint8_t decimals) {
-  _type = static_cast<Internals::JsonVariantType>(
-      Internals::JSON_DOUBLE_0_DECIMALS + decimals);
-  _content.asDouble = value;
-}
-
-inline JsonVariant::JsonVariant(float value, uint8_t decimals) {
-  _type = static_cast<Internals::JsonVariantType>(
-      Internals::JSON_DOUBLE_0_DECIMALS + decimals);
-  _content.asDouble = value;
-}
-
 inline JsonVariant::JsonVariant(JsonArray &array) {
   _type = Internals::JSON_ARRAY;
   _content.asArray = &array;
@@ -47,103 +41,6 @@ inline JsonVariant::JsonVariant(JsonObject &object) {
   _content.asObject = &object;
 }
 
-inline JsonVariant::JsonVariant(signed char value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-inline JsonVariant::JsonVariant(signed int value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-inline JsonVariant::JsonVariant(signed long value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-inline JsonVariant::JsonVariant(signed short value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-inline JsonVariant::JsonVariant(unsigned char value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-inline JsonVariant::JsonVariant(unsigned int value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-inline JsonVariant::JsonVariant(unsigned long value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-inline JsonVariant::JsonVariant(unsigned short value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
-}
-
-template <>
-double JsonVariant::as<double>() const;
-
-template <>
-long JsonVariant::as<long>() const;
-
-template <>
-String JsonVariant::as<String>() const;
-
-template <>
-const char *JsonVariant::as<const char *>() const;
-
-template <>
-inline bool JsonVariant::as<bool>() const {
-  return as<long>() != 0;
-}
-
-template <>
-inline signed char JsonVariant::as<signed char>() const {
-  return static_cast<signed char>(as<long>());
-}
-
-template <>
-inline unsigned char JsonVariant::as<unsigned char>() const {
-  return static_cast<unsigned char>(as<long>());
-}
-
-template <>
-inline signed short JsonVariant::as<signed short>() const {
-  return static_cast<signed short>(as<long>());
-}
-
-template <>
-inline unsigned short JsonVariant::as<unsigned short>() const {
-  return static_cast<unsigned short>(as<long>());
-}
-
-template <>
-inline signed int JsonVariant::as<signed int>() const {
-  return static_cast<signed int>(as<long>());
-}
-
-template <>
-inline unsigned int JsonVariant::as<unsigned int>() const {
-  return static_cast<unsigned int>(as<long>());
-}
-
-template <>
-inline unsigned long JsonVariant::as<unsigned long>() const {
-  return static_cast<unsigned long>(as<long>());
-}
-
-template <>
-inline float JsonVariant::as<float>() const {
-  return static_cast<float>(as<double>());
-}
-
 template <typename T>
 inline T JsonVariant::invalid() {
   return T();
@@ -160,10 +57,8 @@ 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 <>  // int .cpp
+bool JsonVariant::is<bool>() const;
 
 template <>
 inline bool JsonVariant::is<char const *>() const {
@@ -230,7 +125,23 @@ inline bool JsonVariant::is<unsigned short>() const {
   return is<signed long>();
 }
 
-#ifdef ARDUINOJSON_ENABLE_STD_STREAM
+inline Internals::JsonInteger JsonVariant::asInteger() const {
+  if (_type == Internals::JSON_INTEGER || _type == Internals::JSON_BOOLEAN)
+    return _content.asInteger;
+
+  if (_type >= Internals::JSON_FLOAT_0_DECIMALS)
+    return static_cast<Internals::JsonInteger>(_content.asFloat);
+
+  if ((_type == Internals::JSON_STRING || _type == Internals::JSON_UNPARSED) &&
+      _content.asString) {
+    if (!strcmp("true", _content.asString)) return 1;
+    return Internals::parse<Internals::JsonInteger>(_content.asString);
+  }
+
+  return 0L;
+}
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
 inline std::ostream &operator<<(std::ostream &os, const JsonVariant &source) {
   return source.printTo(os);
 }

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

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
 

include/ArduinoJson/TypeTraits/EnableIf.hpp

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

include/ArduinoJson/TypeTraits/IsFloatingPoint.hpp

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

include/ArduinoJson/TypeTraits/IsIntegral.hpp

@@ -0,0 +1,41 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+#include "IsSame.hpp"
+
+#include <stdint.h>
+
+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::IsSame<T, signed char>::value ||
+                            TypeTraits::IsSame<T, unsigned char>::value ||
+                            TypeTraits::IsSame<T, signed short>::value ||
+                            TypeTraits::IsSame<T, unsigned short>::value ||
+                            TypeTraits::IsSame<T, signed int>::value ||
+                            TypeTraits::IsSame<T, unsigned int>::value ||
+                            TypeTraits::IsSame<T, signed long>::value ||
+                            TypeTraits::IsSame<T, unsigned long>::value ||
+#if ARDUINOJSON_USE_LONG_LONG
+                            TypeTraits::IsSame<T, long long>::value ||
+                            TypeTraits::IsSame<T, unsigned long long>::value ||
+#endif
+
+#if ARDUINOJSON_USE_INT64
+                            TypeTraits::IsSame<T, __int64>::value ||
+                            TypeTraits::IsSame<T, unsigned __int64>::value ||
+#endif
+                            TypeTraits::IsSame<T, char>::value;
+};
+}
+}

include/ArduinoJson/TypeTraits/IsReference.hpp

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

include/ArduinoJson/TypeTraits/IsSame.hpp

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

include/ArduinoJson/TypeTraits/RemoveConst.hpp

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

include/ArduinoJson/TypeTraits/RemoveReference.hpp

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

library.json

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

library.properties

@@ -1,8 +1,9 @@
 name=ArduinoJson
-version=5.0.3
+version=5.1.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=*

scripts/travis/arduino.sh

@@ -0,0 +1,15 @@
+#!/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
+
+arduino --verify --board $BOARD $PWD/examples/JsonParserExample/JsonParserExample.ino
+arduino --verify --board $BOARD $PWD/examples/JsonGeneratorExample/JsonGeneratorExample.ino

scripts/travis/clang.sh

@@ -0,0 +1,10 @@
+#!/bin/sh -eux
+
+export CC=clang
+export CXX=clang++
+
+curl -sS https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1
+
+/tmp/bin/cmake .
+make 
+make test

scripts/travis/gcc.sh

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

scripts/travis/platformio.sh

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

src/Arduino/Print.cpp

@@ -1,65 +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::println() { return write('\r') + write('\n'); }
-
-#endif

src/Arduino/String.cpp

@@ -1,25 +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;
-}
-
-#endif

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

src/CMakeLists.txt

@@ -1,3 +1,10 @@
+# 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)
@@ -5,6 +12,7 @@ file(GLOB_RECURSE CPP_FILES *.cpp)
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 	add_definitions(
 		-fno-exceptions
+		-fno-rtti
 		-pedantic
 		-Wall
 		-Wcast-align
@@ -47,4 +55,12 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 	)
 endif()
 
+if(MSVC)
+	add_definitions(
+		-D_CRT_SECURE_NO_WARNINGS
+		-W4)
+endif()
+
 add_library(ArduinoJson ${CPP_FILES} ${HPP_FILES} ${IPP_FILES})
+
+target_include_directories(ArduinoJson INTERFACE ${CMAKE_CURRENT_LIST_DIR}/../include)

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"
 

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";

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"
 

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"
 

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"
 

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"
 

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"
 

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 {

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"
 

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

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,8 +17,7 @@ using namespace ArduinoJson::Internals;
 
 namespace ArduinoJson {
 
-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;
@@ -25,56 +25,41 @@ const char *JsonVariant::as<const char *>() const {
   return NULL;
 }
 
-template <>
-double JsonVariant::as<double>() const {
-  if (_type >= JSON_DOUBLE_0_DECIMALS) return _content.asDouble;
+JsonFloat JsonVariant::asFloat() const {
+  if (_type >= JSON_FLOAT_0_DECIMALS) return _content.asFloat;
 
-  if (_type == JSON_LONG || _type == JSON_BOOLEAN)
-    return static_cast<double>(_content.asLong);
+  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN)
+    return static_cast<JsonFloat>(_content.asInteger);
 
   if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString)
-    return strtod(_content.asString, NULL);
+    return parse<JsonFloat>(_content.asString);
 
   return 0.0;
 }
 
-template <>
-long JsonVariant::as<long>() const {
-  if (_type == JSON_LONG || _type == JSON_BOOLEAN) return _content.asLong;
-
-  if (_type >= JSON_DOUBLE_0_DECIMALS)
-    return static_cast<long>(_content.asDouble);
-
-  if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString) {
-    if (!strcmp("true", _content.asString)) return 1;
-    return strtol(_content.asString, NULL, 10);
-  }
-
-  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_LONG || _type == JSON_BOOLEAN)
-    return String(_content.asLong);
-
-  if (_type >= JSON_DOUBLE_0_DECIMALS) {
-    uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
-    return String(_content.asDouble, decimals);
-  }
-
-  String s;
-  printTo(s);
+    s = _content.asString;
+  else
+    printTo(s);
   return s;
 }
 
+template <>
+bool JsonVariant::is<bool>() const {
+  if (_type == JSON_BOOLEAN) return true;
+
+  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
+
+  return !strcmp(_content.asString, "true") ||
+         !strcmp(_content.asString, "false");
+}
+
 template <>
 bool JsonVariant::is<signed long>() const {
-  if (_type == JSON_LONG) return true;
+  if (_type == JSON_INTEGER) return true;
 
   if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
 
@@ -87,7 +72,7 @@ bool JsonVariant::is<signed long>() const {
 
 template <>
 bool JsonVariant::is<double>() const {
-  if (_type >= JSON_DOUBLE_0_DECIMALS) return true;
+  if (_type >= JSON_FLOAT_0_DECIMALS) return true;
 
   if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
 
@@ -111,15 +96,15 @@ void JsonVariant::writeTo(JsonWriter &writer) const {
   else if (_type == JSON_UNPARSED)
     writer.writeRaw(_content.asString);
 
-  else if (_type == JSON_LONG)
-    writer.writeLong(_content.asLong);
+  else if (_type == JSON_INTEGER)
+    writer.writeInteger(_content.asInteger);
 
   else if (_type == JSON_BOOLEAN)
-    writer.writeBoolean(_content.asLong != 0);
+    writer.writeBoolean(_content.asInteger != 0);
 
-  else if (_type >= JSON_DOUBLE_0_DECIMALS) {
-    uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
-    writer.writeDouble(_content.asDouble, decimals);
+  else if (_type >= JSON_FLOAT_0_DECIMALS) {
+    uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
+    writer.writeFloat(_content.asFloat, decimals);
   }
 }
 }

test/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>
@@ -71,6 +72,26 @@ TEST_F(ArduinoStringTests, JsonObject_SetKeyValue) {
   ASSERT_STREQ("world", object["hello"]);
 }
 
+TEST_F(ArduinoStringTests, JsonObject_SetToArraySubscript) {
+  JsonArray &arr = _jsonBuffer.createArray();
+  arr.add("world");
+
+  JsonObject &object = _jsonBuffer.createObject();
+  object.set(String("hello"), arr[0]);
+
+  ASSERT_STREQ("world", object["hello"]);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_SetToObjectSubscript) {
+  JsonObject &arr = _jsonBuffer.createObject();
+  arr.set("x", "world");
+
+  JsonObject &object = _jsonBuffer.createObject();
+  object.set(String("hello"), arr["x"]);
+
+  ASSERT_STREQ("world", object["hello"]);
+}
+
 TEST_F(ArduinoStringTests, JsonObject_Get) {
   char json[] = "{\"key\":\"value\"}";
   const JsonObject &object = _jsonBuffer.parseObject(json);

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)

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>

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>
 
@@ -22,9 +23,9 @@ TEST_F(DynamicJsonBuffer_Basic_Tests, InitialSizeIsZero) {
 
 TEST_F(DynamicJsonBuffer_Basic_Tests, SizeIncreasesAfterAlloc) {
   buffer.alloc(1);
-  ASSERT_LE(1, buffer.size());
+  ASSERT_LE(1U, buffer.size());
   buffer.alloc(1);
-  ASSERT_LE(2, buffer.size());
+  ASSERT_LE(2U, buffer.size());
 }
 
 TEST_F(DynamicJsonBuffer_Basic_Tests, ReturnDifferentPointer) {

test/DynamicJsonBuffer_NoMemory_Tests.cpp

@@ -1,23 +1,29 @@
-// 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>
 
-class DynamicJsonBuffer_NoMemory_Tests : public ::testing::Test {
-  class NoMemoryAllocator {
-   public:
-    void* allocate(size_t) { return NULL; }
-    void deallocate(void*) {}
-  };
+class NoMemoryAllocator {
+ public:
+  void* allocate(size_t) { return NULL; }
+  void deallocate(void*) {}
+};
 
+class DynamicJsonBuffer_NoMemory_Tests : public ::testing::Test {
  protected:
   Internals::BlockJsonBuffer<NoMemoryAllocator> _jsonBuffer;
 };
 
+TEST_F(DynamicJsonBuffer_NoMemory_Tests, FixCodeCoverage) {
+  // call this function to fix code coverage
+  NoMemoryAllocator().deallocate(NULL);
+}
+
 TEST_F(DynamicJsonBuffer_NoMemory_Tests, CreateArray) {
   ASSERT_FALSE(_jsonBuffer.createArray().success());
 }

test/DynamicJsonBuffer_Object_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>

test/GbathreeBug.cpp

@@ -1,11 +1,11 @@
-// 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>
-#define ARDUINOJSON_ENABLE_STD_STREAM
 #include <ArduinoJson.h>
 
 class GbathreeBug : public testing::Test {

test/IntegrationTests.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>

test/Issue10.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>

test/Issue214.cpp

@@ -0,0 +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!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+TEST(Issue214, IsBool) {
+  char json[] = "{\"ota\": {\"enabled\": true}}";
+  StaticJsonBuffer<JSON_OBJECT_SIZE(1) + JSON_OBJECT_SIZE(1)> jsonBuffer;
+  JsonObject& parsedJson = jsonBuffer.parseObject(json);
+  ASSERT_TRUE(parsedJson["ota"]["enabled"].is<bool>());
+}

test/Issue34.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>

test/Issue67.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>

test/Issue90.cpp

@@ -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!
 
 #include <gtest/gtest.h>
 #include <limits.h>  // for LONG_MAX
-#define ARDUINOJSON_ENABLE_STD_STREAM
+
+#define ARDUINOJSON_USE_LONG_LONG 0
+#define ARDUINOJSON_USE_INT64 0
 #include <ArduinoJson.h>
 
 #define SUITE Issue90

test/JsonArray_Add_Tests.cpp

@@ -0,0 +1,90 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonArray_Add_Tests : public ::testing::Test {
+ protected:
+  JsonArray_Add_Tests() : _array(_jsonBuffer.createArray()) {}
+
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& _array;
+};
+
+#define TEST_(name) TEST_F(JsonArray_Add_Tests, name)
+
+TEST_(SizeIncreased_WhenValuesAreAdded) {
+  _array.add("hello");
+  EXPECT_EQ(1U, _array.size());
+}
+
+TEST_(StoreInteger) {
+  _array.add(123);
+  EXPECT_EQ(123, _array[0].as<int>());
+  EXPECT_TRUE(_array[0].is<int>());
+  EXPECT_FALSE(_array[0].is<double>());
+}
+
+TEST_(StoreDouble) {
+  _array.add(123.45);
+  EXPECT_EQ(123.45, _array[0].as<double>());
+  EXPECT_TRUE(_array[0].is<double>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreBoolean) {
+  _array.add(true);
+  EXPECT_EQ(true, _array[0].as<bool>());
+  EXPECT_TRUE(_array[0].is<bool>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreString) {
+  _array.add("hello");
+  EXPECT_STREQ("hello", _array[0].as<const char*>());
+  EXPECT_TRUE(_array[0].is<const char*>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedArray) {
+  JsonArray& arr = _jsonBuffer.createArray();
+
+  _array.add(arr);
+
+  EXPECT_EQ(&arr, &_array[0].as<JsonArray&>());
+  EXPECT_TRUE(_array[0].is<JsonArray&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedObject) {
+  JsonObject& obj = _jsonBuffer.createObject();
+
+  _array.add(obj);
+
+  EXPECT_EQ(&obj, &_array[0].as<JsonObject&>());
+  EXPECT_TRUE(_array[0].is<JsonObject&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreArraySubscript) {
+  JsonArray& arr = _jsonBuffer.createArray();
+  arr.add("hello");
+
+  _array.add(arr[0]);
+
+  EXPECT_STREQ("hello", _array[0]);
+}
+
+TEST_(StoreObjectSubscript) {
+  JsonObject& obj = _jsonBuffer.createObject();
+  obj["x"] = "hello";
+
+  _array.add(obj["x"]);
+
+  EXPECT_STREQ("hello", _array[0]);
+}