Set version to 5.1.0-beta.1

.travis.yml

@@ -1,85 +1,15 @@
 sudo: false
 language: cpp
-matrix:
-  include:
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.4']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.4
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.5']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.5
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.6']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.6
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.7']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.7
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.8']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.8
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.9']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.9
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-5']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-5
-    - compiler: clang
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++
-    - compiler: clang
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.5']
-          packages: ['clang-3.5']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.5
-    - compiler: clang
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.6']
-          packages: ['clang-3.6']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.6
-    - compiler: clang
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.7']
-          packages: ['clang-3.7']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.7
-    # - compiler: clang
-    #   addons:
-    #     apt:
-    #       sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
-    #       packages: ['clang-3.8']
-    #   env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.8
-    - compiler: gcc
-      env: SCRIPT=coverage
-    - env: SCRIPT=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
-    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
-    - env: SCRIPT=arduino VERSION=1.6.8 BOARD=arduino:avr:uno
-    - env: SCRIPT=platformio BOARD=uno
-    - env: SCRIPT=platformio BOARD=due
-    - env: SCRIPT=platformio BOARD=esp01
-    - env: SCRIPT=platformio BOARD=teensy31
 cache:
   directories:
     - "~/.platformio"
-script: scripts/travis/$SCRIPT.sh
+env:
+  - COMPILER=gcc
+  - COMPILER=clang
+  - COMPILER=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
+  - COMPILER=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
+  - COMPILER=platformio BOARD=uno
+  - COMPILER=platformio BOARD=due
+  - COMPILER=platformio BOARD=esp01
+  - COMPILER=platformio BOARD=teensy31
+script: scripts/travis/$COMPILER.sh

CHANGELOG.md

@@ -1,19 +1,6 @@
 ArduinoJson: change log
 =======================
 
