Set version to 5.11.2

Fixed incorrect rounding for float values (fixes #588 )
Added banner with the new logo
2025-07-26 00:37:36 +02:00 · 2017-10-17 10:21:52 +02:00 · 2017-10-17 10:19:21 +02:00 · 2017-10-16 10:21:44 +02:00 · 2017-10-07 16:33:53 +02:00 · 2017-10-03 13:01:47 +02:00
66 changed files with 1859 additions and 1017 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -1,11 +1,14 @@
 <!--
-Thanks for using ArduinoJson :-)
-
-Before opening an issue, please make sure you've read these:
+Before opening an issue, please read the FAQ:
 https://bblanchon.github.io/ArduinoJson/faq/
-https://bblanchon.github.io/ArduinoJson/doc/pitfalls/

-Next, make sure you provide all the relevant information: platform, code snippet, and error messages.
+Please provide all the relevant information:
+* good title
+* short description of the problem
+* target platform
+* compiler model and version
+* MVCE (https://stackoverflow.com/help/mcve)
+* compiler output

-Please be concise!
+Good questions get fast answers!
 -->
--- a/.travis.yml
+++ b/.travis.yml
@ -8,12 +8,6 @@ matrix:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-4.4']
      env: SCRIPT=cmake GCC=4.4
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.5']
-      env: SCRIPT=cmake GCC=4.5
    - compiler: gcc
      addons:
        apt:
@ -50,6 +44,12 @@ matrix:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-6']
      env: SCRIPT=cmake GCC=6
+    - compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7']
+      env: SCRIPT=cmake GCC=7
    - compiler: clang
      env: SCRIPT=cmake
    - compiler: clang
@ -89,9 +89,7 @@ matrix:
    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:avr:uno
    - env: SCRIPT=platformio BOARD=uno
-    - env: SCRIPT=platformio BOARD=due
    - env: SCRIPT=platformio BOARD=esp01
-    #- env: SCRIPT=platformio BOARD=teensy31C
 cache:
  directories:
    - "~/.platformio"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,11 +1,43 @@
 ArduinoJson: change log
 =======================

+v5.11.2
+-------
+
+* Fixed `DynamicJsonBuffer::clear()` not resetting allocation size (issue #561)
+* Fixed incorrect rounding for float values (issue #588)
+
+v5.11.1
+-------
+
+* Removed dependency on `PGM_P` as Particle 0.6.2 doesn't define it (issue #546)
+* Fixed warning "dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]"
+* Fixed warning "floating constant exceeds range of 'float' [-Woverflow]" (issue #544)
+* Fixed warning "this statement may fall through" [-Wimplicit-fallthrough=] (issue #539)
+* Removed `ARDUINOJSON_DOUBLE_IS_64BITS` as it became useless.
+* Fixed too many decimals places in float serialization (issue #543)
+
+v5.11.0
+-------
+
+* Made `JsonBuffer` non-copyable (PR #524 by @luisrayas3)
+* Added `StaticJsonBuffer::clear()`
+* Added `DynamicJsonBuffer::clear()`
+
+v5.10.1
+-------
+
+* Fixed IntelliSense errors in Visual Micro (issue #483)
+* Fixed compilation in IAR Embedded Workbench (issue #515)
+* Fixed reading "true" as a float (issue #516)
+* Added `ARDUINOJSON_DOUBLE_IS_64BITS`
+* Added `ARDUINOJSON_EMBEDDED_MODE`
+
 v5.10.0
 -------

 * Removed configurable number of decimal places (issues #288, #427 and #506)
-* Changed exponentation thresholds to `1e7` and `1e-5` (issues #288, #427 and #506)
+* Changed exponentiation thresholds to `1e7` and `1e-5` (issues #288, #427 and #506)
 * `JsonVariant::is<double>()` now returns `true` for integers
 * Fixed error `IsBaseOf is not a member of ArduinoJson::TypeTraits` (issue #495)
 * Fixed error `forming reference to reference` (issue #495)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -0,0 +1,11 @@
+# Contribution to ArduinoJson
+
+First, thank you for taking the time to contribute to this project.
+
+You can submit changes via GitHub Pull Requests.
+
+Please:
+
+1. Unit test every change in behavior
+2. Use clang-format in "file" mode to format the code
+3. Consider using the Continuous Integration (Travis and AppVeyor)
--- a/README.md
+++ b/README.md
@ -1,8 +1,10 @@
+[![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)
+
+![ArduinoJson's logo](banner.svg)
+
 ArduinoJson - C++ JSON library for IoT
 ====================

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

 It's designed to have the most intuitive API, the smallest footprint and is able to work without any allocation on the heap (no malloc).
@ -58,6 +60,8 @@ double longitude   = root["data"][1];

 [See JsonParserExample.ino](examples/JsonParserExample/JsonParserExample.ino)

+Use [ArduinoJson Assistant](https://bblanchon.github.io/ArduinoJson/assistant/) to compute the buffer size.
+
 #### Encoding / Generating

 ```c++
@ -78,6 +82,8 @@ root.printTo(Serial);

 [See JsonGeneratorExample.ino](examples/JsonGeneratorExample/JsonGeneratorExample.ino)

+Use [ArduinoJson Assistant](https://bblanchon.github.io/ArduinoJson/assistant/) to compute the buffer size.
+

 Documentation
 -------------
@ -112,6 +118,12 @@ Special thanks to the following persons and companies who made generous donation
 * Christoph Schmidt <img alt='Germany' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1e9-1f1ea.svg' width='18' height='18'>
 * OpenEVSE LLC <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
 * Prokhoryatov Alexey <img alt='Russia' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f7-1f1fa.svg' width='18' height='18'>
+* Google Inc. <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Charles Haynes <img alt='Australia' src='https://d1j8pt39hxlh3d.cloudfront.net/development/emojione/2.2/989/2546.svg' width='18' height='18'>
+* Charles Walker <img alt='USA' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1fa-1f1f8.svg' width='18' height='18'>
+* Günther Jehle <img alt='Liechtenstein' src='https://cdnjs.cloudflare.com/ajax/libs/emojione/2.1.4/assets/svg/1f1f1-1f1ee.svg' width='18' height='18'>
+* Patrick Elliott
+

 ---

--- a/SUPPORT.md
+++ b/SUPPORT.md
@ -0,0 +1,27 @@
+# ArduinoJson Support
+
+First off, thank you very much for using ArduinoJson.
+
+We'll be very happy to help you, but first please read the following.
+
+## Before asking for help
+
+1. Read the [FAQ](https://bblanchon.github.io/ArduinoJson/faq/)
+2. Search in the [API Reference](https://bblanchon.github.io/ArduinoJson/api/)
+
+If you did not find the answer, please create a [new issue on GitHub](https://github.com/bblanchon/ArduinoJson/issues/new).
+
+It is OK to add a comment to a currently opened issue, but please avoid adding comments to a closed issue.
+
+## Before hitting the Submit button
+
+Please provide all the relevant information:
+
+* Good title
+* Short description of the problem
+* Target platform
+* Compiler model and version
+* [MVCE](https://stackoverflow.com/help/mcve)
+* Compiler output
+
+Good questions get fast answers!
--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,13 +1,15 @@
-version: 5.10.0.{build}
+version: 5.11.2.{build}
 environment:
  matrix:
-  - CMAKE_GENERATOR: Visual Studio 14 2015
-  - CMAKE_GENERATOR: Visual Studio 12 2013
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    CMAKE_GENERATOR: Visual Studio 15 2017
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    CMAKE_GENERATOR: Visual Studio 14 2015
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    CMAKE_GENERATOR: Visual Studio 12 2013
  - CMAKE_GENERATOR: Visual Studio 11 2012
  - CMAKE_GENERATOR: Visual Studio 10 2010
-#  - CMAKE_GENERATOR: MinGW Makefiles
-# Note: Disabled because of unexplicated error -1073741511
-# This used to work fine with GCC 4.8.2 then failed after they upgraded to GCC 4.9.3
+  - 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
--- a/banner.svg
+++ b/banner.svg
--- a/examples/JsonGeneratorExample/JsonGeneratorExample.ino
+++ b/examples/JsonGeneratorExample/JsonGeneratorExample.ino
@ -17,13 +17,13 @@ void setup() {
  //
  // 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.
+  // See https://bblanchon.github.io/ArduinoJson/assistant/
  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;
+  // DynamicJsonBuffer  jsonBuffer(200);

  // Create the root of the object tree.
  //
--- a/examples/JsonHttpClient/JsonHttpClient.ino
+++ b/examples/JsonHttpClient/JsonHttpClient.ino
@ -135,7 +135,7 @@ bool skipResponseHeaders() {
 // }
 bool readReponseContent(struct UserData* userData) {
  // Compute optimal size of the JSON buffer according to what we need to parse.
-  // This is only required if you use StaticJsonBuffer.
+  // See https://bblanchon.github.io/ArduinoJson/assistant/
  const size_t BUFFER_SIZE =
      JSON_OBJECT_SIZE(8)    // the root object has 8 elements
      + JSON_OBJECT_SIZE(5)  // the "address" object has 5 elements
--- a/examples/JsonParserExample/JsonParserExample.ino
+++ b/examples/JsonParserExample/JsonParserExample.ino
@ -17,13 +17,13 @@ void setup() {
  //
  // 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.
+  // See https://bblanchon.github.io/ArduinoJson/assistant/
  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;
+  // DynamicJsonBuffer  jsonBuffer(200);

  // JSON input string.
  //
--- a/examples/JsonServer/JsonServer.ino
+++ b/examples/JsonServer/JsonServer.ino
@ -2,9 +2,9 @@
 // Created by Benoit Blanchon.
 // Heavily inspired by "Web Server" from David A. Mellis and Tom Igoe

-#include <SPI.h>
-#include <Ethernet.h>
 #include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>

 byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
 IPAddress ip(192, 168, 0, 177);
@ -64,6 +64,8 @@ void loop() {
  if (client) {
    bool success = readRequest(client);
    if (success) {
+      // Use https://bblanchon.github.io/ArduinoJson/assistant/ to
+      // compute the right size for the buffer
      StaticJsonBuffer<500> jsonBuffer;
      JsonObject& json = prepareResponse(jsonBuffer);
      writeResponse(client, json);
--- a/examples/JsonUdpBeacon/JsonUdpBeacon.ino
+++ b/examples/JsonUdpBeacon/JsonUdpBeacon.ino
@ -49,6 +49,8 @@ void setup() {
 void loop() {
  delay(1000);

+  // Use https://bblanchon.github.io/ArduinoJson/assistant/ to
+  // compute the right size for the buffer
  StaticJsonBuffer<300> jsonBuffer;
  JsonObject& json = buildJson(jsonBuffer);
  sendJson(json);
--- a/library.json
+++ b/library.json
@ -6,7 +6,7 @@
    "type": "git",
    "url": "https://github.com/bblanchon/ArduinoJson.git"
  },
-  "version": "5.10.0",
+  "version": "5.11.2",
  "authors": {
    "name": "Benoit Blanchon",
    "url": "https://blog.benoitblanchon.fr"
--- a/library.properties
+++ b/library.properties
@ -1,5 +1,5 @@
 name=ArduinoJson
-version=5.10.0
+version=5.11.2
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.
--- a/src/ArduinoJson.hpp
+++ b/src/ArduinoJson.hpp
@ -10,7 +10,6 @@
 #include "ArduinoJson/DynamicJsonBuffer.hpp"
 #include "ArduinoJson/JsonArray.hpp"
 #include "ArduinoJson/JsonObject.hpp"
-#include "ArduinoJson/JsonVariantComparisons.hpp"
 #include "ArduinoJson/StaticJsonBuffer.hpp"

 #include "ArduinoJson/Deserialization/JsonParserImpl.hpp"
--- a/src/ArduinoJson/Configuration.hpp
+++ b/src/ArduinoJson/Configuration.hpp
@ -7,30 +7,23 @@

 #pragma once

-// enable deprecated functions by default
-#ifndef ARDUINOJSON_ENABLE_DEPRECATED
-#define ARDUINOJSON_ENABLE_DEPRECATED 1
+// Small or big machine?
+#ifndef ARDUINOJSON_EMBEDDED_MODE
+#if defined(ARDUINO) || defined(__IAR_SYSTEMS_ICC__)
+#define ARDUINOJSON_EMBEDDED_MODE 1
+#else
+#define ARDUINOJSON_EMBEDDED_MODE 0
+#endif
 #endif

-// control the exponentiation threshold for big numbers
-// CAUTION: cannot be more that 1e9 !!!!
-#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
-#define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7
-#endif
+#if ARDUINOJSON_EMBEDDED_MODE

-// control the exponentiation threshold for small numbers
-#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD
-#define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5
-#endif
-
-#ifdef ARDUINO  // assume this is an embedded platform
-
-// store using float instead of double to reduce the memory usage (issue #134)
+// Store floats by default 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.
+// Store longs by default, because they usually match the size of a float.
 #ifndef ARDUINOJSON_USE_LONG_LONG
 #define ARDUINOJSON_USE_LONG_LONG 0
 #endif
@ -38,57 +31,29 @@
 #define ARDUINOJSON_USE_INT64 0
 #endif

-// Arduino has its own implementation of String to replace std::string
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
-#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
-#endif
-
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
-#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
-#endif
-
-// On AVR archiecture, we can use PROGMEM
-#ifndef ARDUINOJSON_ENABLE_PROGMEM
-#ifdef PROGMEM
-#define ARDUINOJSON_ENABLE_PROGMEM 1
-#else
-#define ARDUINOJSON_ENABLE_PROGMEM 0
-#endif
-#endif
-
-// Arduino doesn't have std::string
+// Embedded systems usually don't have std::string
 #ifndef ARDUINOJSON_ENABLE_STD_STRING
 #define ARDUINOJSON_ENABLE_STD_STRING 0
 #endif

-// Arduino doesn't support STL stream
+// Embedded systems usually don't have std::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
-
-// low value to prevent stack overflow
+// Limit nesting as the stack is likely to be small
 #ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
 #define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
 #endif

-#else  // assume this is a computer
+#else  // ARDUINOJSON_EMBEDDED_MODE

-// on a computer we have plenty of memory so we can use doubles
+// 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
+// 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
@ -97,7 +62,7 @@
 #endif
 #endif

-// use _int64 on old versions of Visual Studio
+// Use _int64 on old versions of Visual Studio
 #ifndef ARDUINOJSON_USE_INT64
 #if defined(_MSC_VER) && _MSC_VER <= 1700
 #define ARDUINOJSON_USE_INT64 1
@ -106,41 +71,81 @@
 #endif
 #endif

-// on a computer, we can use std::string
+// On a computer, we can use std::string
 #ifndef ARDUINOJSON_ENABLE_STD_STRING
 #define ARDUINOJSON_ENABLE_STD_STRING 1
 #endif

-// on a computer, there is no reason to beleive Arduino String is available
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
-#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
-#endif
-
-// PROGMEM is only available on AVR architecture
-#ifndef ARDUINOJSON_ENABLE_PROGMEM
-#define ARDUINOJSON_ENABLE_PROGMEM 0
-#endif
-
-// on a computer, we can assume that the STL is there
+// On a computer, we can assume std::stream
 #ifndef ARDUINOJSON_ENABLE_STD_STREAM
 #define ARDUINOJSON_ENABLE_STD_STREAM 1
 #endif

-// on a computer, there is no reason to beleive Arduino Stream is available
-#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
-#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
-#endif
-
-#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
-// even if not required, most cpu's are faster with aligned pointers
-#define ARDUINOJSON_ENABLE_ALIGNMENT 1
-#endif
-
-// on a computer, we should have a lot of space on the stack
+// On a computer, the stack is large so we can increase nesting limit
 #ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
 #define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50
 #endif

+#endif  // ARDUINOJSON_EMBEDDED_MODE
+
+#ifdef ARDUINO
+
+// Enable support for Arduino String
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
+#endif
+
+// Enable support for Arduino Stream
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
+#endif
+
+#else  // ARDUINO
+
+// Disable support for Arduino String
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
+#endif
+
+// Disable support for Arduino Stream
+#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
+#endif
+
+#endif  // ARDUINO
+
+#ifndef ARDUINOJSON_ENABLE_PROGMEM
+#ifdef PROGMEM
+#define ARDUINOJSON_ENABLE_PROGMEM 1
+#else
+#define ARDUINOJSON_ENABLE_PROGMEM 0
+#endif
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+#ifdef ARDUINO_ARCH_AVR
+// alignment isn't needed for 8-bit AVR
+#define ARDUINOJSON_ENABLE_ALIGNMENT 0
+#else
+// but most processors need pointers to be align on word size
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+#endif
+
+// Enable deprecated functions by default
+#ifndef ARDUINOJSON_ENABLE_DEPRECATED
+#define ARDUINOJSON_ENABLE_DEPRECATED 1
+#endif
+
+// Control the exponentiation threshold for big numbers
+// CAUTION: cannot be more that 1e9 !!!!
+#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
+#define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7
+#endif
+
+// Control the exponentiation threshold for small numbers
+#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD
+#define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5
 #endif

 #if ARDUINOJSON_USE_LONG_LONG && ARDUINOJSON_USE_INT64
--- a/src/ArduinoJson/Data/JsonBufferAllocated.hpp
+++ b/src/ArduinoJson/Data/JsonBufferAllocated.hpp
@ -19,7 +19,7 @@ class JsonBufferAllocated {
    return jsonBuffer->alloc(n);
  }

-  void operator delete(void *, JsonBuffer *)throw() {}
+  void operator delete(void *, JsonBuffer *)throw();
 };
 }
 }
--- a/src/ArduinoJson/Data/JsonVariantComparer.hpp
+++ b/src/ArduinoJson/Data/JsonVariantComparer.hpp
@ -1,69 +0,0 @@
-// Copyright Benoit Blanchon 2014-2017
-// MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
-
-#pragma once
-
-#include "../JsonVariantBase.hpp"
-#include "../StringTraits/StringTraits.hpp"
-#include "../TypeTraits/EnableIf.hpp"
-
-namespace ArduinoJson {
-namespace Internals {
-template <typename TComparand, typename Enable = void>
-struct JsonVariantComparer {};
-
-template <typename TString>
-struct JsonVariantComparer<
-    TString,
-    typename TypeTraits::EnableIf<TypeTraits::IsString<TString>::value>::type> {
-  template <typename TVariant>
-  static bool equals(const JsonVariantBase<TVariant> &variant,
-                     const TString &comparand) {
-    const char *value = variant.template as<const char *>();
-    return Internals::StringTraits<TString>::equals(comparand, value);
-  }
-};
-
-template <typename TComparand>
-struct JsonVariantComparer<
-    TComparand, typename TypeTraits::EnableIf<
-                    !TypeTraits::IsVariant<TComparand>::value &&
-                    !TypeTraits::IsString<TComparand>::value>::type> {
-  template <typename TVariant>
-  static bool equals(const JsonVariantBase<TVariant> &variant,
-                     const TComparand &comparand) {
-    return variant.template as<TComparand>() == comparand;
-  }
-};
-
-template <typename TVariant2>
-struct JsonVariantComparer<TVariant2,
-                           typename TypeTraits::EnableIf<
-                               TypeTraits::IsVariant<TVariant2>::value>::type> {
-  template <typename TVariant1>
-  static bool equals(const JsonVariantBase<TVariant1> &left,
-                     const TVariant2 &right) {
-    if (left.template is<bool>() && right.template is<bool>())
-      return left.template as<bool>() == right.template as<bool>();
-    if (left.template is<JsonInteger>() && right.template is<JsonInteger>())
-      return left.template as<JsonInteger>() ==
-             right.template as<JsonInteger>();
-    if (left.template is<JsonFloat>() && right.template is<JsonFloat>())
-      return left.template as<JsonFloat>() == right.template as<JsonFloat>();
-    if (left.template is<JsonArray>() && right.template is<JsonArray>())
-      return left.template as<JsonArray>() == right.template as<JsonArray>();
-    if (left.template is<JsonObject>() && right.template is<JsonObject>())
-      return left.template as<JsonObject>() == right.template as<JsonObject>();
-    if (left.template is<char *>() && right.template is<char *>())
-      return strcmp(left.template as<char *>(), right.template as<char *>()) ==
-             0;
-
-    return false;
-  }
-};
-}
-}
--- a/src/ArduinoJson/Data/ListNode.hpp
+++ b/src/ArduinoJson/Data/ListNode.hpp
@ -18,7 +18,7 @@ namespace Internals {
 // Used by List<T> and its iterators.
 template <typename T>
 struct ListNode : public Internals::JsonBufferAllocated {
-  ListNode() : next(NULL) {}
+  ListNode() throw() : next(NULL) {}

  ListNode<T> *next;
  T content;
--- a/src/ArduinoJson/Data/NonCopyable.hpp
+++ b/src/ArduinoJson/Data/NonCopyable.hpp
@ -0,0 +1,26 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A type that cannot be copied
+class NonCopyable {
+ protected:
+  NonCopyable() {}
+
+ private:
+  // copy constructor is private
+  NonCopyable(const NonCopyable&);
+
+  // copy operator is private
+  NonCopyable& operator=(const NonCopyable&);
+};
+}
+}
--- a/src/ArduinoJson/Data/ReferenceType.hpp
+++ b/src/ArduinoJson/Data/ReferenceType.hpp
@ -22,16 +22,6 @@ class ReferenceType {
  bool operator!=(const ReferenceType& other) const {
    return this != &other;
  }
-
- protected:
-  ReferenceType() {}
-
- private:
-  // copy constructor is private
-  ReferenceType(const ReferenceType&);
-
-  // copy operator is private
-  ReferenceType& operator=(const ReferenceType&);
 };
 }
 }
--- a/src/ArduinoJson/Deserialization/JsonParserImpl.hpp
+++ b/src/ArduinoJson/Deserialization/JsonParserImpl.hpp
@ -20,9 +20,8 @@ inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::eat(
 }

 template <typename TReader, typename TWriter>
-inline bool
-ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingTo(
-    JsonVariant *destination) {
+inline bool ArduinoJson::Internals::JsonParser<
+    TReader, TWriter>::parseAnythingTo(JsonVariant *destination) {
  if (_nestingLimit == 0) return false;
  _nestingLimit--;
  bool success = parseAnythingToUnsafe(destination);
@ -31,9 +30,8 @@ ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingTo(
 }

 template <typename TReader, typename TWriter>
-inline bool
-ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingToUnsafe(
-    JsonVariant *destination) {
+inline bool ArduinoJson::Internals::JsonParser<
+    TReader, TWriter>::parseAnythingToUnsafe(JsonVariant *destination) {
  skipSpacesAndComments(_reader);

  switch (_reader.current()) {
--- a/src/ArduinoJson/Deserialization/StringWriter.hpp
+++ b/src/ArduinoJson/Deserialization/StringWriter.hpp
@ -17,8 +17,8 @@ class StringWriter {
   public:
    String(TChar** ptr) : _writePtr(ptr), _startPtr(*ptr) {}

-    void append(TChar c) {
-      *(*_writePtr)++ = c;
+    void append(char c) {
+      *(*_writePtr)++ = TChar(c);
    }

    const char* c_str() const {
--- a/src/ArduinoJson/DynamicJsonBuffer.hpp
+++ b/src/ArduinoJson/DynamicJsonBuffer.hpp
@ -46,30 +46,41 @@ class DynamicJsonBufferBase
  };

 public:
+  enum { EmptyBlockSize = sizeof(EmptyBlock) };
+
  DynamicJsonBufferBase(size_t initialSize = 256)
      : _head(NULL), _nextBlockCapacity(initialSize) {}

  ~DynamicJsonBufferBase() {
-    Block* currentBlock = _head;
-
-    while (currentBlock != NULL) {
-      Block* nextBlock = currentBlock->next;
-      _allocator.deallocate(currentBlock);
-      currentBlock = nextBlock;
-    }
+    clear();
  }

+  // Gets the number of bytes occupied in the buffer
  size_t size() const {
    size_t total = 0;
    for (const Block* b = _head; b; b = b->next) total += b->size;
    return total;
  }

+  // Allocates the specified amount of bytes in the buffer
  virtual void* alloc(size_t bytes) {
    alignNextAlloc();
    return canAllocInHead(bytes) ? allocInHead(bytes) : allocInNewBlock(bytes);
  }

+  // Resets the buffer.
+  // USE WITH CAUTION: this invalidates all previously allocated data
+  void clear() {
+    Block* currentBlock = _head;
+    while (currentBlock != NULL) {
+      _nextBlockCapacity = currentBlock->capacity;
+      Block* nextBlock = currentBlock->next;
+      _allocator.deallocate(currentBlock);
+      currentBlock = nextBlock;
+    }
+    _head = 0;
+  }
+
  class String {
   public:
    String(DynamicJsonBufferBase* parent)
@ -98,7 +109,7 @@ class DynamicJsonBufferBase
   private:
    DynamicJsonBufferBase* _parent;
    char* _start;
-    int _length;
+    size_t _length;
  };

  String startString() {
@ -129,7 +140,7 @@ class DynamicJsonBufferBase
  }

  bool addNewBlock(size_t capacity) {
-    size_t bytes = sizeof(EmptyBlock) + capacity;
+    size_t bytes = EmptyBlockSize + capacity;
    Block* block = static_cast<Block*>(_allocator.allocate(bytes));
    if (block == NULL) return false;
    block->capacity = capacity;
--- a/src/ArduinoJson/JsonArray.hpp
+++ b/src/ArduinoJson/JsonArray.hpp
@ -39,13 +39,14 @@ class JsonArraySubscript;
 // It can also be deserialized from a JSON string via JsonBuffer::parseArray().
 class JsonArray : public Internals::JsonPrintable<JsonArray>,
                  public Internals::ReferenceType,
+                  public Internals::NonCopyable,
                  public Internals::List<JsonVariant>,
                  public Internals::JsonBufferAllocated {
 public:
  // Create an empty JsonArray attached to the specified JsonBuffer.
  // You should not call this constructor directly.
  // Instead, use JsonBuffer::createArray() or JsonBuffer::parseArray().
-  explicit JsonArray(JsonBuffer *buffer)
+  explicit JsonArray(JsonBuffer *buffer) throw()
      : Internals::List<JsonVariant>(buffer) {}

  // Gets the value at the specified index
--- a/src/ArduinoJson/JsonArraySubscript.hpp
+++ b/src/ArduinoJson/JsonArraySubscript.hpp
@ -106,15 +106,16 @@ inline const JsonArraySubscript JsonArray::operator[](size_t index) const {
  return JsonArraySubscript(*const_cast<JsonArray*>(this), index);
 }

-template <typename TImplem>
-inline JsonArraySubscript JsonVariantBase<TImplem>::operator[](int index) {
-  return as<JsonArray>()[index];
+template <typename TImpl>
+inline JsonArraySubscript JsonVariantSubscripts<TImpl>::operator[](
+    size_t index) {
+  return impl()->template as<JsonArray>()[index];
 }

-template <typename TImplem>
-inline const JsonArraySubscript JsonVariantBase<TImplem>::operator[](
-    int index) const {
-  return as<JsonArray>()[index];
+template <typename TImpl>
+inline const JsonArraySubscript JsonVariantSubscripts<TImpl>::operator[](
+    size_t index) const {
+  return impl()->template as<JsonArray>()[index];
 }

 }  // namespace ArduinoJson
--- a/src/ArduinoJson/JsonBuffer.hpp
+++ b/src/ArduinoJson/JsonBuffer.hpp
@ -11,20 +11,11 @@
 #include <stdint.h>  // for uint8_t
 #include <string.h>

+#include "Data/NonCopyable.hpp"
 #include "JsonVariant.hpp"
 #include "TypeTraits/EnableIf.hpp"
 #include "TypeTraits/IsArray.hpp"

-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#elif defined(__GNUC__)
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#pragma GCC diagnostic push
-#endif
-#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
 namespace ArduinoJson {
 class JsonArray;
 class JsonObject;
@ -34,13 +25,8 @@ class JsonObject;
 // Handle the memory management (done in derived classes) and calls the parser.
 // This abstract class is implemented by StaticJsonBuffer which implements a
 // fixed memory allocation.
-class JsonBuffer {
+class JsonBuffer : Internals::NonCopyable {
 public:
-  // CAUTION: NO VIRTUAL DESTRUCTOR!
-  // If we add a virtual constructor the Arduino compiler will add malloc() and
-  // free() to the binary, adding 706 useless bytes.
-  // virtual ~JsonBuffer() {}
-
  // Allocates an empty JsonArray.
  //
  // Returns a reference to the new JsonArray or JsonArray::invalid() if the
@ -76,6 +62,11 @@ class JsonBuffer {
  virtual void *alloc(size_t size) = 0;

 protected:
+  // CAUTION: NO VIRTUAL DESTRUCTOR!
+  // If we add a virtual constructor the Arduino compiler will add malloc()
+  // and free() to the binary, adding 706 useless bytes.
+  ~JsonBuffer() {}
+
  // Preserve aligment if necessary
  static FORCE_INLINE size_t round_size_up(size_t bytes) {
 #if ARDUINOJSON_ENABLE_ALIGNMENT
@ -87,11 +78,3 @@ class JsonBuffer {
  }
 };
 }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#elif defined(__GNUC__)
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#pragma GCC diagnostic pop
-#endif
-#endif
--- a/src/ArduinoJson/JsonBufferBase.hpp
+++ b/src/ArduinoJson/JsonBufferBase.hpp
@ -9,16 +9,6 @@

 #include "Deserialization/JsonParser.hpp"

-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#elif defined(__GNUC__)
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#pragma GCC diagnostic push
-#endif
-#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
 namespace ArduinoJson {
 template <typename TDerived>
 class JsonBufferBase : public JsonBuffer {
@ -127,17 +117,12 @@ class JsonBufferBase : public JsonBuffer {
    return Internals::makeParser(that(), json, nestingLimit).parseVariant();
  }

+ protected:
+  ~JsonBufferBase() {}
+
 private:
  TDerived *that() {
    return static_cast<TDerived *>(this);
  }
 };
 }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#elif defined(__GNUC__)
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#pragma GCC diagnostic pop
-#endif
-#endif
--- a/src/ArduinoJson/JsonObject.hpp
+++ b/src/ArduinoJson/JsonObject.hpp
@ -38,13 +38,15 @@ class JsonBuffer;
 // It can also be deserialized from a JSON string via JsonBuffer::parseObject().
 class JsonObject : public Internals::JsonPrintable<JsonObject>,
                   public Internals::ReferenceType,
+                   public Internals::NonCopyable,
                   public Internals::List<JsonPair>,
                   public Internals::JsonBufferAllocated {
 public:
  // Create an empty JsonArray attached to the specified JsonBuffer.
  // You should not use this constructor directly.
  // Instead, use JsonBuffer::createObject() or JsonBuffer.parseObject().
-  explicit JsonObject(JsonBuffer* buffer) : Internals::List<JsonPair>(buffer) {}
+  explicit JsonObject(JsonBuffer* buffer) throw() 
+    : Internals::List<JsonPair>(buffer) {}

  // Gets or sets the value associated with the specified key.
  //
--- a/src/ArduinoJson/JsonVariant.hpp
+++ b/src/ArduinoJson/JsonVariant.hpp
@ -52,7 +52,7 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  JsonVariant(bool value) {
    using namespace Internals;
    _type = JSON_BOOLEAN;
-    _content.asInteger = static_cast<JsonInteger>(value);
+    _content.asInteger = static_cast<JsonUInt>(value);
  }

  // Create a JsonVariant containing a floating point value.
--- a/src/ArduinoJson/JsonVariantBase.hpp
+++ b/src/ArduinoJson/JsonVariantBase.hpp
@ -7,133 +7,17 @@

 #pragma once

-#include "Data/JsonVariantAs.hpp"
-#include "Polyfills/attributes.hpp"
+#include "JsonVariantCasts.hpp"
+#include "JsonVariantComparisons.hpp"
+#include "JsonVariantSubscripts.hpp"
 #include "Serialization/JsonPrintable.hpp"

 namespace ArduinoJson {

-// Forward declarations.
-class JsonArraySubscript;
-template <typename TKey>
-class JsonObjectSubscript;
-
 template <typename TImpl>
-class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
- public:
-#if ARDUINOJSON_ENABLE_DEPRECATED
-  DEPRECATED("use as<JsonArray>() instead")
-  FORCE_INLINE JsonArray &asArray() const {
-    return as<JsonArray>();
-  }
-
-  DEPRECATED("use as<JsonObject>() instead")
-  FORCE_INLINE JsonObject &asObject() const {
-    return as<JsonObject>();
-  }
-
-  DEPRECATED("use as<char*>() instead")
-  FORCE_INLINE const char *asString() const {
-    return as<const char *>();
-  }
-#endif
-
-  // Gets the variant as an array.
-  // Returns a reference to the JsonArray or JsonArray::invalid() if the
-  // variant
-  // is not an array.
-  FORCE_INLINE operator JsonArray &() const {
-    return as<JsonArray &>();
-  }
-
-  // Gets the variant as an object.
-  // Returns a reference to the JsonObject or JsonObject::invalid() if the
-  // variant is not an object.
-  FORCE_INLINE operator JsonObject &() const {
-    return as<JsonObject &>();
-  }
-
-  template <typename T>
-  FORCE_INLINE operator T() const {
-    return as<T>();
-  }
-
-  template <typename T>
-  FORCE_INLINE const typename Internals::JsonVariantAs<T>::type as() const {
-    return impl()->template as<T>();
-  }
-
-  template <typename T>
-  FORCE_INLINE bool is() const {
-    return impl()->template is<T>();
-  }
-
-  // Mimics an array or an object.
-  // Returns the size of the array or object if the variant has that type.
-  // Returns 0 if the variant is neither an array nor an object
-  size_t size() const {
-    return as<JsonArray>().size() + as<JsonObject>().size();
-  }
-
-  // Mimics an array.
-  // Returns the element at specified index if the variant is an array.
-  // Returns JsonVariant::invalid() if the variant is not an array.
-  FORCE_INLINE const JsonArraySubscript operator[](int index) const;
-  FORCE_INLINE JsonArraySubscript operator[](int index);
-
-  // Mimics an object.
-  // Returns the value associated with the specified key if the variant is
-  // an object.
-  // Return JsonVariant::invalid() if the variant is not an object.
-  //
-  // const JsonObjectSubscript operator[](TKey) const;
-  // TKey = const std::string&, const String&
-  template <typename TString>
-  FORCE_INLINE typename TypeTraits::EnableIf<
-      Internals::StringTraits<TString>::has_equals,
-      const JsonObjectSubscript<const TString &> >::type
-  operator[](const TString &key) const {
-    return as<JsonObject>()[key];
-  }
-  //
-  // const JsonObjectSubscript operator[](TKey) const;
-  // TKey = const std::string&, const String&
-  template <typename TString>
-  FORCE_INLINE typename TypeTraits::EnableIf<
-      Internals::StringTraits<TString>::has_equals,
-      JsonObjectSubscript<const TString &> >::type
-  operator[](const TString &key) {
-    return as<JsonObject>()[key];
-  }
-  //
-  // JsonObjectSubscript operator[](TKey);
-  // TKey = const char*, const char[N], const FlashStringHelper*
-  template <typename TString>
-  FORCE_INLINE typename TypeTraits::EnableIf<
-      Internals::StringTraits<const TString *>::has_equals,
-      JsonObjectSubscript<const TString *> >::type
-  operator[](const TString *key) {
-    return as<JsonObject>()[key];
-  }
-  //
-  // JsonObjectSubscript operator[](TKey);
-  // TKey = const char*, const char[N], const FlashStringHelper*
-  template <typename TString>
-  FORCE_INLINE typename TypeTraits::EnableIf<
-      Internals::StringTraits<TString *>::has_equals,
-      const JsonObjectSubscript<const TString *> >::type
-  operator[](const TString *key) const {
-    return as<JsonObject>()[key];
-  }
-
- private:
-  const TImpl *impl() const {
-    return static_cast<const TImpl *>(this);
-  }
-};
-
-namespace TypeTraits {
-template <typename T>
-struct IsVariant : IsBaseOf<JsonVariantBase<T>, T> {};
-}
+class JsonVariantBase : public Internals::JsonPrintable<TImpl>,
+                        public JsonVariantCasts<TImpl>,
+                        public JsonVariantComparisons<TImpl>,
+                        public JsonVariantSubscripts<TImpl>,
+                        public TypeTraits::JsonVariantTag {};
 }
--- a/src/ArduinoJson/JsonVariantCasts.hpp
+++ b/src/ArduinoJson/JsonVariantCasts.hpp
@ -0,0 +1,60 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Data/JsonVariantAs.hpp"
+#include "Polyfills/attributes.hpp"
+
+namespace ArduinoJson {
+
+template <typename TImpl>
+class JsonVariantCasts {
+ public:
+#if ARDUINOJSON_ENABLE_DEPRECATED
+  DEPRECATED("use as<JsonArray>() instead")
+  FORCE_INLINE JsonArray &asArray() const {
+    return impl()->template as<JsonArray>();
+  }
+
+  DEPRECATED("use as<JsonObject>() instead")
+  FORCE_INLINE JsonObject &asObject() const {
+    return impl()->template as<JsonObject>();
+  }
+
+  DEPRECATED("use as<char*>() instead")
+  FORCE_INLINE const char *asString() const {
+    return impl()->template as<const char *>();
+  }
+#endif
+
+  // Gets the variant as an array.
+  // Returns a reference to the JsonArray or JsonArray::invalid() if the
+  // variant
+  // is not an array.
+  FORCE_INLINE operator JsonArray &() const {
+    return impl()->template as<JsonArray &>();
+  }
+
+  // Gets the variant as an object.
+  // Returns a reference to the JsonObject or JsonObject::invalid() if the
+  // variant is not an object.
+  FORCE_INLINE operator JsonObject &() const {
+    return impl()->template as<JsonObject &>();
+  }
+
+  template <typename T>
+  FORCE_INLINE operator T() const {
+    return impl()->template as<T>();
+  }
+
+ private:
+  const TImpl *impl() const {
+    return static_cast<const TImpl *>(this);
+  }
+};
+}
--- a/src/ArduinoJson/JsonVariantComparisons.hpp
+++ b/src/ArduinoJson/JsonVariantComparisons.hpp
@ -7,82 +7,138 @@

 #pragma once

-#include "Data/JsonVariantComparer.hpp"
+#include "StringTraits/StringTraits.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsVariant.hpp"

 namespace ArduinoJson {
-template <typename TVariant, typename TComparand>
-inline bool operator==(const JsonVariantBase<TVariant> &variant,
-                       TComparand comparand) {
-  return Internals::JsonVariantComparer<TComparand>::equals(variant, comparand);
-}

-template <typename TVariant, typename TComparand>
-inline typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
-                                     bool>::type
-operator==(TComparand comparand, const JsonVariantBase<TVariant> &variant) {
-  return Internals::JsonVariantComparer<TComparand>::equals(variant, comparand);
-}
+template <typename TImpl>
+class JsonVariantComparisons {
+ public:
+  template <typename TComparand>
+  friend bool operator==(const JsonVariantComparisons &variant,
+                         TComparand comparand) {
+    return variant.equals(comparand);
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator!=(const JsonVariantBase<TVariant> &variant,
-                       TComparand comparand) {
-  return !Internals::JsonVariantComparer<TComparand>::equals(variant,
-                                                             comparand);
-}
+  template <typename TComparand>
+  friend
+      typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
+                                    bool>::type
+      operator==(TComparand comparand, const JsonVariantComparisons &variant) {
+    return variant.equals(comparand);
+  }

-template <typename TVariant, typename TComparand>
-inline typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
-                                     bool>::type
-operator!=(TComparand comparand, const JsonVariantBase<TVariant> &variant) {
-  return !Internals::JsonVariantComparer<TComparand>::equals(variant,
-                                                             comparand);
-}
+  template <typename TComparand>
+  friend bool operator!=(const JsonVariantComparisons &variant,
+                         TComparand comparand) {
+    return !variant.equals(comparand);
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator<=(const JsonVariantBase<TVariant> &left,
-                       TComparand right) {
-  return left.template as<TComparand>() <= right;
-}
+  template <typename TComparand>
+  friend
+      typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
+                                    bool>::type
+      operator!=(TComparand comparand, const JsonVariantComparisons &variant) {
+    return !variant.equals(comparand);
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator<=(TComparand comparand,
-                       const JsonVariantBase<TVariant> &variant) {
-  return comparand <= variant.template as<TComparand>();
-}
+  template <typename TComparand>
+  friend bool operator<=(const JsonVariantComparisons &left, TComparand right) {
+    return left.as<TComparand>() <= right;
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator>=(const JsonVariantBase<TVariant> &variant,
-                       TComparand comparand) {
-  return variant.template as<TComparand>() >= comparand;
-}
+  template <typename TComparand>
+  friend bool operator<=(TComparand comparand,
+                         const JsonVariantComparisons &variant) {
+    return comparand <= variant.as<TComparand>();
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator>=(TComparand comparand,
-                       const JsonVariantBase<TVariant> &variant) {
-  return comparand >= variant.template as<TComparand>();
-}
+  template <typename TComparand>
+  friend bool operator>=(const JsonVariantComparisons &variant,
+                         TComparand comparand) {
+    return variant.as<TComparand>() >= comparand;
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator<(const JsonVariantBase<TVariant> &varian,
-                      TComparand comparand) {
-  return varian.template as<TComparand>() < comparand;
-}
+  template <typename TComparand>
+  friend bool operator>=(TComparand comparand,
+                         const JsonVariantComparisons &variant) {
+    return comparand >= variant.as<TComparand>();
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator<(TComparand comparand,
-                      const JsonVariantBase<TVariant> &variant) {
-  return comparand < variant.template as<TComparand>();
-}
+  template <typename TComparand>
+  friend bool operator<(const JsonVariantComparisons &varian,
+                        TComparand comparand) {
+    return varian.as<TComparand>() < comparand;
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator>(const JsonVariantBase<TVariant> &variant,
-                      TComparand comparand) {
-  return variant.template as<TComparand>() > comparand;
-}
+  template <typename TComparand>
+  friend bool operator<(TComparand comparand,
+                        const JsonVariantComparisons &variant) {
+    return comparand < variant.as<TComparand>();
+  }

-template <typename TVariant, typename TComparand>
-inline bool operator>(TComparand comparand,
-                      const JsonVariantBase<TVariant> &variant) {
-  return comparand > variant.template as<TComparand>();
-}
+  template <typename TComparand>
+  friend bool operator>(const JsonVariantComparisons &variant,
+                        TComparand comparand) {
+    return variant.as<TComparand>() > comparand;
+  }
+
+  template <typename TComparand>
+  friend bool operator>(TComparand comparand,
+                        const JsonVariantComparisons &variant) {
+    return comparand > variant.as<TComparand>();
+  }
+
+ private:
+  const TImpl *impl() const {
+    return static_cast<const TImpl *>(this);
+  }
+
+  template <typename T>
+  const typename Internals::JsonVariantAs<T>::type as() const {
+    return impl()->template as<T>();
+  }
+
+  template <typename T>
+  bool is() const {
+    return impl()->template is<T>();
+  }
+
+  template <typename TString>
+  typename TypeTraits::EnableIf<TypeTraits::IsString<TString>::value,
+                                bool>::type
+  equals(const TString &comparand) const {
+    const char *value = as<const char *>();
+    return Internals::StringTraits<TString>::equals(comparand, value);
+  }
+
+  template <typename TComparand>
+  typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value &&
+                                    !TypeTraits::IsString<TComparand>::value,
+                                bool>::type
+  equals(const TComparand &comparand) const {
+    return as<TComparand>() == comparand;
+  }
+
+  template <typename TVariant2>
+  bool equals(const JsonVariantComparisons<TVariant2> &right) const {
+    using namespace Internals;
+    if (is<bool>() && right.template is<bool>())
+      return as<bool>() == right.template as<bool>();
+    if (is<JsonInteger>() && right.template is<JsonInteger>())
+      return as<JsonInteger>() == right.template as<JsonInteger>();
+    if (is<JsonFloat>() && right.template is<JsonFloat>())
+      return as<JsonFloat>() == right.template as<JsonFloat>();
+    if (is<JsonArray>() && right.template is<JsonArray>())
+      return as<JsonArray>() == right.template as<JsonArray>();
+    if (is<JsonObject>() && right.template is<JsonObject>())
+      return as<JsonObject>() == right.template as<JsonObject>();
+    if (is<char *>() && right.template is<char *>())
+      return strcmp(as<char *>(), right.template as<char *>()) == 0;
+
+    return false;
+  }
+};
 }
--- a/src/ArduinoJson/JsonVariantImpl.hpp
+++ b/src/ArduinoJson/JsonVariantImpl.hpp
@ -56,16 +56,14 @@ inline T JsonVariant::variantAsInteger() const {
      return 0;
    case JSON_POSITIVE_INTEGER:
    case JSON_BOOLEAN:
-      return static_cast<T>(_content.asInteger);
+      return T(_content.asInteger);
    case JSON_NEGATIVE_INTEGER:
-      return static_cast<T>(_content.asInteger * -1);
+      return T(~_content.asInteger + 1);
    case JSON_STRING:
    case JSON_UNPARSED:
-      if (!_content.asString) return 0;
-      if (!strcmp("true", _content.asString)) return 1;
      return Polyfills::parseInteger<T>(_content.asString);
    default:
-      return static_cast<T>(_content.asFloat);
+      return T(_content.asFloat);
  }
 }

@ -117,7 +115,8 @@ inline bool JsonVariant::variantIsInteger() const {
 inline bool JsonVariant::variantIsFloat() const {
  using namespace Internals;

-  return _type == JSON_FLOAT || _type == JSON_POSITIVE_INTEGER || _type == JSON_NEGATIVE_INTEGER || 
+  return _type == JSON_FLOAT || _type == JSON_POSITIVE_INTEGER ||
+         _type == JSON_NEGATIVE_INTEGER ||
         (_type == JSON_UNPARSED && Polyfills::isFloat(_content.asString));
 }

--- a/src/ArduinoJson/JsonVariantSubscripts.hpp
+++ b/src/ArduinoJson/JsonVariantSubscripts.hpp
@ -0,0 +1,89 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Data/JsonVariantAs.hpp"
+#include "Polyfills/attributes.hpp"
+#include "StringTraits/StringTraits.hpp"
+#include "TypeTraits/EnableIf.hpp"
+
+namespace ArduinoJson {
+
+// Forward declarations.
+class JsonArraySubscript;
+template <typename TKey>
+class JsonObjectSubscript;
+
+template <typename TImpl>
+class JsonVariantSubscripts {
+ public:
+  // Mimics an array or an object.
+  // Returns the size of the array or object if the variant has that type.
+  // Returns 0 if the variant is neither an array nor an object
+  size_t size() const {
+    return impl()->template as<JsonArray>().size() +
+           impl()->template as<JsonObject>().size();
+  }
+
+  // Mimics an array.
+  // Returns the element at specified index if the variant is an array.
+  // Returns JsonVariant::invalid() if the variant is not an array.
+  FORCE_INLINE const JsonArraySubscript operator[](size_t index) const;
+  FORCE_INLINE JsonArraySubscript operator[](size_t index);
+
+  // Mimics an object.
+  // Returns the value associated with the specified key if the variant is
+  // an object.
+  // Return JsonVariant::invalid() if the variant is not an object.
+  //
+  // const JsonObjectSubscript operator[](TKey) const;
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  FORCE_INLINE typename TypeTraits::EnableIf<
+      Internals::StringTraits<TString>::has_equals,
+      const JsonObjectSubscript<const TString &> >::type
+  operator[](const TString &key) const {
+    return impl()->template as<JsonObject>()[key];
+  }
+  //
+  // const JsonObjectSubscript operator[](TKey) const;
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  FORCE_INLINE typename TypeTraits::EnableIf<
+      Internals::StringTraits<TString>::has_equals,
+      JsonObjectSubscript<const TString &> >::type
+  operator[](const TString &key) {
+    return impl()->template as<JsonObject>()[key];
+  }
+  //
+  // JsonObjectSubscript operator[](TKey);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  FORCE_INLINE typename TypeTraits::EnableIf<
+      Internals::StringTraits<const TString *>::has_equals,
+      JsonObjectSubscript<const TString *> >::type
+  operator[](const TString *key) {
+    return impl()->template as<JsonObject>()[key];
+  }
+  //
+  // JsonObjectSubscript operator[](TKey);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  FORCE_INLINE typename TypeTraits::EnableIf<
+      Internals::StringTraits<TString *>::has_equals,
+      const JsonObjectSubscript<const TString *> >::type
+  operator[](const TString *key) const {
+    return impl()->template as<JsonObject>()[key];
+  }
+
+ private:
+  const TImpl *impl() const {
+    return static_cast<const TImpl *>(this);
+  }
+};
+}
--- a/src/ArduinoJson/Polyfills/attributes.hpp
+++ b/src/ArduinoJson/Polyfills/attributes.hpp
@ -7,11 +7,14 @@

 #pragma once

-#ifdef _MSC_VER
+#ifdef _MSC_VER  // Visual Studio
+
 #define FORCE_INLINE __forceinline
 #define NO_INLINE __declspec(noinline)
 #define DEPRECATED(msg) __declspec(deprecated(msg))
-#else
+
+#elif defined(__GNUC__)  // GCC or Clang
+
 #define FORCE_INLINE __attribute__((always_inline))
 #define NO_INLINE __attribute__((noinline))
 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
@ -19,4 +22,11 @@
 #else
 #define DEPRECATED(msg) __attribute__((deprecated))
 #endif
+
+#else  // Other compilers
+
+#define FORCE_INLINE
+#define NO_INLINE
+#define DEPRECATED(msg)
+
 #endif
--- a/src/ArduinoJson/Polyfills/math.hpp
+++ b/src/ArduinoJson/Polyfills/math.hpp
@ -7,126 +7,16 @@

 #pragma once

-// If Visual Studo
-#if defined(_MSC_VER)
-
-#include <float.h>
-#include <limits>
-
 namespace ArduinoJson {
 namespace Polyfills {
 template <typename T>
 bool isNaN(T x) {
-  return _isnan(x) != 0;
+  return x != x;
 }

 template <typename T>
 bool isInfinity(T x) {
-  return !_finite(x);
-}
-
-template <typename T>
-T nan() {
-  return std::numeric_limits<T>::quiet_NaN();
-}
-
-template <typename T>
-T inf() {
-  return std::numeric_limits<T>::infinity();
+  return x != 0.0 && x * 2 == x;
 }
 }
 }
-
-#else
-
-#include <math.h>
-
-// GCC warning: "conversion to 'float' from 'double' may alter its value"
-#ifdef __GNUC__
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#pragma GCC diagnostic push
-#endif
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
-#pragma GCC diagnostic ignored "-Wfloat-conversion"
-#else
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif
-#endif
-
-// Workaround for libs that #undef isnan or isinf
-// https://bblanchon.github.io/ArduinoJson//issues/284
-#if !defined(isnan) || !defined(isinf)
-namespace std {}
-#endif
-
-namespace ArduinoJson {
-namespace Polyfills {
-
-template <typename T>
-bool isNaN(T x) {
-// Workaround for libs that #undef isnan
-// https://bblanchon.github.io/ArduinoJson//issues/284
-#ifndef isnan
-  using namespace std;
-#endif
-
-  return isnan(x);
-}
-
-#if defined(_GLIBCXX_HAVE_ISNANL) && _GLIBCXX_HAVE_ISNANL
-template <>
-inline bool isNaN<double>(double x) {
-  return isnanl(x);
-}
-#endif
-
-#if defined(_GLIBCXX_HAVE_ISNANF) && _GLIBCXX_HAVE_ISNANF
-template <>
-inline bool isNaN<float>(float x) {
-  return isnanf(x);
-}
-#endif
-
-template <typename T>
-bool isInfinity(T x) {
-// Workaround for libs that #undef isinf
-// https://bblanchon.github.io/ArduinoJson//issues/284
-#ifndef isinf
-  using namespace std;
-#endif
-
-  return isinf(x);
-}
-
-#if defined(_GLIBCXX_HAVE_ISINFL) && _GLIBCXX_HAVE_ISINFL
-template <>
-inline bool isInfinity<double>(double x) {
-  return isinfl(x);
-}
-#endif
-
-#if defined(_GLIBCXX_HAVE_ISINFF) && _GLIBCXX_HAVE_ISINFF
-template <>
-inline bool isInfinity<float>(float x) {
-  return isinff(x);
-}
-#endif
-
-template <typename T>
-T nan() {
-  return static_cast<T>(NAN);
-}
-
-template <typename T>
-T inf() {
-  return static_cast<T>(INFINITY);
-}
-
-#if defined(__GNUC__)
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-#pragma GCC diagnostic pop
-#endif
-#endif
-}
-}
-#endif
--- a/src/ArduinoJson/Polyfills/normalize.hpp
+++ b/src/ArduinoJson/Polyfills/normalize.hpp
@ -1,103 +0,0 @@
-// Copyright Benoit Blanchon 2014-2017
-// MIT License
-//
-// Arduino JSON library
-// https://bblanchon.github.io/ArduinoJson/
-// If you like this project, please add a star!
-
-#pragma once
-
-#include "../Configuration.hpp"
-
-namespace ArduinoJson {
-namespace Polyfills {
-template <typename T>
-int16_t normalize(T& value) {
-  int16_t powersOf10 = 0;
-
-  if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) {
-#if !defined(__SIZEOF_DOUBLE__) || __SIZEOF_DOUBLE__ >= 8
-    if (value >= 1e256) {
-      value /= 1e256;
-      powersOf10 = int16_t(powersOf10 + 256);
-    }
-    if (value >= 1e128) {
-      value /= 1e128;
-      powersOf10 = int16_t(powersOf10 + 128);
-    }
-    if (value >= 1e64) {
-      value /= 1e64;
-      powersOf10 = int16_t(powersOf10 + 64);
-    }
-#endif
-    if (value >= 1e32) {
-      value /= 1e32;
-      powersOf10 = int16_t(powersOf10 + 32);
-    }
-    if (value >= 1e16) {
-      value /= 1e16;
-      powersOf10 = int16_t(powersOf10 + 16);
-    }
-    if (value >= 1e8) {
-      value /= 1e8;
-      powersOf10 = int16_t(powersOf10 + 8);
-    }
-    if (value >= 1e4) {
-      value /= 1e4;
-      powersOf10 = int16_t(powersOf10 + 4);
-    }
-    if (value >= 1e2) {
-      value /= 1e2;
-      powersOf10 = int16_t(powersOf10 + 2);
-    }
-    if (value >= 1e1) {
-      value /= 1e1;
-      powersOf10 = int16_t(powersOf10 + 1);
-    }
-  }
-
-  if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) {
-#if !defined(__SIZEOF_DOUBLE__) || __SIZEOF_DOUBLE__ >= 8
-    if (value < 1e-255) {
-      value *= 1e256;
-      powersOf10 = int16_t(powersOf10 - 256);
-    }
-    if (value < 1e-127) {
-      value *= 1e128;
-      powersOf10 = int16_t(powersOf10 - 128);
-    }
-    if (value < 1e-63) {
-      value *= 1e64;
-      powersOf10 = int16_t(powersOf10 - 64);
-    }
-#endif
-    if (value < 1e-31) {
-      value *= 1e32;
-      powersOf10 = int16_t(powersOf10 - 32);
-    }
-    if (value < 1e-15) {
-      value *= 1e16;
-      powersOf10 = int16_t(powersOf10 - 16);
-    }
-    if (value < 1e-7) {
-      value *= 1e8;
-      powersOf10 = int16_t(powersOf10 - 8);
-    }
-    if (value < 1e-3) {
-      value *= 1e4;
-      powersOf10 = int16_t(powersOf10 - 4);
-    }
-    if (value < 1e-1) {
-      value *= 1e2;
-      powersOf10 = int16_t(powersOf10 - 2);
-    }
-    if (value < 1e0) {
-      value *= 1e1;
-      powersOf10 = int16_t(powersOf10 - 1);
-    }
-  }
-
-  return powersOf10;
-}
-}
-}
--- a/src/ArduinoJson/Polyfills/parseFloat.hpp
+++ b/src/ArduinoJson/Polyfills/parseFloat.hpp
@ -20,16 +20,20 @@ inline T parseFloat(const char* s) {
  typedef typename traits::mantissa_type mantissa_t;
  typedef typename traits::exponent_type exponent_t;

-  if (!s) return 0;
+  if (!s) return 0;  // NULL

  bool negative_result = false;
  switch (*s) {
    case '-':
      negative_result = true;
+      s++;
+      break;
    case '+':
      s++;
+      break;
  }

+  if (*s == 't') return 1;  // true
  if (*s == 'n' || *s == 'N') return traits::nan();
  if (*s == 'i' || *s == 'I')
    return negative_result ? -traits::inf() : traits::inf();
--- a/src/ArduinoJson/Polyfills/parseInteger.hpp
+++ b/src/ArduinoJson/Polyfills/parseInteger.hpp
@ -16,7 +16,9 @@ namespace ArduinoJson {
 namespace Polyfills {
 template <typename T>
 T parseInteger(const char *s) {
-  if (!s) return 0;
+  if (!s) return 0;  // NULL
+
+  if (*s == 't') return 1;  // "true"

  T result = 0;
  bool negative_result = false;
@ -24,17 +26,19 @@ T parseInteger(const char *s) {
  switch (*s) {
    case '-':
      negative_result = true;
+      s++;
+      break;
    case '+':
      s++;
      break;
  }

  while (isdigit(*s)) {
-    result = static_cast<T>(result * 10 + (*s - '0'));
+    result = T(result * 10 + T(*s - '0'));
    s++;
  }

-  return negative_result ? static_cast<T>(result * -1) : result;
+  return negative_result ? T(~result + 1) : result;
 }
 }
 }
--- a/src/ArduinoJson/Serialization/FloatParts.hpp
+++ b/src/ArduinoJson/Serialization/FloatParts.hpp
@ -0,0 +1,92 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+#include "../Polyfills/math.hpp"
+#include "../TypeTraits/FloatTraits.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TFloat>
+struct FloatParts {
+  uint32_t integral;
+  uint32_t decimal;
+  int16_t exponent;
+  int8_t decimalPlaces;
+
+  FloatParts(TFloat value) {
+    uint32_t maxDecimalPart = sizeof(TFloat) >= 8 ? 1000000000 : 1000000;
+    decimalPlaces = sizeof(TFloat) >= 8 ? 9 : 6;
+
+    exponent = normalize(value);
+
+    integral = uint32_t(value);
+    // reduce number of decimal places by the number of integral places
+    for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) {
+      maxDecimalPart /= 10;
+      decimalPlaces--;
+    }
+
+    TFloat remainder = (value - TFloat(integral)) * TFloat(maxDecimalPart);
+
+    decimal = uint32_t(remainder);
+    remainder = remainder - TFloat(decimal);
+
+    // rounding:
+    // increment by 1 if remainder >= 0.5
+    decimal += uint32_t(remainder * 2);
+    if (decimal >= maxDecimalPart) {
+      decimal = 0;
+      integral++;
+      if (exponent && integral >= 10) {
+        exponent++;
+        integral = 1;
+      }
+    }
+
+    // remove trailing zeros
+    while (decimal % 10 == 0 && decimalPlaces > 0) {
+      decimal /= 10;
+      decimalPlaces--;
+    }
+  }
+
+  static int16_t normalize(TFloat& value) {
+    typedef TypeTraits::FloatTraits<TFloat> traits;
+    int16_t powersOf10 = 0;
+
+    int8_t index = sizeof(TFloat) == 8 ? 8 : 5;
+    int bit = 1 << index;
+
+    if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) {
+      for (; index >= 0; index--) {
+        if (value >= traits::positiveBinaryPowerOfTen(index)) {
+          value *= traits::negativeBinaryPowerOfTen(index);
+          powersOf10 = int16_t(powersOf10 + bit);
+        }
+        bit >>= 1;
+      }
+    }
+
+    if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) {
+      for (; index >= 0; index--) {
+        if (value < traits::negativeBinaryPowerOfTenPlusOne(index)) {
+          value *= traits::positiveBinaryPowerOfTen(index);
+          powersOf10 = int16_t(powersOf10 - bit);
+        }
+        bit >>= 1;
+      }
+    }
+
+    return powersOf10;
+  }
+};
+}
+}
--- a/src/ArduinoJson/Serialization/JsonSerializerImpl.hpp
+++ b/src/ArduinoJson/Serialization/JsonSerializerImpl.hpp
@ -90,7 +90,8 @@ inline void ArduinoJson::Internals::JsonSerializer<Writer>::serialize(
      return;

    case JSON_NEGATIVE_INTEGER:
-      writer.writeRaw('-');
+      writer.writeRaw('-');  // Falls through.
+
    case JSON_POSITIVE_INTEGER:
      writer.writeInteger(variant._content.asInteger);
      return;
--- a/src/ArduinoJson/Serialization/JsonWriter.hpp
+++ b/src/ArduinoJson/Serialization/JsonWriter.hpp
@ -9,12 +9,9 @@

 #include <stdint.h>
 #include "../Data/Encoding.hpp"
-#include "../Data/JsonFloat.hpp"
 #include "../Data/JsonInteger.hpp"
 #include "../Polyfills/attributes.hpp"
-#include "../Polyfills/math.hpp"
-#include "../Polyfills/normalize.hpp"
-#include "../TypeTraits/FloatTraits.hpp"
+#include "../Serialization/FloatParts.hpp"

 namespace ArduinoJson {
 namespace Internals {
@ -28,28 +25,40 @@ namespace Internals {
 // indentation.
 template <typename Print>
 class JsonWriter {
-  static const uint8_t maxDecimalPlaces = sizeof(JsonFloat) >= 8 ? 9 : 6;
-  static const uint32_t maxDecimalPart =
-      sizeof(JsonFloat) >= 8 ? 1000000000 : 1000000;
-
 public:
  explicit JsonWriter(Print &sink) : _sink(sink), _length(0) {}

  // Returns the number of bytes sent to the Print implementation.
  // This is very handy for implementations of printTo() that must return the
  // number of bytes written.
-  size_t bytesWritten() const { return _length; }
+  size_t bytesWritten() const {
+    return _length;
+  }

-  void beginArray() { writeRaw('['); }
-  void endArray() { writeRaw(']'); }
+  void beginArray() {
+    writeRaw('[');
+  }
+  void endArray() {
+    writeRaw(']');
+  }

-  void beginObject() { writeRaw('{'); }
-  void endObject() { writeRaw('}'); }
+  void beginObject() {
+    writeRaw('{');
+  }
+  void endObject() {
+    writeRaw('}');
+  }

-  void writeColon() { writeRaw(':'); }
-  void writeComma() { writeRaw(','); }
+  void writeColon() {
+    writeRaw(':');
+  }
+  void writeComma() {
+    writeRaw(',');
+  }

-  void writeBoolean(bool value) { writeRaw(value ? "true" : "false"); }
+  void writeBoolean(bool value) {
+    writeRaw(value ? "true" : "false");
+  }

  void writeString(const char *value) {
    if (!value) {
@ -71,7 +80,8 @@ class JsonWriter {
    }
  }

-  void writeFloat(JsonFloat value) {
+  template <typename TFloat>
+  void writeFloat(TFloat value) {
    if (Polyfills::isNaN(value)) return writeRaw("NaN");

    if (value < 0.0) {
@ -81,32 +91,31 @@ class JsonWriter {

    if (Polyfills::isInfinity(value)) return writeRaw("Infinity");

-    uint32_t integralPart, decimalPart;
-    int16_t powersOf10;
-    splitFloat(value, integralPart, decimalPart, powersOf10);
+    FloatParts<TFloat> parts(value);

-    writeInteger(integralPart);
-    if (decimalPart) writeDecimals(decimalPart, maxDecimalPlaces);
+    writeInteger(parts.integral);
+    if (parts.decimalPlaces) writeDecimals(parts.decimal, parts.decimalPlaces);

-    if (powersOf10 < 0) {
+    if (parts.exponent < 0) {
      writeRaw("e-");
-      writeInteger(-powersOf10);
+      writeInteger(-parts.exponent);
    }

-    if (powersOf10 > 0) {
+    if (parts.exponent > 0) {
      writeRaw('e');
-      writeInteger(powersOf10);
+      writeInteger(parts.exponent);
    }
  }

  template <typename UInt>
  void writeInteger(UInt value) {
    char buffer[22];
-    char *ptr = buffer + sizeof(buffer) - 1;
+    char *end = buffer + sizeof(buffer) - 1;
+    char *ptr = end;

    *ptr = 0;
    do {
-      *--ptr = static_cast<char>(value % 10 + '0');
+      *--ptr = char(value % 10 + '0');
      value = UInt(value / 10);
    } while (value);

@ -114,15 +123,9 @@ class JsonWriter {
  }

  void writeDecimals(uint32_t value, int8_t width) {
-    // remove trailing zeros
-    while (value % 10 == 0 && width > 0) {
-      value /= 10;
-      width--;
-    }
-
    // buffer should be big enough for all digits, the dot and the null
    // terminator
-    char buffer[maxDecimalPlaces + 2];
+    char buffer[16];
    char *ptr = buffer + sizeof(buffer) - 1;

    // write the string in reverse order
@ -137,8 +140,12 @@ class JsonWriter {
    writeRaw(ptr);
  }

-  void writeRaw(const char *s) { _length += _sink.print(s); }
-  void writeRaw(char c) { _length += _sink.print(c); }
+  void writeRaw(const char *s) {
+    _length += _sink.print(s);
+  }
+  void writeRaw(char c) {
+    _length += _sink.print(c);
+  }

 protected:
  Print &_sink;
@ -146,30 +153,6 @@ class JsonWriter {

 private:
  JsonWriter &operator=(const JsonWriter &);  // cannot be assigned
-
-  void splitFloat(JsonFloat value, uint32_t &integralPart,
-                  uint32_t &decimalPart, int16_t &powersOf10) {
-    powersOf10 = Polyfills::normalize(value);
-
-    integralPart = uint32_t(value);
-    JsonFloat remainder = value - JsonFloat(integralPart);
-
-    decimalPart = uint32_t(remainder * maxDecimalPart);
-    remainder = remainder * maxDecimalPart - JsonFloat(decimalPart);
-
-    // rounding
-    if (remainder > 0.5) {
-      decimalPart++;
-      if (decimalPart >= maxDecimalPart) {
-        decimalPart -= maxDecimalPart;
-        integralPart++;
-        if (powersOf10 && integralPart >= 10) {
-          powersOf10++;
-          integralPart /= 10;
-        }
-      }
-    }
-  }
 };
 }
 }
--- a/src/ArduinoJson/Serialization/StaticStringBuilder.hpp
+++ b/src/ArduinoJson/Serialization/StaticStringBuilder.hpp
@ -28,7 +28,7 @@ class StaticStringBuilder {
    char *begin = p;
    while (p < end && *s) *p++ = *s++;
    *p = '\0';
-    return p - begin;
+    return size_t(p - begin);
  }

 private:
--- a/src/ArduinoJson/StaticJsonBuffer.hpp
+++ b/src/ArduinoJson/StaticJsonBuffer.hpp
@ -9,16 +9,6 @@

 #include "JsonBufferBase.hpp"

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

 class StaticJsonBufferBase : public JsonBufferBase<StaticJsonBufferBase> {
@ -54,23 +44,36 @@ class StaticJsonBufferBase : public JsonBufferBase<StaticJsonBufferBase> {
  StaticJsonBufferBase(char* buffer, size_t capa)
      : _buffer(buffer), _capacity(capa), _size(0) {}

+  // Gets the capacity of the buffer in bytes
  size_t capacity() const {
    return _capacity;
  }
+
+  // Gets the current usage of the buffer in bytes
  size_t size() const {
    return _size;
  }

+  // Allocates the specified amount of bytes in the buffer
  virtual void* alloc(size_t bytes) {
    alignNextAlloc();
    if (!canAlloc(bytes)) return NULL;
    return doAlloc(bytes);
  }

+  // Resets the buffer.
+  // USE WITH CAUTION: this invalidates all previously allocated data
+  void clear() {
+    _size = 0;
+  }
+
  String startString() {
    return String(this);
  }

+ protected:
+  ~StaticJsonBufferBase() {}
+
 private:
  void alignNextAlloc() {
    _size = round_size_up(_size);
@ -91,6 +94,16 @@ class StaticJsonBufferBase : public JsonBufferBase<StaticJsonBufferBase> {
  size_t _size;
 };

+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic push
+#endif
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
 // Implements a JsonBuffer with fixed memory allocation.
 // The template paramenter CAPACITY specifies the capacity of the buffer in
 // bytes.
--- a/src/ArduinoJson/StringTraits/CharPointer.hpp
+++ b/src/ArduinoJson/StringTraits/CharPointer.hpp
@ -23,12 +23,12 @@ struct CharPointerTraits {
      ++_ptr;
    }

-    TChar current() const {
-      return _ptr[0];
+    char current() const {
+      return char(_ptr[0]);
    }

-    TChar next() const {
-      return _ptr[1];
+    char next() const {
+      return char(_ptr[1]);
    }
  };

--- a/src/ArduinoJson/StringTraits/FlashString.hpp
+++ b/src/ArduinoJson/StringTraits/FlashString.hpp
@ -34,15 +34,15 @@ struct StringTraits<const __FlashStringHelper*, void> {
  };

  static bool equals(const __FlashStringHelper* str, const char* expected) {
-    return strcmp_P(expected, (PGM_P)str) == 0;
+    return strcmp_P(expected, (const char*)str) == 0;
  }

  template <typename Buffer>
  static char* duplicate(const __FlashStringHelper* str, Buffer* buffer) {
    if (!str) return NULL;
-    size_t size = strlen_P((PGM_P)str) + 1;
+    size_t size = strlen_P((const char*)str) + 1;
    void* dup = buffer->alloc(size);
-    if (dup != NULL) memcpy_P(dup, (PGM_P)str, size);
+    if (dup != NULL) memcpy_P(dup, (const char*)str, size);
    return static_cast<char*>(dup);
  }

--- a/src/ArduinoJson/TypeTraits/FloatTraits.hpp
+++ b/src/ArduinoJson/TypeTraits/FloatTraits.hpp
@ -9,6 +9,7 @@

 #include <stdint.h>
 #include <stdlib.h>  // for size_t
+#include "../Configuration.hpp"
 #include "../Polyfills/math.hpp"

 namespace ArduinoJson {
@ -17,7 +18,6 @@ namespace TypeTraits {
 template <typename T, size_t = sizeof(T)>
 struct FloatTraits {};

-#if !defined(__SIZEOF_DOUBLE__) || __SIZEOF_DOUBLE__ >= 8
 template <typename T>
 struct FloatTraits<T, 8 /*64bits*/> {
  typedef int64_t mantissa_type;
@ -30,27 +30,65 @@ struct FloatTraits<T, 8 /*64bits*/> {

  template <typename TExponent>
  static T make_float(T m, TExponent e) {
-    if (e >= 0)
-      return m * (e & 1 ? 1e1 : 1) * (e & 2 ? 1e2 : 1) * (e & 4 ? 1e4 : 1) *
-             (e & 8 ? 1e8 : 1) * (e & 16 ? 1e16 : 1) * (e & 32 ? 1e32 : 1) *
-             (e & 64 ? 1e64 : 1) * (e & 128 ? 1e128 : 1) *
-             (e & 256 ? 1e256 : 1);
-    e = TExponent(-e);
-    return m * (e & 1 ? 1e-1 : 1) * (e & 2 ? 1e-2 : 1) * (e & 4 ? 1e-4 : 1) *
-           (e & 8 ? 1e-8 : 1) * (e & 16 ? 1e-16 : 1) * (e & 32 ? 1e-32 : 1) *
-           (e & 64 ? 1e-64 : 1) * (e & 128 ? 1e-128 : 1) *
-           (e & 256 ? 1e-256 : 1);
+    if (e > 0) {
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1) m *= positiveBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    } else {
+      e = TExponent(-e);
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1) m *= negativeBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    }
+    return m;
+  }
+
+  static T positiveBinaryPowerOfTen(int index) {
+    static T factors[] = {
+        1e1, 1e2, 1e4, 1e8, 1e16, 1e32,
+        // workaround to support platforms with single precision literals
+        forge(0x4D384F03, 0xE93FF9F5), forge(0x5A827748, 0xF9301D32),
+        forge(0x75154FDD, 0x7F73BF3C)};
+    return factors[index];
+  }
+
+  static T negativeBinaryPowerOfTen(int index) {
+    static T factors[] = {
+        1e-1, 1e-2, 1e-4, 1e-8, 1e-16, 1e-32,
+        // workaround to support platforms with single precision literals
+        forge(0x32A50FFD, 0x44F4A73D), forge(0x255BBA08, 0xCF8C979D),
+        forge(0x0AC80628, 0x64AC6F43)};
+    return factors[index];
+  }
+
+  static T negativeBinaryPowerOfTenPlusOne(int index) {
+    static T factors[] = {
+        1e0, 1e-1, 1e-3, 1e-7, 1e-15, 1e-31,
+        // workaround to support platforms with single precision literals
+        forge(0x32DA53FC, 0x9631D10D), forge(0x25915445, 0x81B7DEC2),
+        forge(0x0AFE07B2, 0x7DD78B14)};
+    return factors[index];
  }

  static T nan() {
-    return Polyfills::nan<T>();
+    return forge(0x7ff80000, 0x00000000);
  }

  static T inf() {
-    return Polyfills::inf<T>();
+    return forge(0x7ff00000, 0x00000000);
+  }
+
+  static T forge(uint32_t msb, uint32_t lsb) {
+    union {
+      uint64_t integerBits;
+      T floatBits;
+    };
+    integerBits = (uint64_t(msb) << 32) | lsb;
+    return floatBits;
  }
 };
-#endif

 template <typename T>
 struct FloatTraits<T, 4 /*32bits*/> {
@ -64,20 +102,51 @@ struct FloatTraits<T, 4 /*32bits*/> {

  template <typename TExponent>
  static T make_float(T m, TExponent e) {
-    if (e > 0)
-      return m * (e & 1 ? 1e1f : 1) * (e & 2 ? 1e2f : 1) * (e & 4 ? 1e4f : 1) *
-             (e & 8 ? 1e8f : 1) * (e & 16 ? 1e16f : 1) * (e & 32 ? 1e32f : 1);
-    e = -e;
-    return m * (e & 1 ? 1e-1f : 1) * (e & 2 ? 1e-2f : 1) * (e & 4 ? 1e-4f : 1) *
-           (e & 8 ? 1e-8f : 1) * (e & 16 ? 1e-16f : 1) * (e & 32 ? 1e-32f : 1);
+    if (e > 0) {
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1) m *= positiveBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    } else {
+      e = -e;
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1) m *= negativeBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    }
+    return m;
+  }
+
+  static T positiveBinaryPowerOfTen(int index) {
+    static T factors[] = {1e1f, 1e2f, 1e4f, 1e8f, 1e16f, 1e32f};
+    return factors[index];
+  }
+
+  static T negativeBinaryPowerOfTen(int index) {
+    static T factors[] = {1e-1f, 1e-2f, 1e-4f, 1e-8f, 1e-16f, 1e-32f};
+    return factors[index];
+  }
+
+  static T negativeBinaryPowerOfTenPlusOne(int index) {
+    static T factors[] = {1e0f, 1e-1f, 1e-3f, 1e-7f, 1e-15f, 1e-31f};
+    return factors[index];
+  }
+
+  static T forge(uint32_t bits) {
+    union {
+      uint32_t integerBits;
+      T floatBits;
+    };
+    integerBits = bits;
+    return floatBits;
  }

  static T nan() {
-    return Polyfills::nan<T>();
+    return forge(0x7fc00000);
  }

  static T inf() {
-    return Polyfills::inf<T>();
+    return forge(0x7f800000);
  }
 };
 }
--- a/src/ArduinoJson/TypeTraits/IsVariant.hpp
+++ b/src/ArduinoJson/TypeTraits/IsVariant.hpp
@ -0,0 +1,20 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "IsBaseOf.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+class JsonVariantTag {};
+
+template <typename T>
+struct IsVariant : IsBaseOf<JsonVariantTag, T> {};
+}
+}
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -19,13 +19,14 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 		-Wformat=2
 		-Winit-self
 		-Wmissing-include-dirs
-		-Wparentheses
 		-Wnon-virtual-dtor
 		-Wold-style-cast
 		-Woverloaded-virtual
+		-Wparentheses
 		-Wredundant-decls
 		-Wshadow
 		-Wsign-promo
+		-Wstrict-aliasing
 		-Wstrict-overflow=5
 		-Wundef
 	)
--- a/test/DynamicJsonBuffer/CMakeLists.txt
+++ b/test/DynamicJsonBuffer/CMakeLists.txt
@ -8,10 +8,11 @@
 add_executable(DynamicJsonBufferTests 
 	alloc.cpp
 	createArray.cpp
-	no_memory.cpp
 	createObject.cpp
-	strdup.cpp
+	no_memory.cpp
+	size.cpp
 	startString.cpp
+	strdup.cpp
 )

 target_link_libraries(DynamicJsonBufferTests catch)
--- a/test/DynamicJsonBuffer/alloc.cpp
+++ b/test/DynamicJsonBuffer/alloc.cpp
@ -7,6 +7,7 @@

 #include <ArduinoJson.h>
 #include <catch.hpp>
+#include <sstream>

 static bool isAligned(void* ptr) {
  const size_t mask = sizeof(void*) - 1;
@ -14,32 +15,64 @@ static bool isAligned(void* ptr) {
  return (addr & mask) == 0;
 }

+std::stringstream allocatorLog;
+
+struct SpyingAllocator : DefaultAllocator {
+  void* allocate(size_t n) {
+    allocatorLog << "A" << (n - DynamicJsonBuffer::EmptyBlockSize);
+    return DefaultAllocator::allocate(n);
+  }
+  void deallocate(void* p) {
+    allocatorLog << "F";
+    return DefaultAllocator::deallocate(p);
+  }
+};
+
 TEST_CASE("DynamicJsonBuffer::alloc()") {
-  DynamicJsonBuffer buffer;
-
-  SECTION("InitialSizeIsZero") {
-    REQUIRE(0 == buffer.size());
-  }
-
-  SECTION("SizeIncreasesAfterAlloc") {
-    buffer.alloc(1);
-    REQUIRE(1U <= buffer.size());
-    buffer.alloc(1);
-    REQUIRE(2U <= buffer.size());
-  }
-
-  SECTION("ReturnDifferentPointer") {
+  SECTION("Returns different pointers") {
+    DynamicJsonBuffer buffer;
    void* p1 = buffer.alloc(1);
    void* p2 = buffer.alloc(2);
    REQUIRE(p1 != p2);
  }

+  SECTION("Doubles allocation size when full") {
+    allocatorLog.str("");
+    {
+      DynamicJsonBufferBase<SpyingAllocator> buffer(1);
+      buffer.alloc(1);
+      buffer.alloc(1);
+    }
+    REQUIRE(allocatorLog.str() == "A1A2FF");
+  }
+
+  SECTION("Resets allocation size after clear()") {
+    allocatorLog.str("");
+    {
+      DynamicJsonBufferBase<SpyingAllocator> buffer(1);
+      buffer.alloc(1);
+      buffer.alloc(1);
+      buffer.clear();
+      buffer.alloc(1);
+    }
+    REQUIRE(allocatorLog.str() == "A1A2FFA1F");
+  }
+
+  SECTION("Makes a big allocation when needed") {
+    allocatorLog.str("");
+    {
+      DynamicJsonBufferBase<SpyingAllocator> buffer(1);
+      buffer.alloc(42);
+    }
+    REQUIRE(allocatorLog.str() == "A42F");
+  }
+
  SECTION("Alignment") {
    // make room for two but not three
-    buffer = DynamicJsonBuffer(2 * sizeof(void*) + 1);
+    DynamicJsonBuffer tinyBuf(2 * sizeof(void*) + 1);

-    REQUIRE(isAligned(buffer.alloc(1)));  // this on is aligned by design
-    REQUIRE(isAligned(buffer.alloc(1)));  // this one fits in the first block
-    REQUIRE(isAligned(buffer.alloc(1)));  // this one requires a new block
+    REQUIRE(isAligned(tinyBuf.alloc(1)));  // this on is aligned by design
+    REQUIRE(isAligned(tinyBuf.alloc(1)));  // this one fits in the first block
+    REQUIRE(isAligned(tinyBuf.alloc(1)));  // this one requires a new block
  }
 }
--- a/test/DynamicJsonBuffer/size.cpp
+++ b/test/DynamicJsonBuffer/size.cpp
@ -0,0 +1,30 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("DynamicJsonBuffer::size()") {
+  DynamicJsonBuffer buffer;
+
+  SECTION("Initial size is 0") {
+    REQUIRE(0 == buffer.size());
+  }
+
+  SECTION("Increases after alloc()") {
+    buffer.alloc(1);
+    REQUIRE(1U <= buffer.size());
+    buffer.alloc(1);
+    REQUIRE(2U <= buffer.size());
+  }
+
+  SECTION("Goes back to 0 after clear()") {
+    buffer.alloc(1);
+    buffer.clear();
+    REQUIRE(0 == buffer.size());
+  }
+}
--- a/test/IntegrationTests/CMakeLists.txt
+++ b/test/IntegrationTests/CMakeLists.txt
@ -10,5 +10,12 @@ add_executable(IntegrationTests
 	round_trip.cpp
 )

+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	target_compile_options(IntegrationTests
+		PUBLIC
+		-fsingle-precision-constant # issue 544
+	)
+endif()
+
 target_link_libraries(IntegrationTests catch)
 add_test(IntegrationTests IntegrationTests)
--- a/test/IntegrationTests/gbathree.cpp
+++ b/test/IntegrationTests/gbathree.cpp
@ -87,7 +87,7 @@ TEST_CASE("Gbathree") {

    REQUIRE(3 == array.size());

-    for (int i = 0; i < 3; i++) {
+    for (size_t i = 0; i < 3; i++) {
      REQUIRE(50 == array[i]);
    }
  }
@ -112,11 +112,11 @@ TEST_CASE("Gbathree") {
    REQUIRE(array.success());
    REQUIRE(4 == array.size());

-    for (int i = 0; i < 4; i++) {
+    for (size_t i = 0; i < 4; i++) {
      JsonArray& nestedArray = array[i];
      REQUIRE(4 == nestedArray.size());

-      for (int j = 0; j < 4; j++) {
+      for (size_t j = 0; j < 4; j++) {
        REQUIRE(34 == nestedArray[j]);
      }
    }
@ -130,7 +130,7 @@ TEST_CASE("Gbathree") {

    REQUIRE(4 == array.size());

-    for (int i = 0; i < 4; i++) {
+    for (size_t i = 0; i < 4; i++) {
      REQUIRE(2 == array[i]);
    }
  }
@ -143,7 +143,7 @@ TEST_CASE("Gbathree") {

    REQUIRE(4 == array.size());

-    for (int i = 0; i < 4; i++) {
+    for (size_t i = 0; i < 4; i++) {
      REQUIRE(2 == array[i]);
    }
  }
@ -155,12 +155,12 @@ TEST_CASE("Gbathree") {
    REQUIRE(array.success());
    REQUIRE(4 == array.size());

-    for (int i = 0; i < 4; i++) {
+    for (size_t i = 0; i < 4; i++) {
      JsonArray& nestedArray = array[i];

      REQUIRE(4 == nestedArray.size());

-      for (int j = 0; j < 4; j++) {
+      for (size_t j = 0; j < 4; j++) {
        REQUIRE(15 == nestedArray[j]);
      }
    }
@ -173,11 +173,11 @@ TEST_CASE("Gbathree") {
    REQUIRE(array.success());
    REQUIRE(4 == array.size());

-    for (int i = 0; i < 4; i++) {
+    for (size_t i = 0; i < 4; i++) {
      JsonArray& nestedArray = array[i];
      REQUIRE(4 == nestedArray.size());

-      for (int j = 0; j < 4; j++) {
+      for (size_t j = 0; j < 4; j++) {
        REQUIRE(15 == nestedArray[j]);
      }
    }
@ -191,7 +191,7 @@ TEST_CASE("Gbathree") {

    REQUIRE(4 == array.size());

-    for (int i = 0; i < 4; i++) {
+    for (size_t i = 0; i < 4; i++) {
      REQUIRE(2 == array[i]);
    }
  }
@ -204,7 +204,7 @@ TEST_CASE("Gbathree") {

    REQUIRE(4 == array.size());

-    for (int i = 0; i < 4; i++) {
+    for (size_t i = 0; i < 4; i++) {
      REQUIRE(2 == array[i]);
    }
  }
--- a/test/JsonVariant/subscript.cpp
+++ b/test/JsonVariant/subscript.cpp
@ -23,7 +23,7 @@ TEST_CASE("JsonVariant::operator[]") {
    REQUIRE(std::string("element at index 1") == var[1]);
    REQUIRE(std::string("element at index 0") ==
            var[static_cast<unsigned char>(0)]);  // issue #381
-    REQUIRE_FALSE(var[-1].success());
+    REQUIRE_FALSE(var[666].success());
    REQUIRE_FALSE(var[3].success());
    REQUIRE_FALSE(var["0"].success());
  }
--- a/test/JsonWriter/writeFloat.cpp
+++ b/test/JsonWriter/writeFloat.cpp
@ -14,7 +14,8 @@

 using namespace ArduinoJson::Internals;

-void check(double input, const std::string& expected) {
+template <typename TFloat>
+void check(TFloat input, const std::string& expected) {
  std::string output;
  DynamicStringBuilder<std::string> sb(output);
  JsonWriter<DynamicStringBuilder<std::string> > writer(sb);
@ -23,82 +24,97 @@ void check(double input, const std::string& expected) {
  CHECK(expected == output);
 }

-TEST_CASE("JsonWriter::writeFloat()") {
+TEST_CASE("JsonWriter::writeFloat(double)") {
  SECTION("Pi") {
-    check(3.14159265359, "3.141592654");
+    check<double>(3.14159265359, "3.141592654");
  }

  SECTION("Signaling NaN") {
    double nan = std::numeric_limits<double>::signaling_NaN();
-    check(nan, "NaN");
+    check<double>(nan, "NaN");
  }

  SECTION("Quiet NaN") {
    double nan = std::numeric_limits<double>::quiet_NaN();
-    check(nan, "NaN");
+    check<double>(nan, "NaN");
  }

  SECTION("Infinity") {
    double inf = std::numeric_limits<double>::infinity();
-    check(inf, "Infinity");
-    check(-inf, "-Infinity");
+    check<double>(inf, "Infinity");
+    check<double>(-inf, "-Infinity");
  }

  SECTION("Zero") {
-    check(0.0, "0");
-    check(-0.0, "0");
+    check<double>(0.0, "0");
+    check<double>(-0.0, "0");
  }

  SECTION("Espilon") {
-    check(2.2250738585072014E-308, "2.225073859e-308");
-    check(-2.2250738585072014E-308, "-2.225073859e-308");
+    check<double>(2.2250738585072014E-308, "2.225073859e-308");
+    check<double>(-2.2250738585072014E-308, "-2.225073859e-308");
  }

  SECTION("Max double") {
-    check(1.7976931348623157E+308, "1.797693135e308");
-    check(-1.7976931348623157E+308, "-1.797693135e308");
+    check<double>(1.7976931348623157E+308, "1.797693135e308");
+    check<double>(-1.7976931348623157E+308, "-1.797693135e308");
  }

  SECTION("Big exponent") {
    // this test increases coverage of normalize()
-    check(1e255, "1e255");
-    check(1e-255, "1e-255");
+    check<double>(1e255, "1e255");
+    check<double>(1e-255, "1e-255");
  }

  SECTION("Exponentation when <= 1e-5") {
-    check(1e-4, "0.0001");
-    check(1e-5, "1e-5");
+    check<double>(1e-4, "0.0001");
+    check<double>(1e-5, "1e-5");

-    check(-1e-4, "-0.0001");
-    check(-1e-5, "-1e-5");
+    check<double>(-1e-4, "-0.0001");
+    check<double>(-1e-5, "-1e-5");
  }

  SECTION("Exponentation when >= 1e7") {
-    check(9999999.999, "9999999.999");
-    check(10000000, "1e7");
+    check<double>(9999999.999, "9999999.999");
+    check<double>(10000000.0, "1e7");

-    check(-9999999.999, "-9999999.999");
-    check(-10000000, "-1e7");
+    check<double>(-9999999.999, "-9999999.999");
+    check<double>(-10000000.0, "-1e7");
  }

  SECTION("Rounding when too many decimals") {
-    check(0.000099999999999, "0.0001");
-    check(0.0000099999999999, "1e-5");
+    check<double>(0.000099999999999, "0.0001");
+    check<double>(0.0000099999999999, "1e-5");
+    check<double>(0.9999999996, "1");
  }

  SECTION("9 decimal places") {
-    check(0.100000001, "0.100000001");
-    check(0.999999999, "0.999999999");
+    check<double>(0.100000001, "0.100000001");
+    check<double>(0.999999999, "0.999999999");

-    check(9.000000001, "9.000000001");
-    check(9.999999999, "9.999999999");
+    check<double>(9.000000001, "9.000000001");
+    check<double>(9.999999999, "9.999999999");
  }

  SECTION("10 decimal places") {
-    check(0.1000000001, "0.1");
-    check(0.9999999999, "1");
+    check<double>(0.1000000001, "0.1");
+    check<double>(0.9999999999, "1");

-    check(9.0000000001, "9");
-    check(9.9999999999, "10");
+    check<double>(9.0000000001, "9");
+    check<double>(9.9999999999, "10");
+  }
+}
+
+TEST_CASE("JsonWriter::writeFloat(float)") {
+  SECTION("Pi") {
+    check<float>(3.14159265359f, "3.141593");
+  }
+
+  SECTION("999.9") {  // issue #543
+    check<float>(999.9f, "999.9");
+  }
+
+  SECTION("24.3") {  // # issue #588
+    check<float>(24.3f, "24.3");
  }
 }
--- a/test/Misc/CMakeLists.txt
+++ b/test/Misc/CMakeLists.txt
@ -7,6 +7,7 @@

 add_executable(MiscTests 
 	deprecated.cpp
+	FloatParts.cpp
 	std_stream.cpp
 	std_string.cpp
 	StringBuilder.cpp
--- a/test/Misc/FloatParts.cpp
+++ b/test/Misc/FloatParts.cpp
@ -0,0 +1,47 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson/Serialization/FloatParts.hpp>
+#include <catch.hpp>
+
+using namespace ArduinoJson::Internals;
+
+TEST_CASE("FloatParts<double>") {
+  SECTION("1.7976931348623157E+308") {
+    FloatParts<double> parts(1.7976931348623157E+308);
+    REQUIRE(parts.integral == 1);
+    REQUIRE(parts.decimal == 797693135);
+    REQUIRE(parts.decimalPlaces == 9);
+    REQUIRE(parts.exponent == 308);
+  }
+
+  SECTION("4.94065645841247e-324") {
+    FloatParts<double> parts(4.94065645841247e-324);
+    REQUIRE(parts.integral == 4);
+    REQUIRE(parts.decimal == 940656458);
+    REQUIRE(parts.decimalPlaces == 9);
+    REQUIRE(parts.exponent == -324);
+  }
+}
+
+TEST_CASE("FloatParts<float>") {
+  SECTION("3.4E+38") {
+    FloatParts<float> parts(3.4E+38f);
+    REQUIRE(parts.integral == 3);
+    REQUIRE(parts.decimal == 4);
+    REQUIRE(parts.decimalPlaces == 1);
+    REQUIRE(parts.exponent == 38);
+  }
+
+  SECTION("1.17549435e−38") {
+    FloatParts<float> parts(1.17549435e-38f);
+    REQUIRE(parts.integral == 1);
+    REQUIRE(parts.decimal == 175494);
+    REQUIRE(parts.decimalPlaces == 6);
+    REQUIRE(parts.exponent == -38);
+  }
+}
--- a/test/Polyfills/parseFloat.cpp
+++ b/test/Polyfills/parseFloat.cpp
@ -101,6 +101,11 @@ TEST_CASE("parseFloat<float>()") {
    checkInf<float>("+inf", false);
    checkInf<float>("-inf", true);
  }
+
+  SECTION("Boolean") {
+    check<float>("false", 0.0f);
+    check<float>("true", 1.0f);
+  }
 }

 TEST_CASE("parseFloat<double>()") {
@ -167,4 +172,9 @@ TEST_CASE("parseFloat<double>()") {
    checkNaN<double>("NaN");
    checkNaN<double>("nan");
  }
+
+  SECTION("Boolean") {
+    check<double>("false", 0.0);
+    check<double>("true", 1.0);
+  }
 }
--- a/test/Polyfills/parseInteger.cpp
+++ b/test/Polyfills/parseInteger.cpp
@ -23,11 +23,12 @@ TEST_CASE("parseInteger<int8_t>()") {
  check<int8_t>("127", 127);
  check<int8_t>("+127", 127);
  check<int8_t>("3.14", 3);
-  // check<int8_t>(" 42", 0);
  check<int8_t>("x42", 0);
  check<int8_t>("128", -128);
  check<int8_t>("-129", 127);
  check<int8_t>(NULL, 0);
+  check<int8_t>("true", 1);
+  check<int8_t>("false", 0);
 }

 TEST_CASE("parseInteger<int16_t>()") {
@ -35,11 +36,12 @@ TEST_CASE("parseInteger<int16_t>()") {
  check<int16_t>("32767", 32767);
  check<int16_t>("+32767", 32767);
  check<int16_t>("3.14", 3);
-  // check<int16_t>(" 42", 0);
  check<int16_t>("x42", 0);
  check<int16_t>("-32769", 32767);
  check<int16_t>("32768", -32768);
  check<int16_t>(NULL, 0);
+  check<int16_t>("true", 1);
+  check<int16_t>("false", 0);
 }

 TEST_CASE("parseInteger<int32_t>()") {
@ -47,10 +49,11 @@ TEST_CASE("parseInteger<int32_t>()") {
  check<int32_t>("2147483647", 2147483647);
  check<int32_t>("+2147483647", 2147483647);
  check<int32_t>("3.14", 3);
-  // check<int32_t>(" 42", 0);
  check<int32_t>("x42", 0);
  check<int32_t>("-2147483649", 2147483647);
  check<int32_t>("2147483648", (-2147483647 - 1));
+  check<int32_t>("true", 1);
+  check<int32_t>("false", 0);
 }

 TEST_CASE("parseInteger<uint8_t>()") {
@ -58,10 +61,11 @@ TEST_CASE("parseInteger<uint8_t>()") {
  check<uint8_t>("255", 255);
  check<uint8_t>("+255", 255);
  check<uint8_t>("3.14", 3);
-  // check<uint8_t>(" 42", 0);
  check<uint8_t>("x42", 0);
  check<uint8_t>("-1", 255);
  check<uint8_t>("256", 0);
+  check<uint8_t>("true", 1);
+  check<uint8_t>("false", 0);
 }

 TEST_CASE("parseInteger<uint16_t>()") {
@ -73,4 +77,6 @@ TEST_CASE("parseInteger<uint16_t>()") {
  check<uint16_t>("x42", 0);
  check<uint16_t>("-1", 65535);
  check<uint16_t>("65536", 0);
+  check<uint16_t>("true", 1);
+  check<uint16_t>("false", 0);
 }
--- a/test/StaticJsonBuffer/CMakeLists.txt
+++ b/test/StaticJsonBuffer/CMakeLists.txt
@ -11,6 +11,7 @@ add_executable(StaticJsonBufferTests
 	createObject.cpp
 	parseArray.cpp
 	parseObject.cpp
+	size.cpp
 	startString.cpp
 )

--- a/test/StaticJsonBuffer/alloc.cpp
+++ b/test/StaticJsonBuffer/alloc.cpp
@ -17,52 +17,39 @@ static bool isAligned(void *ptr) {
 TEST_CASE("StaticJsonBuffer::alloc()") {
  StaticJsonBuffer<64> buffer;

-  SECTION("CapacityMatchTemplateParameter") {
-    REQUIRE(64 == buffer.capacity());
+  SECTION("Returns different addresses") {
+    void *p1 = buffer.alloc(1);
+    void *p2 = buffer.alloc(1);
+    REQUIRE(p1 != p2);
  }

-  SECTION("InitialSizeIsZero") {
-    REQUIRE(0 == buffer.size());
-  }
-
-  SECTION("GrowsAfterAlloc") {
-    buffer.alloc(1);
-    REQUIRE(1U <= buffer.size());
-    buffer.alloc(1);
-    REQUIRE(2U <= buffer.size());
-  }
-
-  SECTION("DoesntGrowWhenFull") {
-    buffer.alloc(64);
-    buffer.alloc(1);
-    REQUIRE(64 == buffer.size());
-  }
-
-  SECTION("DoesntGrowWhenTooSmall") {
-    buffer.alloc(65);
-    REQUIRE(0 == buffer.size());
-  }
-
-  SECTION("ReturnsNonNull") {
+  SECTION("Returns non-NULL when using full capacity") {
    void *p = buffer.alloc(64);
    REQUIRE(0 != p);
  }

-  SECTION("ReturnsNullWhenFull") {
+  SECTION("Returns NULL when full") {
    buffer.alloc(64);
    void *p = buffer.alloc(1);
    REQUIRE(0 == p);
  }

-  SECTION("ReturnsNullWhenTooSmall") {
+  SECTION("Returns NULL when buffer is too small") {
    void *p = buffer.alloc(65);
    REQUIRE(0 == p);
  }

-  SECTION("Alignment") {
+  SECTION("Returns aligned pointers") {
    for (size_t size = 1; size <= sizeof(void *); size++) {
      void *p = buffer.alloc(1);
      REQUIRE(isAligned(p));
    }
  }
+
+  SECTION("Returns same address after clear()") {
+    void *p1 = buffer.alloc(1);
+    buffer.clear();
+    void *p2 = buffer.alloc(1);
+    REQUIRE(p1 == p2);
+  }
 }
--- a/test/StaticJsonBuffer/size.cpp
+++ b/test/StaticJsonBuffer/size.cpp
@ -0,0 +1,45 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("StaticJsonBuffer::size()") {
+  StaticJsonBuffer<64> buffer;
+
+  SECTION("Capacity equals template parameter") {
+    REQUIRE(64 == buffer.capacity());
+  }
+
+  SECTION("Initial size is 0") {
+    REQUIRE(0 == buffer.size());
+  }
+
+  SECTION("Increases after alloc()") {
+    buffer.alloc(1);
+    REQUIRE(1U <= buffer.size());
+    buffer.alloc(1);
+    REQUIRE(2U <= buffer.size());
+  }
+
+  SECTION("Doesn't grow when buffer is full") {
+    buffer.alloc(64);
+    buffer.alloc(1);
+    REQUIRE(64 == buffer.size());
+  }
+
+  SECTION("Does't grow when buffer is too small for alloc") {
+    buffer.alloc(65);
+    REQUIRE(0 == buffer.size());
+  }
+
+  SECTION("Goes back to zero after clear()") {
+    buffer.alloc(1);
+    buffer.clear();
+    REQUIRE(0 == buffer.size());
+  }
+}
--- a/third-party/catch/catch.hpp
+++ b/third-party/catch/catch.hpp
Author	SHA1	Message	Date
Benoit Blanchon	a7e928d126	Set version to 5.11.2	2017-10-17 10:21:52 +02:00
Benoit Blanchon	591fe7e92b	Fixed incorrect rounding for float values (fixes #588 )	2017-10-17 10:19:21 +02:00
Benoit Blanchon	d6e61cbcda	Added banner with the new logo	2017-10-16 10:21:44 +02:00
Benoit Blanchon	5825366fe4	Added Patrick Elliott to the list of donators	2017-10-07 16:33:53 +02:00
Benoit Blanchon	6df204cf40	Split CONTRIBUTING and SUPPORT	2017-10-03 13:01:47 +02:00
Benoit Blanchon	3f7e1db549	Added guidelines for contributing	2017-10-03 12:26:49 +02:00
Benoit Blanchon	a6091136b0	Fix GCC 7 warning	2017-09-27 11:13:45 +02:00
Benoit Blanchon	353bbd0e8c	Fix GCC 4.8.5 warning	2017-09-27 09:45:48 +02:00
Benoit Blanchon	a428e125fa	Travis: Added GCC 7	2017-09-27 09:29:08 +02:00
Benoit Blanchon	2e262b2689	Travis: Removed GCC 4.5	2017-09-27 09:29:08 +02:00
Benoit Blanchon	a2d055e408	Added Günther Jehle to the list of donators	2017-09-26 09:43:32 +02:00
Benoit Blanchon	57defe00ee	Fixed `DynamicJsonBuffer::clear()` not resetting allocation size (fixes #561 )	2017-08-30 21:51:10 +02:00
Benoit Blanchon	ac5a2676e7	Upgraded to Catch 1.9.7	2017-08-27 15:12:20 +02:00
Benoit Blanchon	ed98ea4e43	Implemented JsonVariant comparisons with template friends	2017-08-06 16:26:38 +02:00
Benoit Blanchon	729bf0afd2	Made JsonBuffer destructor protected	2017-07-18 22:00:06 +02:00
Benoit Blanchon	2ea7ea153c	Set version to 5.11.1	2017-07-14 11:17:11 +02:00
Benoit Blanchon	2772e66064	Fixed warning "this statement may fall through" (issue #539 )	2017-07-14 11:14:56 +02:00
Benoit Blanchon	d41f7a8165	Fixed too many decimals places in float serialization (issue #543 )	2017-07-14 10:51:46 +02:00
Benoit Blanchon	abfd3997eb	Fixed "constant exceeds range of float [-Woverflow]" (issue #544 )	2017-07-09 15:24:58 +02:00
Benoit Blanchon	788c9be016	Removed dependency on `PGM_P` as Particle 0.6.2 doesn't define it (issue #546 )	2017-07-07 23:04:42 +02:00
Benoit Blanchon	c3d7a79a83	Travis: Removed Arduino DUE on platformio (fatal error: Ethernet.h: No such file or directory)	2017-07-06 20:56:05 +02:00
Benoit Blanchon	1782348275	Added Charles Walker to the list of donators	2017-07-06 20:55:05 +02:00
Benoit Blanchon	edfe5c6622	Set version to 5.11.0	2017-06-25 15:11:57 +02:00
Benoit Blanchon	2b9492317b	Added Charles Haynes to the list of donators	2017-06-22 21:56:41 +02:00
Benoit Blanchon	5da41edf6a	Removed implementation of `JsonBufferAllocated::delete`.	2017-06-19 10:05:38 +02:00
Benoit Blanchon	476e5aaa86	Added `DynamicJsonBuffer::clear()`	2017-06-17 16:48:40 +02:00
Benoit Blanchon	789fa507b5	Added `StaticJsonBuffer::clear()`	2017-06-17 15:00:46 +02:00
Benoit Blanchon	508f936317	Made `JsonBuffer` non-copyable (PR #524 by @luisrayas3)	2017-06-17 14:17:01 +02:00
Benoit Blanchon	e9d88dda8e	Set version to 5.10.1	2017-06-12 21:10:02 +02:00
Benoit Blanchon	ecceb71a1e	AppVeyor: Added Visual Studio 2017 and restored MinGW	2017-06-07 11:15:22 +02:00
Benoit Blanchon	bff77abe6a	Fixed reading "true" as a float (issue #516 )	2017-06-03 16:22:26 +02:00
Benoit Blanchon	98413089f6	Added Google to the list of donators	2017-06-01 20:49:50 +02:00
Benoit Blanchon	a2446f6c68	Fixed compilation in IAR Embedded Workbench (issue #515 )	2017-06-01 20:47:09 +02:00
Benoit Blanchon	c955049207	Fixed IntelliSense errors in Visual Micro (issue #483 )	2017-05-28 15:33:03 +02:00
Benoit Blanchon	574c00c096	Added links to the ArduinoJson assistant (issue #513 )	2017-05-27 15:32:12 +02:00
Benoit Blanchon	7415f206ea	Reduced code size	2017-05-27 15:08:11 +02:00