-v5.2.0
-------
-
-* Added `JsonVariant::as<char*>()` as a synonym for `JsonVariant::as<const char*>()` (issue #257)
-* Added example `JsonHttpClient` (issue #256)
-* Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254)
-* Added `RawJson()` to insert pregenerated JSON portions (issue #259)
-
-v5.1.1
-------
-
-* Removed `String` duplication when one replaces a value in a `JsonObject` (PR #232 by @ulion)
-
 v5.1.0
 ------
 

README.md

@@ -15,8 +15,7 @@ Features
 * JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
 * Elegant API, very easy to use
-* Fixed memory allocation (zero malloc)
-* No data duplication (zero copy)
+* Efficient (no malloc, nor copy)
 * Portable (written in C++98)
 * Self-contained (no external dependency)
 * Small footprint
@@ -25,13 +24,12 @@ Features
 Works on
 --------
 
-* All Arduino boards (Uno, Due, Mini, Micro, Yun...)
+* All Arduino boards
 * ESP8266
 * Teensy
 * Intel Edison
 * PlatformIO
 * Energia
-* RedBearLab boards (BLE Nano...)
 * Computers (Windows, Linux, OSX...)
 
 See [FAQ: Compatibility issues](https://github.com/bblanchon/ArduinoJson/wiki/Compatibility-issues)
@@ -92,18 +90,18 @@ From StackOverflow user `thegreendroid`:
 > It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
 
 From GitHub user `zacsketches`:
+
 > Thanks for a great library!!!
 > I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
 > ArduinoJson saved me a week's worth of time!!
 
 [From Reddit user `erm_what_`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusjk8c):
+
 > This is a great library and I wouldn't be able to do the project I'm doing without it. I completely recommend it.
 
 [From Reddit user `makerhacks`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusqg7b):
-> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.
 
-[From Twitter user `@hemalchevli`](https://twitter.com/hemalchevli/status/715788439397011456):
-> ArduinoJson library should be used as a benchmark/reference for making libraries. Truly elegant.
+> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.
 
 Donators
 --------
@@ -117,7 +115,6 @@ Special thanks to the following persons and companies who made generous donation
 * A B Doodkorte
 * Scott Smith
 * Johann Stieger
-* Gustavo Donizeti Gini
 
 ---
 

appveyor.yml

@@ -1,16 +0,0 @@
-version: 5.2.0.{build}
-environment:
-  matrix:
-  - CMAKE_GENERATOR: Visual Studio 14 2015
-  - CMAKE_GENERATOR: Visual Studio 12 2013
-  - CMAKE_GENERATOR: Visual Studio 11 2012
-  - CMAKE_GENERATOR: Visual Studio 10 2010
-  - CMAKE_GENERATOR: MinGW Makefiles
-configuration: Debug
-before_build:
-- set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW
-- cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
-build_script:
-- cmake --build . --config %CONFIGURATION%
-test_script:
-- ctest -V .

examples/JsonHttpClient/JsonHttpClient.ino

@@ -1,195 +0,0 @@
-// Sample Arduino Json Web Client
-// Downloads and parse http://jsonplaceholder.typicode.com/users/1
-//
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#include <ArduinoJson.h>
-#include <SPI.h>
-#include <Ethernet.h>
-
-EthernetClient client;
-
-const char* server = "jsonplaceholder.typicode.com";  // server's address
-const char* resource = "/users/1";                    // http resource
-const unsigned long BAUD_RATE = 9600;                 // serial connection speed
-const unsigned long HTTP_TIMEOUT = 10000;  // max respone time from server
-const size_t MAX_CONTENT_SIZE = 512;       // max size of the HTTP response
-
-// The type of data that we want to extract from the page
-struct UserData {
-  char name[32];
-  char company[32];
-};
-
-// ARDUINO entry point #1: runs once when you press reset or power the board
-void setup() {
-  initSerial();
-  initEthernet();
-}
-
-// ARDUINO entry point #2: runs over and over again forever
-void loop() {
-  if (connect(server)) {
-    if (sendRequest(server, resource) && skipResponseHeaders()) {
-      char response[MAX_CONTENT_SIZE];
-      readReponseContent(response, sizeof(response));
-
-      UserData userData;
-      if (parseUserData(response, &userData)) {
-        printUserData(&userData);
-      }
-    }
-    disconnect();
-  }
-  wait();
-}
-
-// Initialize Serial port
-void initSerial() {
-  Serial.begin(BAUD_RATE);
-  while (!Serial) {
-    ;  // wait for serial port to initialize
-  }
-  Serial.println("Serial ready");
-}
-
-// Initialize Ethernet library
-void initEthernet() {
-  byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
-  if (!Ethernet.begin(mac)) {
-    Serial.println("Failed to configure Ethernet");
-    return;
-  }
-  Serial.println("Ethernet ready");
-  delay(1000);
-}
-
-// Open connection to the HTTP server
-bool connect(const char* hostName) {
-  Serial.print("Connect to ");
-  Serial.println(hostName);
-
-  bool ok = client.connect(hostName, 80);
-
-  Serial.println(ok ? "Connected" : "Connection Failed!");
-  return ok;
-}
-
-// Send the HTTP GET request to the server
-bool sendRequest(const char* host, const char* resource) {
-  Serial.print("GET ");
-  Serial.println(resource);
-
-  client.print("GET ");
-  client.print(resource);
-  client.println(" HTTP/1.1");
-  client.print("Host: ");
-  client.println(server);
-  client.println("Connection: close");
-  client.println();
-
-  return true;
-}
-
-// Skip HTTP headers so that we are at the beginning of the response's body
-bool skipResponseHeaders() {
-  // HTTP headers end with an empty line
-  char endOfHeaders[] = "\r\n\r\n";
-
-  client.setTimeout(HTTP_TIMEOUT);
-  bool ok = client.find(endOfHeaders);
-
-  if (!ok) {
-    Serial.println("No response or invalid response!");
-  }
-
-  return ok;
-}
-
-// Read the body of the response from the HTTP server
-void readReponseContent(char* content, size_t maxSize) {
-  size_t length = client.readBytes(content, maxSize);
-  content[length] = 0;
-  Serial.println(content);
-}
-
-// Parse the JSON from the input string and extract the interesting values
-// Here is the JSON we need to parse
-// {
-//   "id": 1,
-//   "name": "Leanne Graham",
-//   "username": "Bret",
-//   "email": "Sincere@april.biz",
-//   "address": {
-//     "street": "Kulas Light",
-//     "suite": "Apt. 556",
-//     "city": "Gwenborough",
-//     "zipcode": "92998-3874",
-//     "geo": {
-//       "lat": "-37.3159",
-//       "lng": "81.1496"
-//     }
-//   },
-//   "phone": "1-770-736-8031 x56442",
-//   "website": "hildegard.org",
-//   "company": {
-//     "name": "Romaguera-Crona",
-//     "catchPhrase": "Multi-layered client-server neural-net",
-//     "bs": "harness real-time e-markets"
-//   }
-// }
-bool parseUserData(char* content, struct UserData* userData) {
-  // Compute optimal size of the JSON buffer according to what we need to parse.
-  // This is only required if you use StaticJsonBuffer.
-  const size_t BUFFER_SIZE =
-      JSON_OBJECT_SIZE(8)     // the root object has 8 elements
-      + JSON_OBJECT_SIZE(5)   // the "address" object has 5 elements
-      + JSON_OBJECT_SIZE(2)   // the "geo" object has 2 elements
-      + JSON_OBJECT_SIZE(3);  // the "company" object has 3 elements
-
-  // Allocate a temporary memory pool on the stack
-  StaticJsonBuffer<BUFFER_SIZE> jsonBuffer;
-  // If the memory pool is too big for the stack, use this instead:
-  // DynamicJsonBuffer jsonBuffer;
-
-  JsonObject& root = jsonBuffer.parseObject(content);
-
-  if (!root.success()) {
-    Serial.println("JSON parsing failed!");
-    return false;
-  }
-
-  // Here were copy the strings we're interested in
-  strcpy(userData->name, root["name"]);
-  strcpy(userData->company, root["company"]["name"]);
-  // It's not mandatory to make a copy, you could just use the pointers
-  // Since, they are pointing inside the "content" buffer, so you need to make
-  // sure it's still in memory when you read the string
-
-  return true;
-}
-
-// Print the data extracted from the JSON
-void printUserData(const struct UserData* userData) {
-  Serial.print("Name = ");
-  Serial.println(userData->name);
-  Serial.print("Company = ");
-  Serial.println(userData->company);
-}
-
-// Close the connection with the HTTP server
-void disconnect() {
-  Serial.println("Disconnect");
-  client.stop();
-}
-
-// Pause for a 1 minute
-void wait() {
-  Serial.println("Wait 60 seconds");
-  delay(60000);
-}

include/ArduinoJson/Arduino/Print.hpp

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

include/ArduinoJson/Internals/Unparsed.hpp

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

include/ArduinoJson/JsonArray.hpp

@@ -12,10 +12,6 @@
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonVariant.hpp"
-#include "TypeTraits/EnableIf.hpp"
-#include "TypeTraits/IsFloatingPoint.hpp"
-#include "TypeTraits/IsReference.hpp"
-#include "TypeTraits/IsSame.hpp"
 
 // Returns the size (in bytes) of an array with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@@ -74,8 +70,7 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   template <typename T>
   FORCE_INLINE bool add(
       T value,
-      typename TypeTraits::EnableIf<
-          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T>::value, void>::type * = 0) {
     return addNode<T>(value);
   }
   // bool add(const String&)
@@ -85,16 +80,16 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   template <typename T>
   FORCE_INLINE bool add(
       const T &value,
-      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T &>::value, T>::type * = 0) {
     return addNode<T &>(const_cast<T &>(value));
   }
   // bool add(float value, uint8_t decimals);
   // bool add(double value, uint8_t decimals);
   template <typename T>
   FORCE_INLINE bool add(
-      T value, uint8_t decimals,
-      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
-          * = 0) {
+      T value,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                    uint8_t>::type decimals) {
     return addNode<JsonVariant>(JsonVariant(value, decimals));
   }
 
@@ -107,8 +102,7 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   template <typename T>
   FORCE_INLINE bool set(
       size_t index, T value,
-      typename TypeTraits::EnableIf<
-          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T>::value, void>::type * = 0) {
     return setNodeAt<T>(index, value);
   }
   // bool set(size_t index, const String&)
@@ -118,16 +112,16 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   template <typename T>
   FORCE_INLINE bool set(
       size_t index, const T &value,
-      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T &>::value, T>::type * = 0) {
     return setNodeAt<T &>(index, const_cast<T &>(value));
   }
   // bool set(size_t index, float value, uint8_t decimals = 2);
   // bool set(size_t index, double value, uint8_t decimals = 2);
   template <typename T>
   FORCE_INLINE bool set(
-      size_t index, T value, uint8_t decimals,
-      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
-          * = 0) {
+      size_t index, T value,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                    uint8_t>::type decimals) {
     return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
   }
 
@@ -161,59 +155,6 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   // Serialize the array to the specified JsonWriter.
   void writeTo(Internals::JsonWriter &writer) const;
 
-  // Imports a 1D array
-  template <typename T, size_t N>
-  bool copyFrom(T(&array)[N]) {
-    return copyFrom(array, N);
-  }
-
-  // Imports a 1D array
-  template <typename T>
-  bool copyFrom(T *array, size_t len) {
-    bool ok = true;
-    for (size_t i = 0; i < len; i++) {
-      ok &= add(array[i]);
-    }
-    return ok;
-  }
-
-  // Imports a 2D array
-  template <typename T, size_t N1, size_t N2>
-  bool copyFrom(T(&array)[N1][N2]) {
-    bool ok = true;
-    for (size_t i = 0; i < N1; i++) {
-      JsonArray &nestedArray = createNestedArray();
-      for (size_t j = 0; j < N2; j++) {
-        ok &= nestedArray.add(array[i][j]);
-      }
-    }
-    return ok;
-  }
-
-  // Exports a 1D array
-  template <typename T, size_t N>
-  size_t copyTo(T(&array)[N]) const {
-    return copyTo(array, N);
-  }
-
-  // Exports a 1D array
-  template <typename T>
-  size_t copyTo(T *array, size_t len) const {
-    size_t i = 0;
-    for (const_iterator it = begin(); it != end() && i < len; ++it)
-      array[i++] = *it;
-    return i;
-  }
-
-  // Exports a 2D array
-  template <typename T, size_t N1, size_t N2>
-  void copyTo(T(&array)[N1][N2]) const {
-    size_t i = 0;
-    for (const_iterator it = begin(); it != end() && i < N1; ++it) {
-      it->asArray().copyTo(array[i++]);
-    }
-  }
-
  private:
   node_type *getNodeAt(size_t index) const;
 

include/ArduinoJson/JsonArraySubscript.hpp

@@ -77,6 +77,11 @@ inline std::ostream& operator<<(std::ostream& os,
 }
 #endif
 
+template <>
+struct JsonVariant::IsConstructibleFrom<JsonArraySubscript> {
+  static const bool value = true;
+};
+
 }  // namespace ArduinoJson
 
 #ifdef _MSC_VER

include/ArduinoJson/JsonObject.hpp

@@ -13,10 +13,6 @@
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonPair.hpp"
-#include "TypeTraits/EnableIf.hpp"
-#include "TypeTraits/IsFloatingPoint.hpp"
-#include "TypeTraits/IsReference.hpp"
-#include "TypeTraits/IsSame.hpp"
 
 // Returns the size (in bytes) of an object with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@@ -71,12 +67,10 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   // bool set(TKey key, float value);
   // bool set(TKey key, double value);
   // bool set(TKey key, const char* value);
-  // bool set(TKey key, RawJson value);
   template <typename T>
   FORCE_INLINE bool set(
       JsonObjectKey key, T value,
-      typename TypeTraits::EnableIf<
-          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type* = 0) {
+      typename TypeTraits::EnableIf<CanSet<T>::value, void>::type* = 0) {
     return setNodeAt<T>(key, value);
   }
   // bool set(Key, String&);
@@ -86,16 +80,16 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   template <typename T>
   FORCE_INLINE bool set(
       JsonObjectKey key, const T& value,
-      typename TypeTraits::EnableIf<CanSet<T&>::value>::type* = 0) {
+      typename TypeTraits::EnableIf<CanSet<T&>::value, T>::type* = 0) {
     return setNodeAt<T&>(key, const_cast<T&>(value));
   }
   // bool set(Key, float value, uint8_t decimals);
   // bool set(Key, double value, uint8_t decimals);
   template <typename TValue>
   FORCE_INLINE bool set(
-      JsonObjectKey key, TValue value, uint8_t decimals,
-      typename TypeTraits::EnableIf<
-          TypeTraits::IsFloatingPoint<TValue>::value>::type* = 0) {
+      JsonObjectKey key, TValue value,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<TValue>::value,
+                                    uint8_t>::type decimals) {
     return setNodeAt<const JsonVariant&>(key, JsonVariant(value, decimals));
   }
 

include/ArduinoJson/JsonObject.ipp

@@ -55,12 +55,8 @@ inline void JsonObject::remove(JsonObjectKey key) {
 template <typename T>
 inline bool JsonObject::setNodeAt(JsonObjectKey key, T value) {
   node_type *node = getNodeAt(key.c_str());
-  if (!node) {
-    node = addNewNode();
-    if (!node || !setNodeKey(node, key))
-      return false;
-  }
-  return setNodeValue<T>(node, value);
+  if (!node) node = addNewNode();
+  return node && setNodeKey(node, key) && setNodeValue<T>(node, value);
 }
 
 inline bool JsonObject::setNodeKey(node_type *node, JsonObjectKey key) {

include/ArduinoJson/JsonObjectSubscript.hpp

@@ -92,6 +92,10 @@ inline std::ostream& operator<<(
 }
 #endif
 
+template <typename T>
+struct JsonVariant::IsConstructibleFrom<JsonObjectSubscript<T> > {
+  static const bool value = true;
+};
 }  // namespace ArduinoJson
 
 #ifdef _MSC_VER

include/ArduinoJson/JsonVariant.hpp

@@ -13,14 +13,14 @@
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/JsonVariantContent.hpp"
 #include "Internals/JsonVariantType.hpp"
+#include "Internals/Unparsed.hpp"
 #include "JsonVariantBase.hpp"
-#include "RawJson.hpp"
 #include "TypeTraits/EnableIf.hpp"
 #include "TypeTraits/IsFloatingPoint.hpp"
 #include "TypeTraits/IsIntegral.hpp"
-#include "TypeTraits/IsSame.hpp"
 #include "TypeTraits/RemoveConst.hpp"
 #include "TypeTraits/RemoveReference.hpp"
+#include "TypeTraits/IsSame.hpp"
 
 namespace ArduinoJson {
 
@@ -55,8 +55,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   template <typename T>
   FORCE_INLINE JsonVariant(
       T value, uint8_t decimals = 2,
-      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
-          * = 0) {
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                    T>::type * = 0) {
     using namespace Internals;
     _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
     _content.asFloat = static_cast<JsonFloat>(value);
@@ -68,9 +68,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   // JsonVariant(long)
   template <typename T>
   FORCE_INLINE JsonVariant(
-      T value,
-      typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value>::type * =
-          0) {
+      T value, typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value,
+                                             T>::type * = 0) {
     using namespace Internals;
     _type = JSON_INTEGER;
     _content.asInteger = static_cast<JsonInteger>(value);
@@ -80,7 +79,7 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   FORCE_INLINE JsonVariant(const char *value);
 
   // Create a JsonVariant containing an unparsed string
-  FORCE_INLINE JsonVariant(RawJson value);
+  FORCE_INLINE JsonVariant(Internals::Unparsed value);
 
   // Create a JsonVariant containing a reference to an array.
   FORCE_INLINE JsonVariant(JsonArray &array);
@@ -89,7 +88,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   FORCE_INLINE JsonVariant(JsonObject &object);
 
   // Get the variant as the specified type.
-  //
   // short as<short>() const;
   // int as<int>() const;
   // long as<long>() const;
@@ -98,7 +96,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   as() const {
     return static_cast<T>(asInteger());
   }
-  //
   // double as<double>() const;
   // float as<float>() const;
   template <typename T>
@@ -107,7 +104,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   as() const {
     return static_cast<T>(asFloat());
   }
-  //
   // const String as<String>() const;
   template <typename T>
   const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, String>::value,
@@ -115,17 +111,14 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   as() const {
     return toString();
   }
-  //
   // const char* as<const char*>() const;
   // const char* as<char*>() const;
   template <typename T>
-  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
-                                    TypeTraits::IsSame<T, char *>::value,
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value,
                                 const char *>::type
   as() const {
     return asString();
   }
-  //
   // const bool as<bool>() const
   template <typename T>
   const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
@@ -133,7 +126,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   as() const {
     return asInteger() != 0;
   }
-  //
   // JsonArray& as<JsonArray> const;
   // JsonArray& as<JsonArray&> const;
   // JsonArray& as<const JsonArray&> const;
@@ -147,7 +139,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   as() const {
     return asArray();
   }
-  //
   // JsonObject& as<JsonObject> const;
   // JsonObject& as<JsonObject&> const;
   // JsonObject& as<const JsonObject&> const;
@@ -164,71 +155,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
 
   // Tells weither the variant has the specified type.
   // Returns true if the variant has type type T, false otherwise.
-  //
-  // short as<short>() const;
-  // int as<int>() const;
-  // long as<long>() const;
   template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value,
-                                      bool>::type
-  is() const {
-    return isInteger();
-  }
-  //
-  // double is<double>() const;
-  // float is<float>() const;
-  template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
-                                      bool>::type
-  is() const {
-    return isFloat();
-  }
-  //
-  // const bool is<bool>() const
-  template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
-                                      bool>::type
-  is() const {
-    return isBoolean();
-  }
-  //
-  // bool is<const char*>() const;
-  // bool is<char*>() const;
-  template <typename T>
-  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
-                                    TypeTraits::IsSame<T, char *>::value,
-                                bool>::type
-  is() const {
-    return isString();
-  }
-  //
-  // bool is<JsonArray> const;
-  // bool is<JsonArray&> const;
-  // bool is<const JsonArray&> const;
-  template <typename T>
-  typename TypeTraits::EnableIf<
-      TypeTraits::IsSame<
-          typename TypeTraits::RemoveConst<
-              typename TypeTraits::RemoveReference<T>::type>::type,
-          JsonArray>::value,
-      bool>::type
-  is() const {
-    return isArray();
-  }
-  //
-  // JsonObject& as<JsonObject> const;
-  // JsonObject& as<JsonObject&> const;
-  // JsonObject& as<const JsonObject&> const;
-  template <typename T>
-  typename TypeTraits::EnableIf<
-      TypeTraits::IsSame<
-          typename TypeTraits::RemoveConst<
-              typename TypeTraits::RemoveReference<T>::type>::type,
-          JsonObject>::value,
-      bool>::type
-  is() const {
-    return isObject();
-  }
+  bool is() const;
 
   // Serialize the variant to a JsonWriter
   void writeTo(Internals::JsonWriter &writer) const;
@@ -245,12 +173,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   String toString() const;
   Internals::JsonFloat asFloat() const;
   Internals::JsonInteger asInteger() const;
-  bool isBoolean() const;
-  bool isFloat() const;
-  bool isInteger() const;
-  bool isArray() const { return _type == Internals::JSON_ARRAY; }
-  bool isObject() const { return _type == Internals::JSON_OBJECT; }
-  bool isString() const { return _type == Internals::JSON_STRING; }
 
   // The current type of the variant
   Internals::JsonVariantType _type;
@@ -269,25 +191,17 @@ inline JsonVariant double_with_n_digits(double value, uint8_t digits) {
 
 template <typename T>
 struct JsonVariant::IsConstructibleFrom {
-  static const bool value =
-      TypeTraits::IsIntegral<T>::value ||
-      TypeTraits::IsFloatingPoint<T>::value ||
-      TypeTraits::IsSame<T, bool>::value ||
-      TypeTraits::IsSame<T, char *>::value ||
-      TypeTraits::IsSame<T, const char *>::value ||
-      TypeTraits::IsSame<T, RawJson>::value ||
-      TypeTraits::IsSame<T, JsonArray &>::value ||
-      TypeTraits::IsSame<T, const JsonArray &>::value ||
-      TypeTraits::IsSame<T, JsonArraySubscript &>::value ||
-      TypeTraits::IsSame<T, const JsonArraySubscript &>::value ||
-      TypeTraits::IsSame<T, JsonObject &>::value ||
-      TypeTraits::IsSame<T, const JsonObject &>::value ||
-      TypeTraits::IsSame<T, JsonObjectSubscript<const char *> &>::value ||
-      TypeTraits::IsSame<T, const JsonObjectSubscript<const char *> &>::value ||
-      TypeTraits::IsSame<T, JsonObjectSubscript<String> &>::value ||
-      TypeTraits::IsSame<T, const JsonObjectSubscript<String> &>::value ||
-      TypeTraits::IsSame<T, JsonVariant &>::value ||
-      TypeTraits::IsSame<T, const JsonVariant &>::value;
+  static const bool value = TypeTraits::IsIntegral<T>::value ||
+                            TypeTraits::IsFloatingPoint<T>::value ||
+                            TypeTraits::IsSame<T, bool>::value ||
+                            TypeTraits::IsSame<T, char *>::value ||
+                            TypeTraits::IsSame<T, const char *>::value ||
+                            TypeTraits::IsSame<T, JsonArray &>::value ||
+                            TypeTraits::IsSame<T, const JsonArray &>::value ||
+                            TypeTraits::IsSame<T, JsonObject &>::value ||
+                            TypeTraits::IsSame<T, const JsonObject &>::value ||
+                            TypeTraits::IsSame<T, JsonVariant &>::value ||
+                            TypeTraits::IsSame<T, const JsonVariant &>::value;
 };
 }
 

include/ArduinoJson/JsonVariant.ipp

@@ -26,7 +26,7 @@ inline JsonVariant::JsonVariant(const char *value) {
   _content.asString = value;
 }
 
-inline JsonVariant::JsonVariant(RawJson value) {
+inline JsonVariant::JsonVariant(Internals::Unparsed value) {
   _type = Internals::JSON_UNPARSED;
   _content.asString = value;
 }
@@ -46,6 +46,85 @@ inline T JsonVariant::invalid() {
   return T();
 }
 
+template <typename T>
+inline bool JsonVariant::is() const {
+  return false;
+}
+
+template <>  // in .cpp
+bool JsonVariant::is<signed long>() const;
+
+template <>  // in .cpp
+bool JsonVariant::is<double>() const;
+
+template <>  // int .cpp
+bool JsonVariant::is<bool>() const;
+
+template <>
+inline bool JsonVariant::is<char const *>() const {
+  return _type == Internals::JSON_STRING;
+}
+
+template <>
+inline bool JsonVariant::is<float>() const {
+  return is<double>();
+}
+
+template <>
+inline bool JsonVariant::is<JsonArray &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<JsonArray const &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<JsonObject &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <>
+inline bool JsonVariant::is<JsonObject const &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <>
+inline bool JsonVariant::is<signed char>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<signed int>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<signed short>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned char>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned int>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned long>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned short>() const {
+  return is<signed long>();
+}
+
 inline Internals::JsonInteger JsonVariant::asInteger() const {
   if (_type == Internals::JSON_INTEGER || _type == Internals::JSON_BOOLEAN)
     return _content.asInteger;

include/ArduinoJson/TypeTraits/EnableIf.hpp

@@ -11,7 +11,7 @@ namespace ArduinoJson {
 namespace TypeTraits {
 
 // A meta-function that return the type T if Condition is true.
-template <bool Condition, typename T = void>
+template <bool Condition, typename T>
 struct EnableIf {};
 
 template <typename T>

include/ArduinoJson/TypeTraits/IsIntegral.hpp

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include "../Configuration.hpp"
 #include "IsSame.hpp"
 
 #include <stdint.h>
@@ -26,14 +25,10 @@ struct IsIntegral {
                             TypeTraits::IsSame<T, unsigned int>::value ||
                             TypeTraits::IsSame<T, signed long>::value ||
                             TypeTraits::IsSame<T, unsigned long>::value ||
-#if ARDUINOJSON_USE_LONG_LONG
-                            TypeTraits::IsSame<T, long long>::value ||
-                            TypeTraits::IsSame<T, unsigned long long>::value ||
-#endif
-
-#if ARDUINOJSON_USE_INT64
-                            TypeTraits::IsSame<T, __int64>::value ||
-                            TypeTraits::IsSame<T, unsigned __int64>::value ||
+#ifndef ARDUINO
+                            // on a computer add support for 64 bit
+                            TypeTraits::IsSame<T, int64_t>::value ||
+                            TypeTraits::IsSame<T, uint64_t>::value ||
 #endif
                             TypeTraits::IsSame<T, char>::value;
 };

include/ArduinoJson/TypeTraits/IsReference.hpp

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

library.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/bblanchon/ArduinoJson.git"
   },
-  "version": "5.2.0",
+  "version": "5.1.0-beta.1",
   "authors": {
     "name": "Benoit Blanchon",
     "url": "http://blog.benoitblanchon.fr"

library.properties

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

scripts/travis/arduino.sh

@@ -11,6 +11,5 @@ export PATH=$PATH:/tmp/arduino/
   
 ln -s $PWD /tmp/arduino/libraries/ArduinoJson
 
-for EXAMPLE in $PWD/examples/*/*.ino; do
-	arduino --verify --board $BOARD $EXAMPLE
-done
+arduino --verify --board $BOARD $PWD/examples/JsonParserExample/JsonParserExample.ino
+arduino --verify --board $BOARD $PWD/examples/JsonGeneratorExample/JsonGeneratorExample.ino

scripts/travis/clang.sh

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

scripts/travis/gcc.sh

@@ -1,5 +1,8 @@
 #!/bin/sh -eux
 
+export CC=gcc
+export CXX=g++
+
 curl https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1
 
 /tmp/bin/cmake -DCOVERAGE=true .

src/Arduino/Print.cpp

@@ -0,0 +1,60 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#ifndef ARDUINO
+
+#include "../../include/ArduinoJson/Arduino/Print.hpp"
+
+#include <stdio.h>
+#include <math.h>  // for isnan() and isinf()
+
+// only for GCC 4.9+
+#if defined(__GNUC__) && \
+    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
+#pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+// Visual Studo 2012 didn't have isnan, nor isinf
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#include <float.h>
+#define isnan(x) _isnan(x)
+#define isinf(x) (!_finite(x))
+#endif
+
+size_t Print::print(const char s[]) {
+  size_t n = 0;
+  while (*s) {
+    n += write(*s++);
+  }
+  return n;
+}
+
+size_t Print::print(double value, int digits) {
+  // https://github.com/arduino/Arduino/blob/db8cbf24c99dc930b9ccff1a43d018c81f178535/hardware/arduino/sam/cores/arduino/Print.cpp#L218
+  if (isnan(value)) return print("nan");
+  if (isinf(value)) return print("inf");
+
+  char tmp[32];
+
+  // https://github.com/arduino/Arduino/blob/db8cbf24c99dc930b9ccff1a43d018c81f178535/hardware/arduino/sam/cores/arduino/Print.cpp#L220
+  bool isBigDouble = value > 4294967040.0 || value < -4294967040.0;
+
+  if (isBigDouble) {
+    // Arduino's implementation prints "ovf"
+    // We prefer trying to use scientific notation, since we have sprintf
+    sprintf(tmp, "%g", value);
+  } else {
+    // Here we have the exact same output as Arduino's implementation
+    sprintf(tmp, "%.*f", digits, value);
+  }
+
+  return print(tmp);
+}
+
+size_t Print::println() { return write('\r') + write('\n'); }
+
+#endif

src/CMakeLists.txt

@@ -10,7 +10,7 @@ file(GLOB_RECURSE IPP_FILES ../include/*.ipp)
 file(GLOB_RECURSE CPP_FILES *.cpp)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
-	add_compile_options(
+	add_definitions(
 		-fno-exceptions
 		-fno-rtti
 		-pedantic
@@ -40,30 +40,25 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 	)
 endif()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-	add_compile_options(
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU)")
+	add_definitions(
+		-Wlogical-op
+		-Wnoexcept
 		-Wstrict-null-sentinel
 	)
-
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)
-		add_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy
-	endif()
-
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)
-		add_compile_options(-Wnoexcept)
-	endif()
 endif()
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	add_compile_options(
+	add_definitions(
 		-Wc++11-compat
 		-Wdeprecated-register
 	)
 endif()
 
 if(MSVC)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-	add_compile_options(-W4)
+	add_definitions(
+		-D_CRT_SECURE_NO_WARNINGS
+		-W4)
 endif()
 
 add_library(ArduinoJson ${CPP_FILES} ${HPP_FILES} ${IPP_FILES})

src/Internals/JsonParser.cpp

@@ -195,7 +195,7 @@ bool JsonParser::parseStringTo(JsonVariant *destination) {
   if (hasQuotes) {
     *destination = value;
   } else {
-    *destination = RawJson(value);
+    *destination = Unparsed(value);
   }
   return true;
 }

src/JsonVariant.cpp

@@ -47,7 +47,8 @@ String JsonVariant::toString() const {
   return s;
 }
 
-bool JsonVariant::isBoolean() const {
+template <>
+bool JsonVariant::is<bool>() const {
   if (_type == JSON_BOOLEAN) return true;
 
   if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
@@ -56,7 +57,8 @@ bool JsonVariant::isBoolean() const {
          !strcmp(_content.asString, "false");
 }
 
-bool JsonVariant::isInteger() const {
+template <>
+bool JsonVariant::is<signed long>() const {
   if (_type == JSON_INTEGER) return true;
 
   if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
@@ -68,7 +70,8 @@ bool JsonVariant::isInteger() const {
   return *end == '\0' && errno == 0;
 }
 
-bool JsonVariant::isFloat() const {
+template <>
+bool JsonVariant::is<double>() const {
   if (_type >= JSON_FLOAT_0_DECIMALS) return true;
 
   if (_type != JSON_UNPARSED || _content.asString == NULL) return false;

test/ArduinoString_Tests.cpp

@@ -219,27 +219,3 @@ TEST_F(ArduinoStringTests, JsonObject_PrettyPrintTo) {
   object.prettyPrintTo(json);
   ASSERT_EQ(String("{\r\n  \"key\": \"value\"\r\n}"), json);
 }
-
-TEST_F(ArduinoStringTests, JsonBuffer_GrowWhenAddingNewKey) {
-  JsonObject &object = _jsonBuffer.createObject();
-  String key1("hello"), key2("world");
-
-  object[key1] = 1;
-  size_t sizeBefore = _jsonBuffer.size();
-  object[key2] = 2;
-  size_t sizeAfter = _jsonBuffer.size();
-
-  ASSERT_GT(sizeAfter - sizeBefore, key2.size());
-}
-
-TEST_F(ArduinoStringTests, JsonBuffer_DontGrowWhenReusingKey) {
-  JsonObject &object = _jsonBuffer.createObject();
-  String key("hello");
-
-  object[key] = 1;
-  size_t sizeBefore = _jsonBuffer.size();
-  object[key] = 2;
-  size_t sizeAfter = _jsonBuffer.size();
-
-  ASSERT_EQ(sizeBefore, sizeAfter);
-}

test/Issue90.cpp

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

test/JsonArray_CopyFrom_Tests.cpp

@@ -1,64 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#include <ArduinoJson.h>
-#include <gtest/gtest.h>
-
-TEST(JsonArray_CopyFrom_Tests, OneDimension) {
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[] = {1, 2, 3};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_TRUE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[1,2,3]", json);
-}
-
-TEST(JsonArray_CopyFrom_Tests, OneDimension_JsonBufferTooSmall) {
-  const size_t SIZE = JSON_ARRAY_SIZE(2);
-  StaticJsonBuffer<SIZE> jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[] = {1, 2, 3};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_FALSE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[1,2]", json);
-}
-
-TEST(JsonArray_CopyFrom_Tests, TwoDimensions) {
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_TRUE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[[1,2,3],[4,5,6]]", json);
-}
-
-TEST(JsonArray_CopyFrom_Tests, TwoDimensions_JsonBufferTooSmall) {
-  const size_t SIZE =
-      JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
-  StaticJsonBuffer<SIZE> jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_FALSE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[[1,2,3],[4,5]]", json);
-}

test/JsonArray_CopyTo_Tests.cpp

@@ -1,56 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#include <ArduinoJson.h>
-#include <gtest/gtest.h>
-
-TEST(JsonArray_CopyTo_Tests, BiggerOneDimensionIntegerArray) {
-  char json[] = "[1,2,3]";
-
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.parseArray(json);
-
-  int destination[4] = {0};
-  size_t result = array.copyTo(destination);
-
-  ASSERT_EQ(3, result);
-  ASSERT_EQ(1, destination[0]);
-  ASSERT_EQ(2, destination[1]);
-  ASSERT_EQ(3, destination[2]);
-  ASSERT_EQ(0, destination[3]);
-}
-
-TEST(JsonArray_CopyTo_Tests, SmallerOneDimensionIntegerArray) {
-  char json[] = "[1,2,3]";
-
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.parseArray(json);
-
-  int destination[2] = {0};
-  size_t result = array.copyTo(destination);
-
-  ASSERT_EQ(2, result);
-  ASSERT_EQ(1, destination[0]);
-  ASSERT_EQ(2, destination[1]);
-}
-
-TEST(JsonArray_CopyTo_Tests, TwoOneDimensionIntegerArray) {
-  char json[] = "[[1,2],[3],[4]]";
-
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.parseArray(json);
-
-  int destination[3][2] = {0};
-  array.copyTo(destination);
-
-  ASSERT_EQ(1, destination[0][0]);
-  ASSERT_EQ(2, destination[0][1]);
-  ASSERT_EQ(3, destination[1][0]);
-  ASSERT_EQ(0, destination[1][1]);
-  ASSERT_EQ(4, destination[2][0]);
-  ASSERT_EQ(0, destination[2][1]);
-}

test/JsonArray_PrintTo_Tests.cpp

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

test/JsonArray_Subscript_Tests.cpp

@@ -5,8 +5,8 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
-#include <ArduinoJson.h>
 #include <gtest/gtest.h>
+#include <ArduinoJson.h>
 #include <stdint.h>
 
 class JsonArray_Subscript_Tests : public ::testing::Test {
@@ -33,14 +33,12 @@ TEST_(StoreInteger) {
   EXPECT_FALSE(_array[0].is<double>());
 }
 
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
-TEST_(StoreLongLong) {
+TEST_(StoreInt64) {
   _array[0] = 9223372036854775807;
-  EXPECT_EQ(9223372036854775807, _array[0].as<long long>());
+  EXPECT_EQ(9223372036854775807, _array[0].as<int64_t>());
   EXPECT_TRUE(_array[0].is<int>());
   EXPECT_FALSE(_array[0].is<double>());
 }
-#endif
 
 TEST_(StoreDouble) {
   _array[0] = 123.45;

test/JsonObject_PrintTo_Tests.cpp

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

test/JsonVariant_As_Tests.cpp

@@ -5,9 +5,9 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
+#include <gtest/gtest.h>
 #include <ArduinoJson.h>
 
-#include <gtest/gtest.h>
 #include <stdint.h>
 
 static const char* null = 0;
@@ -137,17 +137,15 @@ TEST(JsonVariant_As_Tests, NumberStringAsLong) {
   ASSERT_EQ(42L, variant.as<long>());
 }
 
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST(JsonVariant_As_Tests, NumberStringAsInt64Negative) {
   JsonVariant variant = "-9223372036854775808";
-  ASSERT_EQ(-9223372036854775807 - 1, variant.as<long long>());
+  ASSERT_EQ(-9223372036854775807 - 1, variant.as<int64_t>());
 }
 
 TEST(JsonVariant_As_Tests, NumberStringAsInt64Positive) {
   JsonVariant variant = "9223372036854775807";
-  ASSERT_EQ(9223372036854775807, variant.as<long long>());
+  ASSERT_EQ(9223372036854775807, variant.as<int64_t>());
 }
-#endif
 
 TEST(JsonVariant_As_Tests, RandomStringAsBool) {
   JsonVariant variant = "hello";
@@ -159,16 +157,6 @@ TEST(JsonVariant_As_Tests, RandomStringAsLong) {
   ASSERT_EQ(0L, variant.as<long>());
 }
 
-TEST(JsonVariant_As_Tests, RandomStringAsConstCharPtr) {
-  JsonVariant variant = "hello";
-  ASSERT_STREQ("hello", variant.as<const char*>());
-}
-
-TEST(JsonVariant_As_Tests, RandomStringAsCharPtr) {
-  JsonVariant variant = "hello";
-  ASSERT_STREQ("hello", variant.as<char*>());
-}
-
 TEST(JsonVariant_As_Tests, RandomStringAsString) {
   JsonVariant variant = "hello";
   ASSERT_EQ(String("hello"), variant.as<String>());

test/JsonVariant_Is_Tests.cpp

@@ -10,6 +10,8 @@
 
 #define SUITE JsonVariant_Is_Tests
 
+using namespace ArduinoJson::Internals;
+
 template <typename TTo, typename TFrom>
 void assertIsNot(TFrom value) {
   JsonVariant variant = value;
@@ -74,35 +76,37 @@ TEST(SUITE, StringIsInt) { assertIsNot<int>("42"); }
 TEST(SUITE, StringIsLong) { assertIsNot<long>("42"); }
 TEST(SUITE, StringIsString) { assertIs<const char*>("42"); }
 
-TEST(SUITE, UnparsedTrueIsArra) { assertIsNot<JsonArray&>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsBool) { assertIs<bool>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsDouble) { assertIsNot<double>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsFloat) { assertIsNot<float>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsInt) { assertIsNot<int>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsLong) { assertIsNot<long>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsString) { assertIsNot<const char*>(RawJson("true")); }
-
-TEST(SUITE, UnparsedFalseIsArra) { assertIsNot<JsonArray&>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsBool) { assertIs<bool>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsDouble) { assertIsNot<double>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsFloat) { assertIsNot<float>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsInt) { assertIsNot<int>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsLong) { assertIsNot<long>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsString) {
-  assertIsNot<const char*>(RawJson("false"));
+TEST(SUITE, UnparsedTrueIsArra) { assertIsNot<JsonArray&>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsBool) { assertIs<bool>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsDouble) { assertIsNot<double>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsFloat) { assertIsNot<float>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsInt) { assertIsNot<int>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsLong) { assertIsNot<long>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsString) {
+  assertIsNot<const char*>(Unparsed("true"));
 }
 
-TEST(SUITE, UnparsedIntIsArra) { assertIsNot<JsonArray&>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(RawJson("42")); }
+TEST(SUITE, UnparsedFalseIsArra) { assertIsNot<JsonArray&>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsBool) { assertIs<bool>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsDouble) { assertIsNot<double>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsFloat) { assertIsNot<float>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsInt) { assertIsNot<int>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsLong) { assertIsNot<long>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsString) {
+  assertIsNot<const char*>(Unparsed("false"));
+}
 
-TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(RawJson("4.2")); }
+TEST(SUITE, UnparsedIntIsArra) { assertIsNot<JsonArray&>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(Unparsed("42")); }
+
+TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(Unparsed("4.2")); }

test/JsonVariant_PrintTo_Tests.cpp

@@ -72,7 +72,6 @@ TEST_F(JsonVariant_PrintTo_Tests, OneFalse) {
   outputMustBe("false");
 }
 
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST_F(JsonVariant_PrintTo_Tests, NegativeInt64) {
   variant = -9223372036854775807 - 1;
   outputMustBe("-9223372036854775808");
@@ -82,4 +81,3 @@ TEST_F(JsonVariant_PrintTo_Tests, PositiveInt64) {
   variant = 9223372036854775807;
   outputMustBe("9223372036854775807");
 }
-#endif

test/JsonVariant_Storage_Tests.cpp

@@ -5,9 +5,9 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!
 
-#include <gtest/gtest.h>
 #include <stdint.h>
 #include <limits>
+#include <gtest/gtest.h>
 #include <ArduinoJson.h>
 
 class JsonVariant_Storage_Tests : public ::testing::Test {
@@ -37,11 +37,9 @@ class JsonVariant_Storage_Tests : public ::testing::Test {
   }
 };
 
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST_F(JsonVariant_Storage_Tests, SizeOfJsonInteger) {
   ASSERT_EQ(8, sizeof(Internals::JsonInteger));
 }
-#endif
 
 TEST_F(JsonVariant_Storage_Tests, Null) { testValue<const char *>(NULL); }
 TEST_F(JsonVariant_Storage_Tests, String) { testValue<const char *>("hello"); }
@@ -59,21 +57,15 @@ TEST_F(JsonVariant_Storage_Tests, UChar) { testNumericType<unsigned char>(); }
 TEST_F(JsonVariant_Storage_Tests, UInt) { testNumericType<unsigned int>(); }
 TEST_F(JsonVariant_Storage_Tests, ULong) { testNumericType<unsigned long>(); }
 TEST_F(JsonVariant_Storage_Tests, UShort) { testNumericType<unsigned short>(); }
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
-TEST_F(JsonVariant_Storage_Tests, LongLong) { testNumericType<unsigned long long>(); }
-TEST_F(JsonVariant_Storage_Tests, ULongLong) { testNumericType<unsigned long long>(); }
-#endif
 
 TEST_F(JsonVariant_Storage_Tests, Int8) { testNumericType<int8_t>(); }
-TEST_F(JsonVariant_Storage_Tests, Uint8) { testNumericType<uint8_t>(); }
 TEST_F(JsonVariant_Storage_Tests, Int16) { testNumericType<int16_t>(); }
-TEST_F(JsonVariant_Storage_Tests, Uint16) { testNumericType<uint16_t>(); }
 TEST_F(JsonVariant_Storage_Tests, Int32) { testNumericType<int32_t>(); }
-TEST_F(JsonVariant_Storage_Tests, Uint32) { testNumericType<uint32_t>(); }
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST_F(JsonVariant_Storage_Tests, Int64) { testNumericType<int64_t>(); }
+TEST_F(JsonVariant_Storage_Tests, Uint8) { testNumericType<uint8_t>(); }
+TEST_F(JsonVariant_Storage_Tests, Uint16) { testNumericType<uint16_t>(); }
+TEST_F(JsonVariant_Storage_Tests, Uint32) { testNumericType<uint32_t>(); }
 TEST_F(JsonVariant_Storage_Tests, Uint64) { testNumericType<uint64_t>(); }
-#endif
 
 TEST_F(JsonVariant_Storage_Tests, CanStoreObject) {
   DynamicJsonBuffer jsonBuffer;