Renamed folder include/ to src/ (issue #461)

src/ArduinoJson.h

@@ -0,0 +1,12 @@
+// 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 "ArduinoJson.hpp"
+
+using namespace ArduinoJson;

src/ArduinoJson.hpp

@@ -0,0 +1,21 @@
+// 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 "ArduinoJson/DynamicJsonBuffer.hpp"
+#include "ArduinoJson/JsonArray.hpp"
+#include "ArduinoJson/JsonObject.hpp"
+#include "ArduinoJson/JsonVariantComparisons.hpp"
+#include "ArduinoJson/StaticJsonBuffer.hpp"
+
+#include "ArduinoJson/Deserialization/JsonParserImpl.hpp"
+#include "ArduinoJson/JsonArrayImpl.hpp"
+#include "ArduinoJson/JsonBufferImpl.hpp"
+#include "ArduinoJson/JsonObjectImpl.hpp"
+#include "ArduinoJson/JsonVariantImpl.hpp"
+#include "ArduinoJson/Serialization/JsonSerializerImpl.hpp"

src/ArduinoJson/Configuration.hpp

@@ -0,0 +1,137 @@
+// 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
+
+// enable deprecated functions by default
+#ifndef ARDUINOJSON_ENABLE_DEPRECATED
+#define ARDUINOJSON_ENABLE_DEPRECATED 1
+#endif
+
+#ifdef ARDUINO  // assume this is an embedded platform
+
+// store using float instead of double to reduce the memory usage (issue #134)
+#ifndef ARDUINOJSON_USE_DOUBLE
+#define ARDUINOJSON_USE_DOUBLE 0
+#endif
+
+// store using a long because it usually match the size of a float.
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#define ARDUINOJSON_USE_LONG_LONG 0
+#endif
+#ifndef ARDUINOJSON_USE_INT64
+#define ARDUINOJSON_USE_INT64 0
+#endif
+
+// Arduino has its own implementation of String to replace std::string
+#ifndef ARDUINOJSON_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
+#ifndef ARDUINOJSON_ENABLE_STD_STRING
+#define ARDUINOJSON_ENABLE_STD_STRING 0
+#endif
+
+// Arduino doesn't support STL stream
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#define ARDUINOJSON_ENABLE_STD_STREAM 0
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+#ifdef ARDUINO_ARCH_AVR
+// alignment isn't needed for 8-bit AVR
+#define ARDUINOJSON_ENABLE_ALIGNMENT 0
+#else
+// but must processor needs pointer to be align on word size
+#define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#endif
+#endif
+
+// low value to prevent stack overflow
+#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
+#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
+#endif
+
+#else  // assume this is a computer
+
+// on a computer we have plenty of memory so we can use doubles
+#ifndef ARDUINOJSON_USE_DOUBLE
+#define ARDUINOJSON_USE_DOUBLE 1
+#endif
+
+// use long long when available
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
+#define ARDUINOJSON_USE_LONG_LONG 1
+#else
+#define ARDUINOJSON_USE_LONG_LONG 0
+#endif
+#endif
+
+// use _int64 on old versions of Visual Studio
+#ifndef ARDUINOJSON_USE_INT64
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#define ARDUINOJSON_USE_INT64 1
+#else
+#define ARDUINOJSON_USE_INT64 0
+#endif
+#endif
+
+// on a computer, we can use std::string
+#ifndef ARDUINOJSON_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
+#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
+#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
+#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50
+#endif
+
+#endif
+
+#if ARDUINOJSON_USE_LONG_LONG && ARDUINOJSON_USE_INT64
+#error ARDUINOJSON_USE_LONG_LONG and ARDUINOJSON_USE_INT64 cannot be set together
+#endif

src/ArduinoJson/Data/Encoding.hpp

@@ -0,0 +1,42 @@
+// 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 "../Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+class Encoding {
+ public:
+  // Optimized for code size on a 8-bit AVR
+  static char escapeChar(char c) {
+    const char *p = escapeTable(false);
+    while (p[0] && p[1] != c) {
+      p += 2;
+    }
+    return p[0];
+  }
+
+  // Optimized for code size on a 8-bit AVR
+  static char unescapeChar(char c) {
+    const char *p = escapeTable(true);
+    for (;;) {
+      if (p[0] == '\0') return c;
+      if (p[0] == c) return p[1];
+      p += 2;
+    }
+  }
+
+ private:
+  static const char *escapeTable(bool excludeIdenticals) {
+    return &"\"\"\\\\b\bf\fn\nr\rt\t"[excludeIdenticals ? 4 : 0];
+  }
+};
+}
+}

src/ArduinoJson/Data/JsonBufferAllocated.hpp

@@ -0,0 +1,25 @@
+// 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 "../JsonBuffer.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+class JsonBufferAllocated {
+ public:
+  void *operator new(size_t n, JsonBuffer *jsonBuffer) throw() {
+    if (!jsonBuffer) return NULL;
+    return jsonBuffer->alloc(n);
+  }
+
+  void operator delete(void *, JsonBuffer *)throw() {}
+};
+}
+}

src/ArduinoJson/Data/JsonFloat.hpp

@@ -0,0 +1,21 @@
+// 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 Internals {
+
+#if ARDUINOJSON_USE_DOUBLE
+typedef double JsonFloat;
+#else
+typedef float JsonFloat;
+#endif
+}
+}

src/ArduinoJson/Data/JsonInteger.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
+
+#include "../Configuration.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+#if ARDUINOJSON_USE_LONG_LONG
+typedef long long JsonInteger;
+typedef unsigned long long JsonUInt;
+#elif ARDUINOJSON_USE_INT64
+typedef __int64 JsonInteger;
+typedef unsigned _int64 JsonUInt;
+#else
+typedef long JsonInteger;
+typedef unsigned long JsonUInt;
+#endif
+}
+}

src/ArduinoJson/Data/JsonVariantAs.hpp

@@ -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!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A metafunction that returns the type of the value returned by
+// JsonVariant::as<T>()
+template <typename T>
+struct JsonVariantAs {
+  typedef T type;
+};
+
+template <>
+struct JsonVariantAs<char*> {
+  typedef const char* type;
+};
+
+template <>
+struct JsonVariantAs<JsonArray> {
+  typedef JsonArray& type;
+};
+
+template <>
+struct JsonVariantAs<const JsonArray> {
+  typedef const JsonArray& type;
+};
+
+template <>
+struct JsonVariantAs<JsonObject> {
+  typedef JsonObject& type;
+};
+
+template <>
+struct JsonVariantAs<const JsonObject> {
+  typedef const JsonObject& type;
+};
+}
+}

src/ArduinoJson/Data/JsonVariantComparer.hpp

@@ -0,0 +1,69 @@
+// 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;
+  }
+};
+}
+}

src/ArduinoJson/Data/JsonVariantContent.hpp

@@ -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!
+
+#pragma once
+
+#include "JsonFloat.hpp"
+#include "JsonInteger.hpp"
+
+namespace ArduinoJson {
+
+// Forward declarations
+class JsonArray;
+class JsonObject;
+
+namespace Internals {
+// A union that defines the actual content of a JsonVariant.
+// The enum JsonVariantType determines which member is in use.
+union JsonVariantContent {
+  JsonFloat asFloat;     // used for double and float
+  JsonUInt asInteger;    // used for bool, char, short, int and longs
+  const char* asString;  // asString can be null
+  JsonArray* asArray;    // asArray cannot be null
+  JsonObject* asObject;  // asObject cannot be null
+};
+}
+}

src/ArduinoJson/Data/JsonVariantDefault.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 {
+
+template <typename T>
+struct JsonVariantDefault {
+  static T get() {
+    return T();
+  }
+};
+
+template <typename T>
+struct JsonVariantDefault<const T> : JsonVariantDefault<T> {};
+
+template <typename T>
+struct JsonVariantDefault<T&> : JsonVariantDefault<T> {};
+}
+}

src/ArduinoJson/Data/JsonVariantType.hpp

@@ -0,0 +1,39 @@
+// 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 {
+class JsonArray;
+class JsonObject;
+
+namespace Internals {
+
+// Enumerated type to know the current type of a JsonVariant.
+// The value determines which member of JsonVariantContent is used.
+enum JsonVariantType {
+  JSON_UNDEFINED,         // JsonVariant has not been initialized
+  JSON_UNPARSED,          // JsonVariant contains an unparsed string
+  JSON_STRING,            // JsonVariant stores a const char*
+  JSON_BOOLEAN,           // JsonVariant stores a bool
+  JSON_POSITIVE_INTEGER,  // JsonVariant stores an unsigned long
+  JSON_NEGATIVE_INTEGER,  // JsonVariant stores an unsigned long that must be
+                          // negated
+  JSON_ARRAY,             // JsonVariant stores a pointer to a JsonArray
+  JSON_OBJECT,            // JsonVariant stores a pointer to a JsonObject
+
+  // The following values are reserved for float values
+  // Multiple values are used for double, depending on the number of decimal
+  // digits that must be printed in the JSON output.
+  // This little trick allow to save one extra member in JsonVariant
+  JSON_FLOAT_0_DECIMALS
+  // JSON_FLOAT_1_DECIMAL
+  // JSON_FLOAT_2_DECIMALS
+  // ...
+};
+}
+}

src/ArduinoJson/Data/List.hpp

@@ -0,0 +1,97 @@
+// 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 "../JsonBuffer.hpp"
+#include "ListConstIterator.hpp"
+#include "ListIterator.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A singly linked list of T.
+// The linked list is composed of ListNode<T>.
+// It is derived by JsonArray and JsonObject
+template <typename T>
+class List {
+ public:
+  typedef T value_type;
+  typedef ListNode<T> node_type;
+  typedef ListIterator<T> iterator;
+  typedef ListConstIterator<T> const_iterator;
+
+  // Creates an empty List<T> attached to a JsonBuffer.
+  // The JsonBuffer allows to allocate new nodes.
+  // When buffer is NULL, the List is not able to grow and success() returns
+  // false. This is used to identify bad memory allocations and parsing
+  // failures.
+  explicit List(JsonBuffer *buffer) : _buffer(buffer), _firstNode(NULL) {}
+
+  // Returns true if the object is valid
+  // Would return false in the following situation:
+  // - the memory allocation failed (StaticJsonBuffer was too small)
+  // - the JSON parsing failed
+  bool success() const {
+    return _buffer != NULL;
+  }
+
+  // Returns the numbers of elements in the list.
+  // For a JsonObject, it would return the number of key-value pairs
+  size_t size() const {
+    size_t nodeCount = 0;
+    for (node_type *node = _firstNode; node; node = node->next) nodeCount++;
+    return nodeCount;
+  }
+
+  iterator add() {
+    node_type *newNode = new (_buffer) node_type();
+
+    if (_firstNode) {
+      node_type *lastNode = _firstNode;
+      while (lastNode->next) lastNode = lastNode->next;
+      lastNode->next = newNode;
+    } else {
+      _firstNode = newNode;
+    }
+
+    return iterator(newNode);
+  }
+
+  iterator begin() {
+    return iterator(_firstNode);
+  }
+  iterator end() {
+    return iterator(NULL);
+  }
+
+  const_iterator begin() const {
+    return const_iterator(_firstNode);
+  }
+  const_iterator end() const {
+    return const_iterator(NULL);
+  }
+
+  void remove(iterator it) {
+    node_type *nodeToRemove = it._node;
+    if (!nodeToRemove) return;
+    if (nodeToRemove == _firstNode) {
+      _firstNode = nodeToRemove->next;
+    } else {
+      for (node_type *node = _firstNode; node; node = node->next)
+        if (node->next == nodeToRemove) node->next = nodeToRemove->next;
+    }
+  }
+
+ protected:
+  JsonBuffer *_buffer;
+
+ private:
+  node_type *_firstNode;
+};
+}
+}

src/ArduinoJson/Data/ListConstIterator.hpp

@@ -0,0 +1,53 @@
+// 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 "ListNode.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A read-only forward itertor for List<T>
+template <typename T>
+class ListConstIterator {
+ public:
+  explicit ListConstIterator(const ListNode<T> *node = NULL) : _node(node) {}
+
+  const T &operator*() const {
+    return _node->content;
+  }
+  const T *operator->() {
+    return &_node->content;
+  }
+
+  bool operator==(const ListConstIterator<T> &other) const {
+    return _node == other._node;
+  }
+
+  bool operator!=(const ListConstIterator<T> &other) const {
+    return _node != other._node;
+  }
+
+  ListConstIterator<T> &operator++() {
+    if (_node) _node = _node->next;
+    return *this;
+  }
+
+  ListConstIterator<T> &operator+=(size_t distance) {
+    while (_node && distance) {
+      _node = _node->next;
+      --distance;
+    }
+    return *this;
+  }
+
+ private:
+  const ListNode<T> *_node;
+};
+}
+}

src/ArduinoJson/Data/ListIterator.hpp

@@ -0,0 +1,63 @@
+// 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 "ListConstIterator.hpp"
+#include "ListNode.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename T>
+class List;
+
+// A read-write forward iterator for List<T>
+template <typename T>
+class ListIterator {
+  friend class List<T>;
+
+ public:
+  explicit ListIterator(ListNode<T> *node = NULL) : _node(node) {}
+
+  T &operator*() const {
+    return _node->content;
+  }
+  T *operator->() {
+    return &_node->content;
+  }
+
+  bool operator==(const ListIterator<T> &other) const {
+    return _node == other._node;
+  }
+
+  bool operator!=(const ListIterator<T> &other) const {
+    return _node != other._node;
+  }
+
+  ListIterator<T> &operator++() {
+    if (_node) _node = _node->next;
+    return *this;
+  }
+
+  ListIterator<T> &operator+=(size_t distance) {
+    while (_node && distance) {
+      _node = _node->next;
+      --distance;
+    }
+    return *this;
+  }
+
+  operator ListConstIterator<T>() const {
+    return ListConstIterator<T>(_node);
+  }
+
+ private:
+  ListNode<T> *_node;
+};
+}
+}

src/ArduinoJson/Data/ListNode.hpp

@@ -0,0 +1,27 @@
+// 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 <stddef.h>  // for NULL
+
+#include "JsonBufferAllocated.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A node for a singly-linked list.
+// Used by List<T> and its iterators.
+template <typename T>
+struct ListNode : public Internals::JsonBufferAllocated {
+  ListNode() : next(NULL) {}
+
+  ListNode<T> *next;
+  T content;
+};
+}
+}

src/ArduinoJson/Data/ReferenceType.hpp

@@ -0,0 +1,37 @@
+// 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 is meant to be used by reference only (JsonArray and JsonObject)
+class ReferenceType {
+ public:
+  bool operator==(const ReferenceType& other) const {
+    // two JsonArray are equal if they are the same instance
+    // (we don't compare the content)
+    return this == &other;
+  }
+
+  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&);
+};
+}
+}

src/ArduinoJson/Data/ValueSetter.hpp

@@ -0,0 +1,53 @@
+// 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 "../JsonBuffer.hpp"
+#include "../JsonVariant.hpp"
+#include "../StringTraits/StringTraits.hpp"
+#include "../TypeTraits/EnableIf.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TSource, typename Enable = void>
+struct ValueSetter {
+  template <typename TDestination>
+  static bool set(JsonBuffer*, TDestination& destination,
+                  const TSource& source) {
+    destination = source;
+    return true;
+  }
+};
+
+template <typename TSource>
+struct ValueSetter<TSource, typename TypeTraits::EnableIf<StringTraits<
+                                TSource>::should_duplicate>::type> {
+  template <typename TDestination>
+  static bool set(JsonBuffer* buffer, TDestination& destination,
+                  const TSource& source) {
+    const char* copy = buffer->strdup(source);
+    if (!copy) return false;
+    destination = copy;
+    return true;
+  }
+};
+
+template <typename TSource>
+struct ValueSetter<TSource, typename TypeTraits::EnableIf<!StringTraits<
+                                TSource>::should_duplicate>::type> {
+  template <typename TDestination>
+  static bool set(JsonBuffer*, TDestination& destination,
+                  const TSource& source) {
+    // unsigned char* -> char*
+    destination = reinterpret_cast<const char*>(source);
+    return true;
+  }
+};
+}
+}

src/ArduinoJson/Deserialization/Comments.hpp

@@ -0,0 +1,64 @@
+// 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 {
+template <typename TInput>
+void skipSpacesAndComments(TInput& input) {
+  for (;;) {
+    switch (input.current()) {
+      // spaces
+      case ' ':
+      case '\t':
+      case '\r':
+      case '\n':
+        input.move();
+        continue;
+
+      // comments
+      case '/':
+        switch (input.next()) {
+          // C-style block comment
+          case '*':
+            input.move();  // skip '/'
+            // no need to skip '*'
+            for (;;) {
+              input.move();
+              if (input.current() == '\0') return;
+              if (input.current() == '*' && input.next() == '/') {
+                input.move();  // skip '*'
+                input.move();  // skip '/'
+                break;
+              }
+            }
+            break;
+
+          // C++-style line comment
+          case '/':
+            // not need to skip "//"
+            for (;;) {
+              input.move();
+              if (input.current() == '\0') return;
+              if (input.current() == '\n') break;
+            }
+            break;
+
+          // not a comment, just a '/'
+          default:
+            return;
+        }
+        break;
+
+      default:
+        return;
+    }
+  }
+}
+}
+}

src/ArduinoJson/Deserialization/JsonParser.hpp

@@ -0,0 +1,107 @@
+// 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 "../JsonBuffer.hpp"
+#include "../JsonVariant.hpp"
+#include "../TypeTraits/IsConst.hpp"
+#include "StringWriter.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Parse JSON string to create JsonArrays and JsonObjects
+// This internal class is not indended to be used directly.
+// Instead, use JsonBuffer.parseArray() or .parseObject()
+template <typename TReader, typename TWriter>
+class JsonParser {
+ public:
+  JsonParser(JsonBuffer *buffer, TReader reader, TWriter writer,
+             uint8_t nestingLimit)
+      : _buffer(buffer),
+        _reader(reader),
+        _writer(writer),
+        _nestingLimit(nestingLimit) {}
+
+  JsonArray &parseArray();
+  JsonObject &parseObject();
+
+  JsonVariant parseVariant() {
+    JsonVariant result;
+    parseAnythingTo(&result);
+    return result;
+  }
+
+ private:
+  JsonParser &operator=(const JsonParser &);  // non-copiable
+
+  static bool eat(TReader &, char charToSkip);
+  FORCE_INLINE bool eat(char charToSkip) {
+    return eat(_reader, charToSkip);
+  }
+
+  const char *parseString();
+  bool parseAnythingTo(JsonVariant *destination);
+  FORCE_INLINE bool parseAnythingToUnsafe(JsonVariant *destination);
+
+  inline bool parseArrayTo(JsonVariant *destination);
+  inline bool parseObjectTo(JsonVariant *destination);
+  inline bool parseStringTo(JsonVariant *destination);
+
+  static inline bool isInRange(char c, char min, char max) {
+    return min <= c && c <= max;
+  }
+
+  static inline bool isLetterOrNumber(char c) {
+    return isInRange(c, '0', '9') || isInRange(c, 'a', 'z') ||
+           isInRange(c, 'A', 'Z') || c == '+' || c == '-' || c == '.';
+  }
+
+  static inline bool isQuote(char c) {
+    return c == '\'' || c == '\"';
+  }
+
+  JsonBuffer *_buffer;
+  TReader _reader;
+  TWriter _writer;
+  uint8_t _nestingLimit;
+};
+
+template <typename TJsonBuffer, typename TString, typename Enable = void>
+struct JsonParserBuilder {
+  typedef typename Internals::StringTraits<TString>::Reader InputReader;
+  typedef JsonParser<InputReader, TJsonBuffer &> TParser;
+
+  static TParser makeParser(TJsonBuffer *buffer, TString &json,
+                            uint8_t nestingLimit) {
+    return TParser(buffer, InputReader(json), *buffer, nestingLimit);
+  }
+};
+
+template <typename TJsonBuffer, typename TChar>
+struct JsonParserBuilder<
+    TJsonBuffer, TChar *,
+    typename TypeTraits::EnableIf<!TypeTraits::IsConst<TChar>::value>::type> {
+  typedef typename Internals::StringTraits<TChar *>::Reader TReader;
+  typedef StringWriter<TChar> TWriter;
+  typedef JsonParser<TReader, TWriter> TParser;
+
+  static TParser makeParser(TJsonBuffer *buffer, TChar *json,
+                            uint8_t nestingLimit) {
+    return TParser(buffer, TReader(json), TWriter(json), nestingLimit);
+  }
+};
+
+template <typename TJsonBuffer, typename TString>
+inline typename JsonParserBuilder<TJsonBuffer, TString>::TParser makeParser(
+    TJsonBuffer *buffer, TString &json, uint8_t nestingLimit) {
+  return JsonParserBuilder<TJsonBuffer, TString>::makeParser(buffer, json,
+                                                             nestingLimit);
+}
+}
+}

src/ArduinoJson/Deserialization/JsonParserImpl.hpp

@@ -0,0 +1,196 @@
+// 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 "Comments.hpp"
+#include "JsonParser.hpp"
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::eat(
+    TReader &reader, char charToSkip) {
+  skipSpacesAndComments(reader);
+  if (reader.current() != charToSkip) return false;
+  reader.move();
+  return true;
+}
+
+template <typename TReader, typename TWriter>
+inline bool
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingTo(
+    JsonVariant *destination) {
+  if (_nestingLimit == 0) return false;
+  _nestingLimit--;
+  bool success = parseAnythingToUnsafe(destination);
+  _nestingLimit++;
+  return success;
+}
+
+template <typename TReader, typename TWriter>
+inline bool
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseAnythingToUnsafe(
+    JsonVariant *destination) {
+  skipSpacesAndComments(_reader);
+
+  switch (_reader.current()) {
+    case '[':
+      return parseArrayTo(destination);
+
+    case '{':
+      return parseObjectTo(destination);
+
+    default:
+      return parseStringTo(destination);
+  }
+}
+
+template <typename TReader, typename TWriter>
+inline ArduinoJson::JsonArray &
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArray() {
+  // Create an empty array
+  JsonArray &array = _buffer->createArray();
+
+  // Check opening braket
+  if (!eat('[')) goto ERROR_MISSING_BRACKET;
+  if (eat(']')) goto SUCCESS_EMPTY_ARRAY;
+
+  // Read each value
+  for (;;) {
+    // 1 - Parse value
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!array.add(value)) goto ERROR_NO_MEMORY;
+
+    // 2 - More values?
+    if (eat(']')) goto SUCCES_NON_EMPTY_ARRAY;
+    if (!eat(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_ARRAY:
+SUCCES_NON_EMPTY_ARRAY:
+  return array;
+
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACKET:
+ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
+  return JsonArray::invalid();
+}
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArrayTo(
+    JsonVariant *destination) {
+  JsonArray &array = parseArray();
+  if (!array.success()) return false;
+
+  *destination = array;
+  return true;
+}
+
+template <typename TReader, typename TWriter>
+inline ArduinoJson::JsonObject &
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseObject() {
+  // Create an empty object
+  JsonObject &object = _buffer->createObject();
+
+  // Check opening brace
+  if (!eat('{')) goto ERROR_MISSING_BRACE;
+  if (eat('}')) goto SUCCESS_EMPTY_OBJECT;
+
+  // Read each key value pair
+  for (;;) {
+    // 1 - Parse key
+    const char *key = parseString();
+    if (!key) goto ERROR_INVALID_KEY;
+    if (!eat(':')) goto ERROR_MISSING_COLON;
+
+    // 2 - Parse value
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!object.set(key, value)) goto ERROR_NO_MEMORY;
+
+    // 3 - More keys/values?
+    if (eat('}')) goto SUCCESS_NON_EMPTY_OBJECT;
+    if (!eat(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_OBJECT:
+SUCCESS_NON_EMPTY_OBJECT:
+  return object;
+
+ERROR_INVALID_KEY:
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACE:
+ERROR_MISSING_COLON:
+ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
+  return JsonObject::invalid();
+}
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseObjectTo(
+    JsonVariant *destination) {
+  JsonObject &object = parseObject();
+  if (!object.success()) return false;
+
+  *destination = object;
+  return true;
+}
+
+template <typename TReader, typename TWriter>
+inline const char *
+ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseString() {
+  typename TypeTraits::RemoveReference<TWriter>::type::String str =
+      _writer.startString();
+
+  skipSpacesAndComments(_reader);
+  char c = _reader.current();
+
+  if (isQuote(c)) {  // quotes
+    _reader.move();
+    char stopChar = c;
+    for (;;) {
+      c = _reader.current();
+      if (c == '\0') break;
+      _reader.move();
+
+      if (c == stopChar) break;
+
+      if (c == '\\') {
+        // replace char
+        c = Encoding::unescapeChar(_reader.current());
+        if (c == '\0') break;
+        _reader.move();
+      }
+
+      str.append(c);
+    }
+  } else {  // no quotes
+    for (;;) {
+      if (!isLetterOrNumber(c)) break;
+      _reader.move();
+      str.append(c);
+      c = _reader.current();
+    }
+  }
+
+  return str.c_str();
+}
+
+template <typename TReader, typename TWriter>
+inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseStringTo(
+    JsonVariant *destination) {
+  bool hasQuotes = isQuote(_reader.current());
+  const char *value = parseString();
+  if (value == NULL) return false;
+  if (hasQuotes) {
+    *destination = value;
+  } else {
+    *destination = RawJson(value);
+  }
+  return true;
+}

src/ArduinoJson/Deserialization/StringWriter.hpp

@@ -0,0 +1,44 @@
+// 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 {
+
+template <typename TChar>
+class StringWriter {
+ public:
+  class String {
+   public:
+    String(TChar** ptr) : _writePtr(ptr), _startPtr(*ptr) {}
+
+    void append(TChar c) {
+      *(*_writePtr)++ = c;
+    }
+
+    const char* c_str() const {
+      *(*_writePtr)++ = 0;
+      return reinterpret_cast<const char*>(_startPtr);
+    }
+
+   private:
+    TChar** _writePtr;
+    TChar* _startPtr;
+  };
+
+  StringWriter(TChar* buffer) : _ptr(buffer) {}
+
+  String startString() {
+    return String(&_ptr);
+  }
+
+ private:
+  TChar* _ptr;
+};
+}
+}

src/ArduinoJson/DynamicJsonBuffer.hpp

@@ -0,0 +1,159 @@
+// 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 "JsonBufferBase.hpp"
+
+#include <stdlib.h>
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic push
+#endif
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+namespace ArduinoJson {
+class DefaultAllocator {
+ public:
+  void* allocate(size_t size) {
+    return malloc(size);
+  }
+  void deallocate(void* pointer) {
+    free(pointer);
+  }
+};
+
+template <typename TAllocator>
+class DynamicJsonBufferBase
+    : public JsonBufferBase<DynamicJsonBufferBase<TAllocator> > {
+  struct Block;
+  struct EmptyBlock {
+    Block* next;
+    size_t capacity;
+    size_t size;
+  };
+  struct Block : EmptyBlock {
+    uint8_t data[1];
+  };
+
+ public:
+  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;
+    }
+  }
+
+  size_t size() const {
+    size_t total = 0;
+    for (const Block* b = _head; b; b = b->next) total += b->size;
+    return total;
+  }
+
+  virtual void* alloc(size_t bytes) {
+    alignNextAlloc();
+    return canAllocInHead(bytes) ? allocInHead(bytes) : allocInNewBlock(bytes);
+  }
+
+  class String {
+   public:
+    String(DynamicJsonBufferBase* parent)
+        : _parent(parent), _start(NULL), _length(0) {}
+
+    void append(char c) {
+      if (_parent->canAllocInHead(1)) {
+        char* end = static_cast<char*>(_parent->allocInHead(1));
+        *end = c;
+        if (_length == 0) _start = end;
+      } else {
+        char* newStart =
+            static_cast<char*>(_parent->allocInNewBlock(_length + 1));
+        if (_start && newStart) memcpy(newStart, _start, _length);
+        if (newStart) newStart[_length] = c;
+        _start = newStart;
+      }
+      _length++;
+    }
+
+    const char* c_str() {
+      append(0);
+      return _start;
+    }
+
+   private:
+    DynamicJsonBufferBase* _parent;
+    char* _start;
+    int _length;
+  };
+
+  String startString() {
+    return String(this);
+  }
+
+ private:
+  void alignNextAlloc() {
+    if (_head) _head->size = this->round_size_up(_head->size);
+  }
+
+  bool canAllocInHead(size_t bytes) const {
+    return _head != NULL && _head->size + bytes <= _head->capacity;
+  }
+
+  void* allocInHead(size_t bytes) {
+    void* p = _head->data + _head->size;
+    _head->size += bytes;
+    return p;
+  }
+
+  void* allocInNewBlock(size_t bytes) {
+    size_t capacity = _nextBlockCapacity;
+    if (bytes > capacity) capacity = bytes;
+    if (!addNewBlock(capacity)) return NULL;
+    _nextBlockCapacity *= 2;
+    return allocInHead(bytes);
+  }
+
+  bool addNewBlock(size_t capacity) {
+    size_t bytes = sizeof(EmptyBlock) + capacity;
+    Block* block = static_cast<Block*>(_allocator.allocate(bytes));
+    if (block == NULL) return false;
+    block->capacity = capacity;
+    block->size = 0;
+    block->next = _head;
+    _head = block;
+    return true;
+  }
+
+  TAllocator _allocator;
+  Block* _head;
+  size_t _nextBlockCapacity;
+};
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic pop
+#endif
+#endif
+
+// Implements a JsonBuffer with dynamic memory allocation.
+// You are strongly encouraged to consider using StaticJsonBuffer which is much
+// more suitable for embedded systems.
+typedef DynamicJsonBufferBase<DefaultAllocator> DynamicJsonBuffer;
+}

src/ArduinoJson/JsonArray.hpp

@@ -0,0 +1,231 @@
+// 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/JsonBufferAllocated.hpp"
+#include "Data/List.hpp"
+#include "Data/ReferenceType.hpp"
+#include "Data/ValueSetter.hpp"
+#include "JsonVariant.hpp"
+#include "Serialization/JsonPrintable.hpp"
+#include "StringTraits/StringTraits.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsArray.hpp"
+#include "TypeTraits/IsFloatingPoint.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.
+#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
+  (sizeof(JsonArray) + (NUMBER_OF_ELEMENTS) * sizeof(JsonArray::node_type))
+
+namespace ArduinoJson {
+
+// Forward declarations
+class JsonObject;
+class JsonBuffer;
+class JsonArraySubscript;
+
+// An array of JsonVariant.
+//
+// The constructor is private, instances must be created via
+// JsonBuffer::createArray() or JsonBuffer::parseArray().
+// A JsonArray can be serialized to a JSON string via JsonArray::printTo().
+// It can also be deserialized from a JSON string via JsonBuffer::parseArray().
+class JsonArray : public Internals::JsonPrintable<JsonArray>,
+                  public Internals::ReferenceType,
+                  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)
+      : Internals::List<JsonVariant>(buffer) {}
+
+  // Gets the value at the specified index
+  const JsonArraySubscript operator[](size_t index) const;
+
+  // Gets or sets the value at specified index
+  JsonArraySubscript operator[](size_t index);
+
+  // Adds the specified value at the end of the array.
+  //
+  // bool add(TValue);
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename T>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<T>::value, bool>::type add(
+      const T &value) {
+    return add_impl<const T &>(value);
+  }
+  //
+  // bool add(TValue);
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename T>
+  bool add(const T *value) {
+    return add_impl<const T *>(value);
+  }
+  //
+  // bool add(TValue value, uint8_t decimals);
+  // TValue = float, double
+  template <typename T>
+  bool add(T value, uint8_t decimals) {
+    return add_impl<const JsonVariant &>(JsonVariant(value, decimals));
+  }
+
+  // Sets the value at specified index.
+  //
+  // bool add(size_t index, TValue);
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename T>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<T>::value, bool>::type set(
+      size_t index, const T &value) {
+    return set_impl<const T &>(index, value);
+  }
+  //
+  // bool add(size_t index, TValue);
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename T>
+  bool set(size_t index, const T *value) {
+    return set_impl<const T *>(index, value);
+  }
+  //
+  // bool set(size_t index, TValue value, uint8_t decimals);
+  // TValue = float, double
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                bool>::type
+  set(size_t index, T value, uint8_t decimals) {
+    return set_impl<const JsonVariant &>(index, JsonVariant(value, decimals));
+  }
+
+  // Gets the value at the specified index.
+  template <typename T>
+  typename Internals::JsonVariantAs<T>::type get(size_t index) const {
+    const_iterator it = begin() += index;
+    return it != end() ? it->as<T>() : Internals::JsonVariantDefault<T>::get();
+  }
+
+  // Check the type of the value at specified index.
+  template <typename T>
+  bool is(size_t index) const {
+    const_iterator it = begin() += index;
+    return it != end() ? it->is<T>() : false;
+  }
+
+  // Creates a JsonArray and adds a reference at the end of the array.
+  // It's a shortcut for JsonBuffer::createArray() and JsonArray::add()
+  JsonArray &createNestedArray();
+
+  // Creates a JsonObject and adds a reference at the end of the array.
+  // It's a shortcut for JsonBuffer::createObject() and JsonArray::add()
+  JsonObject &createNestedObject();
+
+  // Removes element at specified index.
+  void remove(size_t index) {
+    remove(begin() += index);
+  }
+  using Internals::List<JsonVariant>::remove;
+
+  // Returns a reference an invalid JsonArray.
+  // This object is meant to replace a NULL pointer.
+  // This is used when memory allocation or JSON parsing fail.
+  static JsonArray &invalid() {
+    static JsonArray instance(NULL);
+    return instance;
+  }
+
+  // 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->as<JsonArray>().copyTo(array[i++]);
+    }
+  }
+
+#if ARDUINOJSON_ENABLE_DEPRECATED
+  DEPRECATED("use remove() instead")
+  FORCE_INLINE void removeAt(size_t index) {
+    return remove(index);
+  }
+#endif
+
+ private:
+  template <typename TValueRef>
+  bool set_impl(size_t index, TValueRef value) {
+    iterator it = begin() += index;
+    if (it == end()) return false;
+    return Internals::ValueSetter<TValueRef>::set(_buffer, *it, value);
+  }
+
+  template <typename TValueRef>
+  bool add_impl(TValueRef value) {
+    iterator it = Internals::List<JsonVariant>::add();
+    if (it == end()) return false;
+    return Internals::ValueSetter<TValueRef>::set(_buffer, *it, value);
+  }
+};
+
+namespace Internals {
+template <>
+struct JsonVariantDefault<JsonArray> {
+  static JsonArray &get() {
+    return JsonArray::invalid();
+  }
+};
+}
+}

src/ArduinoJson/JsonArrayImpl.hpp

@@ -0,0 +1,29 @@
+// 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 "JsonArray.hpp"
+#include "JsonArraySubscript.hpp"
+#include "JsonObject.hpp"
+
+namespace ArduinoJson {
+
+inline JsonArray &JsonArray::createNestedArray() {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  add(array);
+  return array;
+}
+
+inline JsonObject &JsonArray::createNestedObject() {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  add(object);
+  return object;
+}
+}

src/ArduinoJson/JsonArraySubscript.hpp

@@ -0,0 +1,123 @@
+// 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 "JsonVariantBase.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+
+namespace ArduinoJson {
+class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
+ public:
+  FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
+      : _array(array), _index(index) {}
+
+  FORCE_INLINE JsonArraySubscript& operator=(const JsonArraySubscript& src) {
+    _array.set(_index, src);
+    return *this;
+  }
+
+  // Replaces the value
+  //
+  // operator=(TValue)
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename T>
+  FORCE_INLINE JsonArraySubscript& operator=(const T& src) {
+    _array.set(_index, src);
+    return *this;
+  }
+  //
+  // operator=(TValue)
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename T>
+  FORCE_INLINE JsonArraySubscript& operator=(const T* src) {
+    _array.set(_index, src);
+    return *this;
+  }
+
+  FORCE_INLINE bool success() const {
+    return _index < _array.size();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename Internals::JsonVariantAs<T>::type as() const {
+    return _array.get<T>(_index);
+  }
+
+  template <typename T>
+  FORCE_INLINE bool is() const {
+    return _array.is<T>(_index);
+  }
+
+  // Replaces the value
+  //
+  // bool set(TValue)
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue>
+  FORCE_INLINE bool set(const TValue& value) {
+    return _array.set(_index, value);
+  }
+  //
+  // bool set(TValue)
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename TValue>
+  FORCE_INLINE bool set(const TValue* value) {
+    return _array.set(_index, value);
+  }
+  //
+  // bool set(TValue, uint8_t decimals);
+  // TValue = float, double
+  template <typename TValue>
+  FORCE_INLINE bool set(const TValue& value, uint8_t decimals) {
+    return _array.set(_index, value, decimals);
+  }
+
+ private:
+  JsonArray& _array;
+  const size_t _index;
+};
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream& operator<<(std::ostream& os,
+                                const JsonArraySubscript& source) {
+  return source.printTo(os);
+}
+#endif
+
+inline JsonArraySubscript JsonArray::operator[](size_t index) {
+  return JsonArraySubscript(*this, index);
+}
+
+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 TImplem>
+inline const JsonArraySubscript JsonVariantBase<TImplem>::operator[](
+    int index) const {
+  return as<JsonArray>()[index];
+}
+
+}  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

src/ArduinoJson/JsonBuffer.hpp

@@ -0,0 +1,97 @@
+// 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 <stddef.h>  // for size_t
+#include <stdint.h>  // for uint8_t
+#include <string.h>
+
+#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;
+
+// Entry point for using the library.
+//
+// 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 {
+ 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
+  // allocation fails.
+  JsonArray &createArray();
+
+  // Allocates an empty JsonObject.
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  JsonObject &createObject();
+
+  // Duplicates a string
+  //
+  // char* strdup(TValue);
+  // TValue = const std::string&, const String&,
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                char *>::type
+  strdup(const TString &src) {
+    return Internals::StringTraits<TString>::duplicate(src, this);
+  }
+  //
+  // char* strdup(TValue);
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  char *strdup(const TString *src) {
+    return Internals::StringTraits<const TString *>::duplicate(src, this);
+  }
+
+  // Allocates n bytes in the JsonBuffer.
+  // Return a pointer to the allocated memory or NULL if allocation fails.
+  virtual void *alloc(size_t size) = 0;
+
+ protected:
+  // Preserve aligment if necessary
+  static FORCE_INLINE size_t round_size_up(size_t bytes) {
+#if ARDUINOJSON_ENABLE_ALIGNMENT
+    const size_t x = sizeof(void *) - 1;
+    return (bytes + x) & ~x;
+#else
+    return bytes;
+#endif
+  }
+};
+}
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic pop
+#endif
+#endif

src/ArduinoJson/JsonBufferBase.hpp

@@ -0,0 +1,143 @@
+// 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 "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 {
+ public:
+  // Allocates and populate a JsonArray from a JSON string.
+  //
+  // The First argument is a pointer to the JSON string, the memory must be
+  // writable
+  // because the parser will insert null-terminators and replace escaped chars.
+  //
+  // The second argument set the nesting limit
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  // With this overload, the JsonBuffer will make a copy of the string
+  //
+  // JsonArray& parseArray(TString);
+  // TString = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                JsonArray &>::type
+  parseArray(const TString &json,
+             uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseArray();
+  }
+  //
+  // JsonArray& parseArray(TString);
+  // TString = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonArray &parseArray(
+      TString *json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseArray();
+  }
+  //
+  // JsonArray& parseArray(TString);
+  // TString = std::istream&, Stream&
+  template <typename TString>
+  JsonArray &parseArray(
+      TString &json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseArray();
+  }
+
+  // Allocates and populate a JsonObject from a JSON string.
+  //
+  // The First argument is a pointer to the JSON string, the memory must be
+  // writable
+  // because the parser will insert null-terminators and replace escaped chars.
+  //
+  // The second argument set the nesting limit
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  //
+  // JsonObject& parseObject(TString);
+  // TString = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                JsonObject &>::type
+  parseObject(const TString &json,
+              uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseObject();
+  }
+  //
+  // JsonObject& parseObject(TString);
+  // TString = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonObject &parseObject(
+      TString *json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseObject();
+  }
+  //
+  // JsonObject& parseObject(TString);
+  // TString = std::istream&, Stream&
+  template <typename TString>
+  JsonObject &parseObject(
+      TString &json, uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseObject();
+  }
+
+  // Generalized version of parseArray() and parseObject(), also works for
+  // integral types.
+  //
+  // JsonVariant parse(TString);
+  // TString = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                JsonVariant>::type
+  parse(const TString &json,
+        uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseVariant();
+  }
+  //
+  // JsonVariant parse(TString);
+  // TString = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonVariant parse(TString *json,
+                    uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseVariant();
+  }
+  //
+  // JsonVariant parse(TString);
+  // TString = std::istream&, Stream&
+  template <typename TString>
+  JsonVariant parse(TString &json,
+                    uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
+    return Internals::makeParser(that(), json, nestingLimit).parseVariant();
+  }
+
+ 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

src/ArduinoJson/JsonBufferImpl.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 "Deserialization/JsonParser.hpp"
+
+inline ArduinoJson::JsonArray &ArduinoJson::JsonBuffer::createArray() {
+  JsonArray *ptr = new (this) JsonArray(this);
+  return ptr ? *ptr : JsonArray::invalid();
+}
+
+inline ArduinoJson::JsonObject &ArduinoJson::JsonBuffer::createObject() {
+  JsonObject *ptr = new (this) JsonObject(this);
+  return ptr ? *ptr : JsonObject::invalid();
+}

src/ArduinoJson/JsonObject.hpp

@@ -0,0 +1,347 @@
+// 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/JsonBufferAllocated.hpp"
+#include "Data/List.hpp"
+#include "Data/ReferenceType.hpp"
+#include "Data/ValueSetter.hpp"
+#include "JsonPair.hpp"
+#include "Serialization/JsonPrintable.hpp"
+#include "StringTraits/StringTraits.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsArray.hpp"
+#include "TypeTraits/IsFloatingPoint.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.
+#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
+  (sizeof(JsonObject) + (NUMBER_OF_ELEMENTS) * sizeof(JsonObject::node_type))
+
+namespace ArduinoJson {
+
+// Forward declarations
+class JsonArray;
+class JsonBuffer;
+
+// A dictionary of JsonVariant indexed by string (char*)
+//
+// The constructor is private, instances must be created via
+// JsonBuffer::createObject() or JsonBuffer::parseObject().
+// A JsonObject can be serialized to a JSON string via JsonObject::printTo().
+// It can also be deserialized from a JSON string via JsonBuffer::parseObject().
+class JsonObject : public Internals::JsonPrintable<JsonObject>,
+                   public Internals::ReferenceType,
+                   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) {}
+
+  // Gets or sets the value associated with the specified key.
+  //
+  // JsonObjectSubscript operator[](TKey)
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                JsonObjectSubscript<const TString&> >::type
+  operator[](const TString& key) {
+    return JsonObjectSubscript<const TString&>(*this, key);
+  }
+  //
+  // JsonObjectSubscript operator[](TKey)
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonObjectSubscript<const TString*> operator[](const TString* key) {
+    return JsonObjectSubscript<const TString*>(*this, key);
+  }
+
+  // Gets the value associated with the specified key.
+  //
+  // const JsonObjectSubscript operator[](TKey) const;
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<
+      !TypeTraits::IsArray<TString>::value,
+      const JsonObjectSubscript<const TString&> >::type
+  operator[](const TString& key) const {
+    return JsonObjectSubscript<const TString&>(*const_cast<JsonObject*>(this),
+                                               key);
+  }
+  //
+  // const JsonObjectSubscript operator[](TKey) const;
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  const JsonObjectSubscript<const TString*> operator[](
+      const TString* key) const {
+    return JsonObjectSubscript<const TString*>(*const_cast<JsonObject*>(this),
+                                               key);
+  }
+
+  // Sets the specified key with the specified value.
+  //
+  // bool set(TKey, TValue);
+  // TKey = const std::string&, const String&
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value &&
+                                    !TypeTraits::IsArray<TValue>::value,
+                                bool>::type
+  set(const TString& key, const TValue& value) {
+    return set_impl<const TString&, const TValue&>(key, value);
+  }
+  //
+  // bool set(TKey, TValue);
+  // TKey = const std::string&, const String&
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                bool>::type
+  set(const TString& key, const TValue* value) {
+    return set_impl<const TString&, const TValue*>(key, value);
+  }
+  //
+  // bool set(TKey, TValue);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  // TValue = bool, long, int, short, float, double, RawJson, JsonVariant,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TValue>::value, bool>::type
+  set(const TString* key, const TValue& value) {
+    return set_impl<const TString*, const TValue&>(key, value);
+  }
+  //
+  // bool set(TKey, TValue);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename TValue, typename TString>
+  bool set(const TString* key, const TValue* value) {
+    return set_impl<const TString*, const TValue*>(key, value);
+  }
+  //
+  // bool set(TKey, TValue, uint8_t decimals);
+  // TKey = const std::string&, const String&
+  // TValue = float, double
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<TValue>::value &&
+                                    !TypeTraits::IsArray<TString>::value,
+                                bool>::type
+  set(const TString& key, TValue value, uint8_t decimals) {
+    return set_impl<const TString&, const JsonVariant&>(
+        key, JsonVariant(value, decimals));
+  }
+  //
+  // bool set(TKey, TValue, uint8_t decimals);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  // TValue = float, double
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<TValue>::value,
+                                bool>::type
+  set(const TString* key, TValue value, uint8_t decimals) {
+    return set_impl<const TString*, const JsonVariant&>(
+        key, JsonVariant(value, decimals));
+  }
+
+  // Gets the value associated with the specified key.
+  //
+  // TValue get<TValue>(TKey);
+  // TKey = const std::string&, const String&
+  // TValue = bool, char, long, int, short, float, double,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<
+      !TypeTraits::IsArray<TString>::value,
+      typename Internals::JsonVariantAs<TValue>::type>::type
+  get(const TString& key) const {
+    return get_impl<const TString&, TValue>(key);
+  }
+  //
+  // TValue get<TValue>(TKey);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  // TValue = bool, char, long, int, short, float, double,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue, typename TString>
+  typename Internals::JsonVariantAs<TValue>::type get(
+      const TString* key) const {
+    return get_impl<const TString*, TValue>(key);
+  }
+
+  // Checks the type of the value associated with the specified key.
+  //
+  //
+  // bool is<TValue>(TKey) const;
+  // TKey = const std::string&, const String&
+  // TValue = bool, char, long, int, short, float, double,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue, typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                bool>::type
+  is(const TString& key) const {
+    return is_impl<const TString&, TValue>(key);
+  }
+  //
+  // bool is<TValue>(TKey) const;
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  // TValue = bool, char, long, int, short, float, double,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue, typename TString>
+  bool is(const TString* key) const {
+    return is_impl<const TString*, TValue>(key);
+  }
+
+  // Creates and adds a JsonArray.
+  //
+  // JsonArray& createNestedArray(TKey);
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                JsonArray&>::type
+  createNestedArray(const TString& key) {
+    return createNestedArray_impl<const TString&>(key);
+  }
+  // JsonArray& createNestedArray(TKey);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonArray& createNestedArray(const TString* key) {
+    return createNestedArray_impl<const TString*>(key);
+  }
+
+  // Creates and adds a JsonObject.
+  //
+  // JsonObject& createNestedObject(TKey);
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                JsonObject&>::type
+  createNestedObject(const TString& key) {
+    return createNestedObject_impl<const TString&>(key);
+  }
+  //
+  // JsonObject& createNestedObject(TKey);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  JsonObject& createNestedObject(const TString* key) {
+    return createNestedObject_impl<const TString*>(key);
+  }
+
+  // Tells weither the specified key is present and associated with a value.
+  //
+  // bool containsKey(TKey);
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                bool>::type
+  containsKey(const TString& key) const {
+    return findKey<const TString&>(key) != end();
+  }
+  //
+  // bool containsKey(TKey);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  bool containsKey(const TString* key) const {
+    return findKey<const TString*>(key) != end();
+  }
+
+  // Removes the specified key and the associated value.
+  //
+  // void remove(TKey);
+  // TKey = const std::string&, const String&
+  template <typename TString>
+  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
+                                void>::type
+  remove(const TString& key) {
+    remove(findKey<const TString&>(key));
+  }
+  //
+  // void remove(TKey);
+  // TKey = const char*, const char[N], const FlashStringHelper*
+  template <typename TString>
+  void remove(const TString* key) {
+    remove(findKey<const TString*>(key));
+  }
+  //
+  // void remove(iterator)
+  using Internals::List<JsonPair>::remove;
+
+  // Returns a reference an invalid JsonObject.
+  // This object is meant to replace a NULL pointer.
+  // This is used when memory allocation or JSON parsing fail.
+  static JsonObject& invalid() {
+    static JsonObject instance(NULL);
+    return instance;
+  }
+
+ private:
+  // Returns the list node that matches the specified key.
+  template <typename TStringRef>
+  iterator findKey(TStringRef key) {
+    iterator it;
+    for (it = begin(); it != end(); ++it) {
+      if (Internals::StringTraits<TStringRef>::equals(key, it->key)) break;
+    }
+    return it;
+  }
+  template <typename TStringRef>
+  const_iterator findKey(TStringRef key) const {
+    return const_cast<JsonObject*>(this)->findKey<TStringRef>(key);
+  }
+
+  template <typename TStringRef, typename TValue>
+  typename Internals::JsonVariantAs<TValue>::type get_impl(
+      TStringRef key) const {
+    const_iterator it = findKey<TStringRef>(key);
+    return it != end() ? it->value.as<TValue>()
+                       : Internals::JsonVariantDefault<TValue>::get();
+  }
+
+  template <typename TStringRef, typename TValueRef>
+  bool set_impl(TStringRef key, TValueRef value) {
+    iterator it = findKey<TStringRef>(key);
+    if (it == end()) {
+      it = Internals::List<JsonPair>::add();
+      if (it == end()) return false;
+
+      bool key_ok =
+          Internals::ValueSetter<TStringRef>::set(_buffer, it->key, key);
+      if (!key_ok) return false;
+    }
+    return Internals::ValueSetter<TValueRef>::set(_buffer, it->value, value);
+  }
+
+  template <typename TStringRef, typename TValue>
+  bool is_impl(TStringRef key) const {
+    const_iterator it = findKey<TStringRef>(key);
+    return it != end() ? it->value.is<TValue>() : false;
+  }
+
+  template <typename TStringRef>
+  JsonArray& createNestedArray_impl(TStringRef key);
+
+  template <typename TStringRef>
+  JsonObject& createNestedObject_impl(TStringRef key);
+};
+
+namespace Internals {
+template <>
+struct JsonVariantDefault<JsonObject> {
+  static JsonObject& get() {
+    return JsonObject::invalid();
+  }
+};
+}
+}

src/ArduinoJson/JsonObjectImpl.hpp

@@ -0,0 +1,31 @@
+// 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 "JsonArray.hpp"
+#include "JsonObject.hpp"
+#include "JsonObjectSubscript.hpp"
+
+namespace ArduinoJson {
+
+template <typename TStringRef>
+inline JsonArray &JsonObject::createNestedArray_impl(TStringRef key) {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  set(key, array);
+  return array;
+}
+
+template <typename TStringRef>
+inline JsonObject &JsonObject::createNestedObject_impl(TStringRef key) {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  set(key, object);
+  return object;
+}
+}

src/ArduinoJson/JsonObjectSubscript.hpp

@@ -0,0 +1,116 @@
+// 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 "JsonVariantBase.hpp"
+#include "TypeTraits/EnableIf.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+
+namespace ArduinoJson {
+
+template <typename TStringRef>
+class JsonObjectSubscript
+    : public JsonVariantBase<JsonObjectSubscript<TStringRef> > {
+  typedef JsonObjectSubscript<TStringRef> this_type;
+
+ public:
+  FORCE_INLINE JsonObjectSubscript(JsonObject& object, TStringRef key)
+      : _object(object), _key(key) {}
+
+  FORCE_INLINE this_type& operator=(const this_type& src) {
+    _object.set(_key, src);
+    return *this;
+  }
+
+  // Set the specified value
+  //
+  // operator=(TValue);
+  // TValue = bool, char, long, int, short, float, double,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue>
+  FORCE_INLINE
+      typename TypeTraits::EnableIf<!TypeTraits::IsArray<TValue>::value,
+                                    this_type&>::type
+      operator=(const TValue& src) {
+    _object.set(_key, src);
+    return *this;
+  }
+  //
+  // operator=(TValue);
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename TValue>
+  FORCE_INLINE this_type& operator=(const TValue* src) {
+    _object.set(_key, src);
+    return *this;
+  }
+
+  FORCE_INLINE bool success() const {
+    return _object.containsKey(_key);
+  }
+
+  template <typename TValue>
+  FORCE_INLINE typename Internals::JsonVariantAs<TValue>::type as() const {
+    return _object.get<TValue>(_key);
+  }
+
+  template <typename TValue>
+  FORCE_INLINE bool is() const {
+    return _object.is<TValue>(_key);
+  }
+
+  // Sets the specified value.
+  //
+  // bool set(TValue);
+  // TValue = bool, char, long, int, short, float, double, RawJson, JsonVariant,
+  //          const std::string&, const String&,
+  //          const JsonArray&, const JsonObject&
+  template <typename TValue>
+  FORCE_INLINE
+      typename TypeTraits::EnableIf<!TypeTraits::IsArray<TValue>::value,
+                                    bool>::type
+      set(const TValue& value) {
+    return _object.set(_key, value);
+  }
+  //
+  // bool set(TValue);
+  // TValue = const char*, const char[N], const FlashStringHelper*
+  template <typename TValue>
+  FORCE_INLINE bool set(const TValue* value) {
+    return _object.set(_key, value);
+  }
+  //
+  // bool set(TValue, uint8_t decimals);
+  // TValue = float, double
+  template <typename TValue>
+  FORCE_INLINE bool set(const TValue& value, uint8_t decimals) {
+    return _object.set(_key, value, decimals);
+  }
+
+ private:
+  JsonObject& _object;
+  TStringRef _key;
+};
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+template <typename TStringRef>
+inline std::ostream& operator<<(std::ostream& os,
+                                const JsonObjectSubscript<TStringRef>& source) {
+  return source.printTo(os);
+}
+#endif
+}  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

src/ArduinoJson/JsonPair.hpp

@@ -0,0 +1,19 @@
+// 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 "JsonVariant.hpp"
+
+namespace ArduinoJson {
+
+// A key value pair for JsonObject.
+struct JsonPair {
+  const char* key;
+  JsonVariant value;
+};
+}

src/ArduinoJson/JsonVariant.hpp

@@ -0,0 +1,352 @@
+// 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 <stddef.h>
+#include <stdint.h>  // for uint8_t
+
+#include "Data/JsonVariantContent.hpp"
+#include "Data/JsonVariantDefault.hpp"
+#include "Data/JsonVariantType.hpp"
+#include "JsonVariantBase.hpp"
+#include "RawJson.hpp"
+#include "Serialization/JsonPrintable.hpp"
+#include "TypeTraits/EnableIf.hpp"
+#include "TypeTraits/IsChar.hpp"
+#include "TypeTraits/IsFloatingPoint.hpp"
+#include "TypeTraits/IsIntegral.hpp"
+#include "TypeTraits/IsSame.hpp"
+#include "TypeTraits/IsSignedIntegral.hpp"
+#include "TypeTraits/IsUnsignedIntegral.hpp"
+#include "TypeTraits/RemoveConst.hpp"
+#include "TypeTraits/RemoveReference.hpp"
+
+namespace ArduinoJson {
+
+// Forward declarations.
+class JsonArray;
+class JsonObject;
+
+// A variant that can be a any value serializable to a JSON value.
+//
+// It can be set to:
+// - a boolean
+// - a char, short, int or a long (signed or unsigned)
+// - a string (const char*)
+// - a reference to a JsonArray or JsonObject
+class JsonVariant : public JsonVariantBase<JsonVariant> {
+  friend void Internals::JsonSerializer::serialize(const JsonVariant &,
+                                                   JsonWriter &);
+
+ public:
+  // Creates an uninitialized JsonVariant
+  JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
+
+  // Create a JsonVariant containing a boolean value.
+  // It will be serialized as "true" or "false" in JSON.
+  JsonVariant(bool value) {
+    using namespace Internals;
+    _type = JSON_BOOLEAN;
+    _content.asInteger = static_cast<JsonInteger>(value);
+  }
+
+  // Create a JsonVariant containing a floating point value.
+  // The second argument specifies the number of decimal digits to write in
+  // the JSON string.
+  // JsonVariant(double value, uint8_t decimals);
+  // JsonVariant(float value, uint8_t decimals);
+  template <typename T>
+  JsonVariant(T value, uint8_t decimals = 2,
+              typename TypeTraits::EnableIf<
+                  TypeTraits::IsFloatingPoint<T>::value>::type * = 0) {
+    using namespace Internals;
+    _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
+    _content.asFloat = static_cast<JsonFloat>(value);
+  }
+
+  // Create a JsonVariant containing an integer value.
+  // JsonVariant(char)
+  // JsonVariant(signed short)
+  // JsonVariant(signed int)
+  // JsonVariant(signed long)
+  // JsonVariant(signed char)
+  template <typename T>
+  JsonVariant(T value, typename TypeTraits::EnableIf<
+                           TypeTraits::IsSignedIntegral<T>::value ||
+                           TypeTraits::IsSame<T, char>::value>::type * = 0) {
+    using namespace Internals;
+    if (value >= 0) {
+      _type = JSON_POSITIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(value);
+    } else {
+      _type = JSON_NEGATIVE_INTEGER;
+      _content.asInteger = static_cast<JsonUInt>(-value);
+    }
+  }
+  // JsonVariant(unsigned short)
+  // JsonVariant(unsigned int)
+  // JsonVariant(unsigned long)
+  template <typename T>
+  JsonVariant(T value,
+              typename TypeTraits::EnableIf<
+                  TypeTraits::IsUnsignedIntegral<T>::value>::type * = 0) {
+    using namespace Internals;
+    _type = JSON_POSITIVE_INTEGER;
+    _content.asInteger = static_cast<JsonUInt>(value);
+  }
+
+  // Create a JsonVariant containing a string.
+  // JsonVariant(const char*);
+  // JsonVariant(const signed char*);
+  // JsonVariant(const unsigned char*);
+  template <typename TChar>
+  JsonVariant(
+      const TChar *value,
+      typename TypeTraits::EnableIf<TypeTraits::IsChar<TChar>::value>::type * =
+          0) {
+    _type = Internals::JSON_STRING;
+    _content.asString = reinterpret_cast<const char *>(value);
+  }
+
+  // Create a JsonVariant containing an unparsed string
+  JsonVariant(RawJson value) {
+    _type = Internals::JSON_UNPARSED;
+    _content.asString = value;
+  }
+
+  // Create a JsonVariant containing a reference to an array.
+  // CAUTION: we are lying about constness, because the array can be modified if
+  // the variant is converted back to a JsonArray&
+  JsonVariant(const JsonArray &array);
+
+  // Create a JsonVariant containing a reference to an object.
+  // CAUTION: we are lying about constness, because the object can be modified
+  // if the variant is converted back to a JsonObject&
+  JsonVariant(const JsonObject &object);
+
+  // Get the variant as the specified type.
+  //
+  // char as<char>() const;
+  // signed char as<signed char>() const;
+  // signed short as<signed short>() const;
+  // signed int as<signed int>() const;
+  // signed long as<signed long>() const;
+  // unsigned char as<unsigned char>() const;
+  // unsigned short as<unsigned short>() const;
+  // unsigned int as<unsigned int>() const;
+  // unsigned long as<unsigned long>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value, T>::type
+  as() const {
+    return variantAsInteger<T>();
+  }
+  // bool as<bool>() const
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
+                                      T>::type
+  as() const {
+    return variantAsInteger<int>() != 0;
+  }
+  //
+  // double as<double>() const;
+  // float as<float>() const;
+  template <typename T>
+  const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                      T>::type
+  as() const {
+    return variantAsFloat<T>();
+  }
+  //
+  // const char* as<const char*>() const;
+  // const char* as<char*>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
+                                    TypeTraits::IsSame<T, char *>::value,
+                                const char *>::type
+  as() const {
+    return variantAsString();
+  }
+  //
+  // std::string as<std::string>() const;
+  // String as<String>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<Internals::StringTraits<T>::has_append, T>::type
+  as() const {
+    const char *cstr = variantAsString();
+    if (cstr) return T(cstr);
+    T s;
+    printTo(s);
+    return s;
+  }
+  //
+  // JsonArray& as<JsonArray> const;
+  // JsonArray& as<JsonArray&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
+                         JsonArray>::value,
+      JsonArray &>::type
+  as() const {
+    return variantAsArray();
+  }
+  //
+  // const JsonArray& as<const JsonArray&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
+                         const JsonArray>::value,
+      const JsonArray &>::type
+  as() const {
+    return variantAsArray();
+  }
+  //
+  // JsonObject& as<JsonObject> const;
+  // JsonObject& as<JsonObject&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
+                         JsonObject>::value,
+      JsonObject &>::type
+  as() const {
+    return variantAsObject();
+  }
+  //
+  // JsonObject& as<const JsonObject> const;
+  // JsonObject& as<const JsonObject&> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<
+      TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
+                         const JsonObject>::value,
+      const JsonObject &>::type
+  as() const {
+    return variantAsObject();
+  }
+  //
+  // JsonVariant as<JsonVariant> const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, JsonVariant>::value,
+                                T>::type
+  as() const {
+    return *this;
+  }
+
+  // Tells weither the variant has the specified type.
+  // Returns true if the variant has type type T, false otherwise.
+  //
+  // bool is<char>() const;
+  // bool is<signed char>() const;
+  // bool is<signed short>() const;
+  // bool is<signed int>() const;
+  // bool is<signed long>() const;
+  // bool is<unsigned char>() const;
+  // bool is<unsigned short>() const;
+  // bool is<unsigned int>() const;
+  // bool is<unsigned long>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value, bool>::type
+  is() const {
+    return variantIsInteger();
+  }
+  //
+  // bool is<double>() const;
+  // bool is<float>() const;
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                bool>::type
+  is() const {
+    return variantIsFloat();
+  }
+  //
+  // bool is<bool>() const
+  template <typename T>
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value, bool>::type
+  is() const {
+    return variantIsBoolean();
+  }
+  //
+  // 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 variantIsString();
+  }
+  //
+  // 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 variantIsArray();
+  }
+  //
+  // bool is<JsonObject> const;
+  // bool is<JsonObject&> const;
+  // bool is<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 variantIsObject();
+  }
+
+  // Returns true if the variant has a value
+  bool success() const {
+    return _type != Internals::JSON_UNDEFINED;
+  }
+
+ private:
+  JsonArray &variantAsArray() const;
+  JsonObject &variantAsObject() const;
+  const char *variantAsString() const;
+  template <typename T>
+  T variantAsFloat() const;
+  template <typename T>
+  T variantAsInteger() const;
+  bool variantIsBoolean() const;
+  bool variantIsFloat() const;
+  bool variantIsInteger() const;
+  bool variantIsArray() const {
+    return _type == Internals::JSON_ARRAY;
+  }
+  bool variantIsObject() const {
+    return _type == Internals::JSON_OBJECT;
+  }
+  bool variantIsString() const {
+    return _type == Internals::JSON_STRING ||
+           (_type == Internals::JSON_UNPARSED && _content.asString &&
+            !strcmp("null", _content.asString));
+  }
+
+  // The current type of the variant
+  Internals::JsonVariantType _type;
+
+  // The various alternatives for the value of the variant.
+  Internals::JsonVariantContent _content;
+};
+
+inline JsonVariant float_with_n_digits(float value, uint8_t digits) {
+  return JsonVariant(value, digits);
+}
+
+inline JsonVariant double_with_n_digits(double value, uint8_t digits) {
+  return JsonVariant(value, digits);
+}
+}

src/ArduinoJson/JsonVariantBase.hpp

@@ -0,0 +1,139 @@
+// 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 "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> {};
+}
+}

src/ArduinoJson/JsonVariantComparisons.hpp

@@ -0,0 +1,88 @@
+// 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/JsonVariantComparer.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 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 TVariant, typename TComparand>
+inline bool operator<=(const JsonVariantBase<TVariant> &left,
+                       TComparand right) {
+  return left.template as<TComparand>() <= right;
+}
+
+template <typename TVariant, typename TComparand>
+inline bool operator<=(TComparand comparand,
+                       const JsonVariantBase<TVariant> &variant) {
+  return comparand <= variant.template as<TComparand>();
+}
+
+template <typename TVariant, typename TComparand>
+inline bool operator>=(const JsonVariantBase<TVariant> &variant,
+                       TComparand comparand) {
+  return variant.template as<TComparand>() >= comparand;
+}
+
+template <typename TVariant, typename TComparand>
+inline bool operator>=(TComparand comparand,
+                       const JsonVariantBase<TVariant> &variant) {
+  return comparand >= variant.template as<TComparand>();
+}
+
+template <typename TVariant, typename TComparand>
+inline bool operator<(const JsonVariantBase<TVariant> &varian,
+                      TComparand comparand) {
+  return varian.template as<TComparand>() < comparand;
+}
+
+template <typename TVariant, typename TComparand>
+inline bool operator<(TComparand comparand,
+                      const JsonVariantBase<TVariant> &variant) {
+  return comparand < variant.template as<TComparand>();
+}
+
+template <typename TVariant, typename TComparand>
+inline bool operator>(const JsonVariantBase<TVariant> &variant,
+                      TComparand comparand) {
+  return variant.template as<TComparand>() > comparand;
+}
+
+template <typename TVariant, typename TComparand>
+inline bool operator>(TComparand comparand,
+                      const JsonVariantBase<TVariant> &variant) {
+  return comparand > variant.template as<TComparand>();
+}
+}

src/ArduinoJson/JsonVariantImpl.hpp

@@ -0,0 +1,130 @@
+// 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 "JsonArray.hpp"
+#include "JsonObject.hpp"
+#include "JsonVariant.hpp"
+#include "Polyfills/isFloat.hpp"
+#include "Polyfills/isInteger.hpp"
+#include "Polyfills/parseFloat.hpp"
+#include "Polyfills/parseInteger.hpp"
+
+#include <string.h>  // for strcmp
+
+namespace ArduinoJson {
+
+inline JsonVariant::JsonVariant(const JsonArray &array) {
+  if (array.success()) {
+    _type = Internals::JSON_ARRAY;
+    _content.asArray = const_cast<JsonArray *>(&array);
+  } else {
+    _type = Internals::JSON_UNDEFINED;
+  }
+}
+
+inline JsonVariant::JsonVariant(const JsonObject &object) {
+  if (object.success()) {
+    _type = Internals::JSON_OBJECT;
+    _content.asObject = const_cast<JsonObject *>(&object);
+  } else {
+    _type = Internals::JSON_UNDEFINED;
+  }
+}
+
+inline JsonArray &JsonVariant::variantAsArray() const {
+  if (_type == Internals::JSON_ARRAY) return *_content.asArray;
+  return JsonArray::invalid();
+}
+
+inline JsonObject &JsonVariant::variantAsObject() const {
+  if (_type == Internals::JSON_OBJECT) return *_content.asObject;
+  return JsonObject::invalid();
+}
+
+template <typename T>
+inline T JsonVariant::variantAsInteger() const {
+  using namespace Internals;
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return 0;
+    case JSON_POSITIVE_INTEGER:
+    case JSON_BOOLEAN:
+      return static_cast<T>(_content.asInteger);
+    case JSON_NEGATIVE_INTEGER:
+      return static_cast<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);
+  }
+}
+
+inline const char *JsonVariant::variantAsString() const {
+  using namespace Internals;
+  if (_type == JSON_UNPARSED && _content.asString &&
+      !strcmp("null", _content.asString))
+    return NULL;
+  if (_type == JSON_STRING || _type == JSON_UNPARSED) return _content.asString;
+  return NULL;
+}
+
+template <typename T>
+inline T JsonVariant::variantAsFloat() const {
+  using namespace Internals;
+  switch (_type) {
+    case JSON_UNDEFINED:
+      return 0;
+    case JSON_POSITIVE_INTEGER:
+    case JSON_BOOLEAN:
+      return static_cast<T>(_content.asInteger);
+    case JSON_NEGATIVE_INTEGER:
+      return -static_cast<T>(_content.asInteger);
+    case JSON_STRING:
+    case JSON_UNPARSED:
+      return Polyfills::parseFloat<T>(_content.asString);
+    default:
+      return static_cast<T>(_content.asFloat);
+  }
+}
+
+inline bool JsonVariant::variantIsBoolean() const {
+  using namespace Internals;
+  if (_type == JSON_BOOLEAN) return true;
+
+  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
+
+  return !strcmp(_content.asString, "true") ||
+         !strcmp(_content.asString, "false");
+}
+
+inline bool JsonVariant::variantIsInteger() const {
+  using namespace Internals;
+
+  return _type == JSON_POSITIVE_INTEGER || _type == JSON_NEGATIVE_INTEGER ||
+         (_type == JSON_UNPARSED && Polyfills::isInteger(_content.asString));
+}
+
+inline bool JsonVariant::variantIsFloat() const {
+  using namespace Internals;
+
+  return _type >= JSON_FLOAT_0_DECIMALS ||
+         (_type == JSON_UNPARSED && Polyfills::isFloat(_content.asString));
+}
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream &operator<<(std::ostream &os, const JsonVariant &source) {
+  return source.printTo(os);
+}
+#endif
+
+}  // namespace ArduinoJson

src/ArduinoJson/Polyfills/attributes.hpp

@@ -0,0 +1,22 @@
+// 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
+
+#ifdef _MSC_VER
+#define FORCE_INLINE __forceinline
+#define NO_INLINE __declspec(noinline)
+#define DEPRECATED(msg) __declspec(deprecated(msg))
+#else
+#define FORCE_INLINE __attribute__((always_inline))
+#define NO_INLINE __attribute__((noinline))
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#define DEPRECATED(msg) __attribute__((deprecated(msg)))
+#else
+#define DEPRECATED(msg) __attribute__((deprecated))
+#endif
+#endif

src/ArduinoJson/Polyfills/ctype.hpp

@@ -0,0 +1,21 @@
+// 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 Polyfills {
+
+inline bool isdigit(char c) {
+  return '0' <= c && c <= '9';
+}
+
+inline bool issign(char c) {
+  return '-' == c || c == '+';
+}
+}
+}

src/ArduinoJson/Polyfills/isFloat.hpp

@@ -0,0 +1,42 @@
+// 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 <string.h>  // for strcmp
+#include "./ctype.hpp"
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+inline bool isFloat(const char* s) {
+  if (!s) return false;
+
+  if (!strcmp(s, "NaN")) return true;
+  if (issign(*s)) s++;
+  if (!strcmp(s, "Infinity")) return true;
+
+  while (isdigit(*s)) s++;
+
+  bool has_dot = *s == '.';
+  if (has_dot) {
+    s++;
+    while (isdigit(*s)) s++;
+  }
+
+  bool has_exponent = *s == 'e' || *s == 'E';
+  if (has_exponent) {
+    s++;
+    if (issign(*s)) s++;
+    if (!isdigit(*s)) return false;
+    while (isdigit(*s)) s++;
+  }
+
+  return (has_dot || has_exponent) && *s == '\0';
+}
+}
+}

src/ArduinoJson/Polyfills/isInteger.hpp

@@ -0,0 +1,22 @@
+// 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 "./ctype.hpp"
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+inline bool isInteger(const char* s) {
+  if (!s) return false;
+  if (issign(*s)) s++;
+  while (isdigit(*s)) s++;
+  return *s == '\0';
+}
+}
+}

src/ArduinoJson/Polyfills/math.hpp

@@ -0,0 +1,132 @@
+// 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
+
+// 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;
+}
+
+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();
+}
+}
+}
+
+#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

src/ArduinoJson/Polyfills/normalize.hpp

@@ -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!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+#ifdef ARDUINO
+
+// on embedded platform, favor code size over speed
+
+template <typename T>
+short normalize(T& value) {
+  short powersOf10 = 0;
+  while (value && value < 1) {
+    powersOf10--;
+    value *= 10;
+  }
+  while (value > 10) {
+    powersOf10++;
+    value /= 10;
+  }
+  return powersOf10;
+}
+
+#else
+
+// on non-embedded platform, favor speed over code size
+
+template <typename T>
+short normalize(T& value) {
+  if (value == 0.0) return 0;
+
+  short powersOf10 = static_cast<short>(floor(log10(value)));
+  value /= pow(T(10), powersOf10);
+
+  return powersOf10;
+}
+
+#endif
+}
+}

src/ArduinoJson/Polyfills/parseFloat.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 "../TypeTraits/FloatTraits.hpp"
+#include "./ctype.hpp"
+#include "./math.hpp"
+
+namespace ArduinoJson {
+namespace Polyfills {
+
+template <typename T>
+inline T parseFloat(const char* s) {
+  typedef TypeTraits::FloatTraits<T> traits;
+  typedef typename traits::mantissa_type mantissa_t;
+  typedef typename traits::exponent_type exponent_t;
+
+  if (!s) return 0;
+
+  bool negative_result = false;
+  switch (*s) {
+    case '-':
+      negative_result = true;
+    case '+':
+      s++;
+  }
+
+  if (*s == 'n' || *s == 'N') return traits::nan();
+  if (*s == 'i' || *s == 'I')
+    return negative_result ? -traits::inf() : traits::inf();
+
+  mantissa_t mantissa = 0;
+  exponent_t exponent_offset = 0;
+
+  while (isdigit(*s)) {
+    if (mantissa < traits::mantissa_max / 10)
+      mantissa = mantissa * 10 + (*s - '0');
+    else
+      exponent_offset++;
+    s++;
+  }
+
+  if (*s == '.') {
+    s++;
+    while (isdigit(*s)) {
+      if (mantissa < traits::mantissa_max / 10) {
+        mantissa = mantissa * 10 + (*s - '0');
+        exponent_offset--;
+      }
+      s++;
+    }
+  }
+
+  int exponent = 0;
+  if (*s == 'e' || *s == 'E') {
+    s++;
+    bool negative_exponent = false;
+    if (*s == '-') {
+      negative_exponent = true;
+      s++;
+    } else if (*s == '+') {
+      s++;
+    }
+
+    while (isdigit(*s)) {
+      exponent = exponent * 10 + (*s - '0');
+      if (exponent + exponent_offset > traits::exponent_max) {
+        if (negative_exponent)
+          return negative_result ? -0.0f : 0.0f;
+        else
+          return negative_result ? -traits::inf() : traits::inf();
+      }
+      s++;
+    }
+    if (negative_exponent) exponent = -exponent;
+  }
+  exponent += exponent_offset;
+
+  T result = traits::make_float(static_cast<T>(mantissa), exponent);
+
+  return negative_result ? -result : result;
+}
+}
+}

src/ArduinoJson/Polyfills/parseInteger.hpp

@@ -0,0 +1,40 @@
+// 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 <stdlib.h>
+
+#include "../Configuration.hpp"
+#include "./ctype.hpp"
+
+namespace ArduinoJson {
+namespace Polyfills {
+template <typename T>
+T parseInteger(const char *s) {
+  if (!s) return 0;
+
+  T result = 0;
+  bool negative_result = false;
+
+  switch (*s) {
+    case '-':
+      negative_result = true;
+    case '+':
+      s++;
+      break;
+  }
+
+  while (isdigit(*s)) {
+    result = static_cast<T>(result * 10 + (*s - '0'));
+    s++;
+  }
+
+  return negative_result ? static_cast<T>(result * -1) : result;
+}
+}
+}

src/ArduinoJson/Print.hpp

@@ -0,0 +1,44 @@
+// 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
+
+#ifndef ARDUINO
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace ArduinoJson {
+// This class reproduces Arduino's Print class
+class Print {
+ public:
+  virtual ~Print() {}
+
+  virtual size_t write(uint8_t) = 0;
+
+  size_t print(const char* s) {
+    size_t n = 0;
+    while (*s) {
+      n += write(static_cast<uint8_t>(*s++));
+    }
+    return n;
+  }
+
+  size_t println() {
+    size_t n = 0;
+    n += write('\r');
+    n += write('\n');
+    return n;
+  }
+};
+}
+
+#else
+
+#include <Print.h>
+
+#endif

src/ArduinoJson/RawJson.hpp

@@ -0,0 +1,23 @@
+// 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 {
+
+// A special type of data that can be used to insert pregenerated JSON portions.
+class RawJson {
+ public:
+  explicit RawJson(const char* str) : _str(str) {}
+  operator const char*() const {
+    return _str;
+  }
+
+ private:
+  const char* _str;
+};
+}

src/ArduinoJson/Serialization/DummyPrint.hpp

@@ -0,0 +1,23 @@
+// 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 "../Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A dummy Print implementation used in JsonPrintable::measureLength()
+class DummyPrint : public Print {
+ public:
+  virtual size_t write(uint8_t) {
+    return 1;
+  }
+};
+}
+}

src/ArduinoJson/Serialization/DynamicStringBuilder.hpp

@@ -0,0 +1,33 @@
+// 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 "../Print.hpp"
+#include "../StringTraits/StringTraits.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A Print implementation that allows to write in a String
+template <typename TString>
+class DynamicStringBuilder : public Print {
+ public:
+  DynamicStringBuilder(TString &str) : _str(str) {}
+
+  virtual size_t write(uint8_t c) {
+    StringTraits<TString>::append(_str, static_cast<char>(c));
+    return 1;
+  }
+
+ private:
+  DynamicStringBuilder &operator=(const DynamicStringBuilder &);
+
+  TString &_str;
+};
+}
+}

src/ArduinoJson/Serialization/IndentedPrint.hpp

@@ -0,0 +1,65 @@
+// 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 "../Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Decorator on top of Print to allow indented output.
+// This class is used by JsonPrintable::prettyPrintTo() but can also be used
+// for your own purpose, like logging.
+class IndentedPrint : public Print {
+ public:
+  explicit IndentedPrint(Print &p) : sink(&p) {
+    level = 0;
+    tabSize = 2;
+    isNewLine = true;
+  }
+
+  virtual size_t write(uint8_t c) {
+    size_t n = 0;
+    if (isNewLine) n += writeTabs();
+    n += sink->write(c);
+    isNewLine = c == '\n';
+    return n;
+  }
+
+  // Adds one level of indentation
+  void indent() {
+    if (level < MAX_LEVEL) level++;
+  }
+
+  // Removes one level of indentation
+  void unindent() {
+    if (level > 0) level--;
+  }
+
+  // Set the number of space printed for each level of indentation
+  void setTabSize(uint8_t n) {
+    if (n < MAX_TAB_SIZE) tabSize = n & MAX_TAB_SIZE;
+  }
+
+ private:
+  Print *sink;
+  uint8_t level : 4;
+  uint8_t tabSize : 3;
+  bool isNewLine : 1;
+
+  size_t writeTabs() {
+    size_t n = 0;
+    for (int i = 0; i < level * tabSize; i++) n += sink->write(' ');
+    return n;
+  }
+
+  static const int MAX_LEVEL = 15;    // because it's only 4 bits
+  static const int MAX_TAB_SIZE = 7;  // because it's only 3 bits
+};
+}
+}

src/ArduinoJson/Serialization/JsonPrintable.hpp

@@ -0,0 +1,115 @@
+// 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 "../TypeTraits/EnableIf.hpp"
+#include "DummyPrint.hpp"
+#include "DynamicStringBuilder.hpp"
+#include "IndentedPrint.hpp"
+#include "JsonSerializer.hpp"
+#include "JsonWriter.hpp"
+#include "Prettyfier.hpp"
+#include "StaticStringBuilder.hpp"
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#include "StreamPrintAdapter.hpp"
+#endif
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Implements all the overloads of printTo() and prettyPrintTo()
+// Caution: this class use a template parameter to avoid virtual methods.
+// This is a bit curious but allows to reduce the size of JsonVariant, JsonArray
+// and JsonObject.
+template <typename T>
+class JsonPrintable {
+ public:
+  size_t printTo(Print &print) const {
+    JsonWriter writer(print);
+    JsonSerializer::serialize(downcast(), writer);
+    return writer.bytesWritten();
+  }
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+  std::ostream &printTo(std::ostream &os) const {
+    StreamPrintAdapter adapter(os);
+    printTo(adapter);
+    return os;
+  }
+#endif
+
+  size_t printTo(char *buffer, size_t bufferSize) const {
+    StaticStringBuilder sb(buffer, bufferSize);
+    return printTo(sb);
+  }
+
+  template <size_t N>
+  size_t printTo(char (&buffer)[N]) const {
+    return printTo(buffer, N);
+  }
+
+  template <typename TString>
+  typename TypeTraits::EnableIf<StringTraits<TString>::has_append, size_t>::type
+  printTo(TString &str) const {
+    DynamicStringBuilder<TString> sb(str);
+    return printTo(sb);
+  }
+
+  size_t prettyPrintTo(IndentedPrint &print) const {
+    Prettyfier p(print);
+    return printTo(p);
+  }
+
+  size_t prettyPrintTo(char *buffer, size_t bufferSize) const {
+    StaticStringBuilder sb(buffer, bufferSize);
+    return prettyPrintTo(sb);
+  }
+
+  template <size_t N>
+  size_t prettyPrintTo(char (&buffer)[N]) const {
+    return prettyPrintTo(buffer, N);
+  }
+
+  size_t prettyPrintTo(Print &print) const {
+    IndentedPrint indentedPrint = IndentedPrint(print);
+    return prettyPrintTo(indentedPrint);
+  }
+
+  template <typename TString>
+  typename TypeTraits::EnableIf<StringTraits<TString>::has_append, size_t>::type
+  prettyPrintTo(TString &str) const {
+    DynamicStringBuilder<TString> sb(str);
+    return prettyPrintTo(sb);
+  }
+
+  size_t measureLength() const {
+    DummyPrint dp;
+    return printTo(dp);
+  }
+
+  size_t measurePrettyLength() const {
+    DummyPrint dp;
+    return prettyPrintTo(dp);
+  }
+
+ private:
+  const T &downcast() const {
+    return *static_cast<const T *>(this);
+  }
+};
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+template <typename T>
+inline std::ostream &operator<<(std::ostream &os, const JsonPrintable<T> &v) {
+  return v.printTo(os);
+}
+#endif
+}
+}

src/ArduinoJson/Serialization/JsonSerializer.hpp

@@ -0,0 +1,33 @@
+// 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 "JsonWriter.hpp"
+
+namespace ArduinoJson {
+
+class JsonArray;
+class JsonArraySubscript;
+class JsonObject;
+template <typename TKey>
+class JsonObjectSubscript;
+class JsonVariant;
+
+namespace Internals {
+
+class JsonSerializer {
+ public:
+  static void serialize(const JsonArray &, JsonWriter &);
+  static void serialize(const JsonArraySubscript &, JsonWriter &);
+  static void serialize(const JsonObject &, JsonWriter &);
+  template <typename TKey>
+  static void serialize(const JsonObjectSubscript<TKey> &, JsonWriter &);
+  static void serialize(const JsonVariant &, JsonWriter &);
+};
+}
+}

src/ArduinoJson/Serialization/JsonSerializerImpl.hpp

@@ -0,0 +1,101 @@
+// 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 "../JsonArray.hpp"
+#include "../JsonArraySubscript.hpp"
+#include "../JsonObject.hpp"
+#include "../JsonObjectSubscript.hpp"
+#include "../JsonVariant.hpp"
+#include "JsonSerializer.hpp"
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonArray& array, JsonWriter& writer) {
+  writer.beginArray();
+
+  JsonArray::const_iterator it = array.begin();
+  while (it != array.end()) {
+    serialize(*it, writer);
+
+    ++it;
+    if (it == array.end()) break;
+
+    writer.writeComma();
+  }
+
+  writer.endArray();
+}
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonArraySubscript& arraySubscript, JsonWriter& writer) {
+  serialize(arraySubscript.as<JsonVariant>(), writer);
+}
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonObject& object, JsonWriter& writer) {
+  writer.beginObject();
+
+  JsonObject::const_iterator it = object.begin();
+  while (it != object.end()) {
+    writer.writeString(it->key);
+    writer.writeColon();
+    serialize(it->value, writer);
+
+    ++it;
+    if (it == object.end()) break;
+
+    writer.writeComma();
+  }
+
+  writer.endObject();
+}
+
+template <typename TKey>
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonObjectSubscript<TKey>& objectSubscript, JsonWriter& writer) {
+  serialize(objectSubscript.template as<JsonVariant>(), writer);
+}
+
+inline void ArduinoJson::Internals::JsonSerializer::serialize(
+    const JsonVariant& variant, JsonWriter& writer) {
+  switch (variant._type) {
+    case JSON_UNDEFINED:
+      return;
+
+    case JSON_ARRAY:
+      serialize(*variant._content.asArray, writer);
+      return;
+
+    case JSON_OBJECT:
+      serialize(*variant._content.asObject, writer);
+      return;
+
+    case JSON_STRING:
+      writer.writeString(variant._content.asString);
+      return;
+
+    case JSON_UNPARSED:
+      writer.writeRaw(variant._content.asString);
+      return;
+
+    case JSON_NEGATIVE_INTEGER:
+      writer.writeRaw('-');
+    case JSON_POSITIVE_INTEGER:
+      writer.writeInteger(variant._content.asInteger);
+      return;
+
+    case JSON_BOOLEAN:
+      writer.writeBoolean(variant._content.asInteger != 0);
+      return;
+
+    default:
+      uint8_t decimals =
+          static_cast<uint8_t>(variant._type - JSON_FLOAT_0_DECIMALS);
+      writer.writeFloat(variant._content.asFloat, decimals);
+  }
+}

src/ArduinoJson/Serialization/JsonWriter.hpp

@@ -0,0 +1,184 @@
+// 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/Encoding.hpp"
+#include "../Data/JsonFloat.hpp"
+#include "../Data/JsonInteger.hpp"
+#include "../Polyfills/attributes.hpp"
+#include "../Polyfills/math.hpp"
+#include "../Polyfills/normalize.hpp"
+#include "../Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Writes the JSON tokens to a Print implementation
+// This class is used by:
+// - JsonArray::writeTo()
+// - JsonObject::writeTo()
+// - JsonVariant::writeTo()
+// Its derived by PrettyJsonWriter that overrides some members to add
+// indentation.
+class JsonWriter {
+ 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;
+  }
+
+  void beginArray() {
+    writeRaw('[');
+  }
+  void endArray() {
+    writeRaw(']');
+  }
+
+  void beginObject() {
+    writeRaw('{');
+  }
+  void endObject() {
+    writeRaw('}');
+  }
+
+  void writeColon() {
+    writeRaw(':');
+  }
+  void writeComma() {
+    writeRaw(',');
+  }
+
+  void writeBoolean(bool value) {
+    writeRaw(value ? "true" : "false");
+  }
+
+  void writeString(const char *value) {
+    if (!value) {
+      writeRaw("null");
+    } else {
+      writeRaw('\"');
+      while (*value) writeChar(*value++);
+      writeRaw('\"');
+    }
+  }
+
+  void writeChar(char c) {
+    char specialChar = Encoding::escapeChar(c);
+    if (specialChar) {
+      writeRaw('\\');
+      writeRaw(specialChar);
+    } else {
+      writeRaw(c);
+    }
+  }
+
+  void writeFloat(JsonFloat value, uint8_t digits = 2) {
+    if (Polyfills::isNaN(value)) return writeRaw("NaN");
+
+    if (value < 0.0) {
+      writeRaw('-');
+      value = -value;
+    }
+
+    if (Polyfills::isInfinity(value)) return writeRaw("Infinity");
+
+    short powersOf10;
+    if (value > 1000 || value < 0.001) {
+      powersOf10 = Polyfills::normalize(value);
+    } else {
+      powersOf10 = 0;
+    }
+
+    // Round up last digit (so that print(1.999, 2) prints as "2.00")
+    value += getRoundingBias(digits);
+
+    // Extract the integer part of the value and print it
+    JsonUInt int_part = static_cast<JsonUInt>(value);
+    JsonFloat remainder = value - static_cast<JsonFloat>(int_part);
+    writeInteger(int_part);
+
+    // Print the decimal point, but only if there are digits beyond
+    if (digits > 0) {
+      writeRaw('.');
+    }
+
+    // Extract digits from the remainder one at a time
+    while (digits-- > 0) {
+      // Extract digit
+      remainder *= 10.0;
+      char currentDigit = char(remainder);
+      remainder -= static_cast<JsonFloat>(currentDigit);
+
+      // Print
+      writeRaw(char('0' + currentDigit));
+    }
+
+    if (powersOf10 < 0) {
+      writeRaw("e-");
+      writeInteger(-powersOf10);
+    }
+
+    if (powersOf10 > 0) {
+      writeRaw('e');
+      writeInteger(powersOf10);
+    }
+  }
+
+  void writeInteger(JsonUInt value) {
+    char buffer[22];
+    char *ptr = buffer + sizeof(buffer) - 1;
+
+    *ptr = 0;
+    do {
+      *--ptr = static_cast<char>(value % 10 + '0');
+      value /= 10;
+    } while (value);
+
+    writeRaw(ptr);
+  }
+
+  void writeRaw(const char *s) {
+    _length += _sink.print(s);
+  }
+  void writeRaw(char c) {
+    _length += _sink.write(c);
+  }
+
+ protected:
+  Print &_sink;
+  size_t _length;
+
+ private:
+  JsonWriter &operator=(const JsonWriter &);  // cannot be assigned
+
+  static JsonFloat getLastDigit(uint8_t digits) {
+    // Designed as a compromise between code size and speed
+    switch (digits) {
+      case 0:
+        return 1e-0;
+      case 1:
+        return 1e-1;
+      case 2:
+        return 1e-2;
+      case 3:
+        return 1e-3;
+      default:
+        return getLastDigit(uint8_t(digits - 4)) * 1e-4;
+    }
+  }
+
+  FORCE_INLINE static JsonFloat getRoundingBias(uint8_t digits) {
+    return 0.5 * getLastDigit(digits);
+  }
+};
+}
+}

src/ArduinoJson/Serialization/Prettyfier.hpp

@@ -0,0 +1,130 @@
+// 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 "IndentedPrint.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Converts a compact JSON string into an indented one.
+class Prettyfier : public Print {
+ public:
+  explicit Prettyfier(IndentedPrint& p) : _sink(p) {
+    _previousChar = 0;
+    _inString = false;
+  }
+
+  virtual size_t write(uint8_t c) {
+    size_t n = _inString ? handleStringChar(c) : handleMarkupChar(c);
+    _previousChar = c;
+    return n;
+  }
+
+ private:
+  Prettyfier& operator=(const Prettyfier&);  // cannot be assigned
+
+  bool inEmptyBlock() {
+    return _previousChar == '{' || _previousChar == '[';
+  }
+
+  size_t handleStringChar(uint8_t c) {
+    bool isQuote = c == '"' && _previousChar != '\\';
+
+    if (isQuote) _inString = false;
+
+    return _sink.write(c);
+  }
+
+  size_t handleMarkupChar(uint8_t c) {
+    switch (c) {
+      case '{':
+      case '[':
+        return writeBlockOpen(c);
+
+      case '}':
+      case ']':
+        return writeBlockClose(c);
+
+      case ':':
+        return writeColon();
+
+      case ',':
+        return writeComma();
+
+      case '"':
+        return writeQuoteOpen();
+
+      default:
+        return writeNormalChar(c);
+    }
+  }
+
+  size_t writeBlockClose(uint8_t c) {
+    size_t n = 0;
+    n += unindentIfNeeded();
+    n += _sink.write(c);
+    return n;
+  }
+
+  size_t writeBlockOpen(uint8_t c) {
+    size_t n = 0;
+    n += indentIfNeeded();
+    n += _sink.write(c);
+    return n;
+  }
+
+  size_t writeColon() {
+    size_t n = 0;
+    n += _sink.write(':');
+    n += _sink.write(' ');
+    return n;
+  }
+
+  size_t writeComma() {
+    size_t n = 0;
+    n += _sink.write(',');
+    n += _sink.println();
+    return n;
+  }
+
+  size_t writeQuoteOpen() {
+    _inString = true;
+    size_t n = 0;
+    n += indentIfNeeded();
+    n += _sink.write('"');
+    return n;
+  }
+
+  size_t writeNormalChar(uint8_t c) {
+    size_t n = 0;
+    n += indentIfNeeded();
+    n += _sink.write(c);
+    return n;
+  }
+
+  size_t indentIfNeeded() {
+    if (!inEmptyBlock()) return 0;
+
+    _sink.indent();
+    return _sink.println();
+  }
+
+  size_t unindentIfNeeded() {
+    if (inEmptyBlock()) return 0;
+
+    _sink.unindent();
+    return _sink.println();
+  }
+
+  uint8_t _previousChar;
+  IndentedPrint& _sink;
+  bool _inString;
+};
+}
+}

src/ArduinoJson/Serialization/StaticStringBuilder.hpp

@@ -0,0 +1,37 @@
+// 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 "../Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A Print implementation that allows to write in a char[]
+class StaticStringBuilder : public Print {
+ public:
+  StaticStringBuilder(char *buf, size_t size)
+      : buffer(buf), capacity(size - 1), length(0) {
+    buffer[0] = '\0';
+  }
+
+  virtual size_t write(uint8_t c) {
+    if (length >= capacity) return 0;
+
+    buffer[length++] = c;
+    buffer[length] = '\0';
+    return 1;
+  }
+
+ private:
+  char *buffer;
+  size_t capacity;
+  size_t length;
+};
+}
+}

src/ArduinoJson/Serialization/StreamPrintAdapter.hpp

@@ -0,0 +1,39 @@
+// 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"
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+
+#include "../Print.hpp"
+
+#include <ostream>
+
+namespace ArduinoJson {
+namespace Internals {
+
+class StreamPrintAdapter : public Print {
+ public:
+  explicit StreamPrintAdapter(std::ostream& os) : _os(os) {}
+
+  virtual size_t write(uint8_t c) {
+    _os << static_cast<char>(c);
+    return 1;
+  }
+
+ private:
+  // cannot be assigned
+  StreamPrintAdapter& operator=(const StreamPrintAdapter&);
+
+  std::ostream& _os;
+};
+}
+}
+
+#endif  // ARDUINOJSON_ENABLE_STD_STREAM

src/ArduinoJson/StaticJsonBuffer.hpp

@@ -0,0 +1,113 @@
+// 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 "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> {
+ public:
+  class String {
+   public:
+    String(StaticJsonBufferBase* parent) : _parent(parent) {
+      _start = parent->_buffer + parent->_size;
+    }
+
+    void append(char c) {
+      if (_parent->canAlloc(1)) {
+        char* last = static_cast<char*>(_parent->doAlloc(1));
+        *last = c;
+      }
+    }
+
+    const char* c_str() const {
+      if (_parent->canAlloc(1)) {
+        char* last = static_cast<char*>(_parent->doAlloc(1));
+        *last = '\0';
+        return _start;
+      } else {
+        return NULL;
+      }
+    }
+
+   private:
+    StaticJsonBufferBase* _parent;
+    char* _start;
+  };
+
+  StaticJsonBufferBase(char* buffer, size_t capa)
+      : _buffer(buffer), _capacity(capa), _size(0) {}
+
+  size_t capacity() const {
+    return _capacity;
+  }
+  size_t size() const {
+    return _size;
+  }
+
+  virtual void* alloc(size_t bytes) {
+    alignNextAlloc();
+    if (!canAlloc(bytes)) return NULL;
+    return doAlloc(bytes);
+  }
+
+  String startString() {
+    return String(this);
+  }
+
+ private:
+  void alignNextAlloc() {
+    _size = round_size_up(_size);
+  }
+
+  bool canAlloc(size_t bytes) const {
+    return _size + bytes <= _capacity;
+  }
+
+  void* doAlloc(size_t bytes) {
+    void* p = &_buffer[_size];
+    _size += bytes;
+    return p;
+  }
+
+  char* _buffer;
+  size_t _capacity;
+  size_t _size;
+};
+
+// Implements a JsonBuffer with fixed memory allocation.
+// The template paramenter CAPACITY specifies the capacity of the buffer in
+// bytes.
+template <size_t CAPACITY>
+class StaticJsonBuffer : public StaticJsonBufferBase {
+ public:
+  explicit StaticJsonBuffer() : StaticJsonBufferBase(_buffer, CAPACITY) {}
+
+ private:
+  char _buffer[CAPACITY];
+};
+}
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#pragma GCC diagnostic pop
+#endif
+#endif

src/ArduinoJson/StringTraits/ArduinoStream.hpp

@@ -0,0 +1,65 @@
+// 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
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
+
+#include <Stream.h>
+
+#include "../TypeTraits/EnableIf.hpp"
+#include "../TypeTraits/IsBaseOf.hpp"
+#include "../TypeTraits/RemoveReference.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+struct ArduinoStreamTraits {
+  class Reader {
+    Stream& _stream;
+    char _current, _next;
+
+   public:
+    Reader(Stream& stream) : _stream(stream), _current(0), _next(0) {}
+
+    void move() {
+      _current = _next;
+      _next = 0;
+    }
+
+    char current() {
+      if (!_current) _current = read();
+      return _current;
+    }
+
+    char next() {
+      // assumes that current() has been called
+      if (!_next) _next = read();
+      return _next;
+    }
+
+   private:
+    char read() {
+      // don't use _stream.read() as it ignores the timeout
+      char c = 0;
+      _stream.readBytes(&c, 1);
+      return c;
+    }
+  };
+};
+
+template <typename TStream>
+struct StringTraits<TStream,
+                    // match any type that is derived from Stream:
+                    typename TypeTraits::EnableIf<TypeTraits::IsBaseOf<
+                        Stream, typename TypeTraits::RemoveReference<
+                                    TStream>::type>::value>::type>
+    : ArduinoStreamTraits {};
+}
+}
+
+#endif

src/ArduinoJson/StringTraits/CharPointer.hpp

@@ -0,0 +1,61 @@
+// 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 "../TypeTraits/EnableIf.hpp"
+#include "../TypeTraits/IsChar.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TChar>
+struct CharPointerTraits {
+  class Reader {
+    const TChar* _ptr;
+
+   public:
+    Reader(const TChar* ptr)
+        : _ptr(ptr ? ptr : reinterpret_cast<const TChar*>("")) {}
+
+    void move() {
+      ++_ptr;
+    }
+
+    TChar current() const {
+      return _ptr[0];
+    }
+
+    TChar next() const {
+      return _ptr[1];
+    }
+  };
+
+  static bool equals(const TChar* str, const char* expected) {
+    return strcmp(reinterpret_cast<const char*>(str), expected) == 0;
+  }
+
+  template <typename Buffer>
+  static char* duplicate(const TChar* str, Buffer* buffer) {
+    if (!str) return NULL;
+    size_t size = strlen(reinterpret_cast<const char*>(str)) + 1;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy(dup, str, size);
+    return static_cast<char*>(dup);
+  }
+
+  static const bool has_append = false;
+  static const bool has_equals = true;
+  static const bool should_duplicate = false;
+};
+
+template <typename TChar>
+struct StringTraits<TChar*, typename TypeTraits::EnableIf<
+                                TypeTraits::IsChar<TChar>::value>::type>
+    : CharPointerTraits<TChar> {};
+}
+}

src/ArduinoJson/StringTraits/FlashString.hpp

@@ -0,0 +1,56 @@
+// 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
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+
+namespace ArduinoJson {
+namespace Internals {
+template <>
+struct StringTraits<const __FlashStringHelper*, void> {
+  class Reader {
+    const char* _ptr;
+
+   public:
+    Reader(const __FlashStringHelper* ptr)
+        : _ptr(reinterpret_cast<const char*>(ptr)) {}
+
+    void move() {
+      _ptr++;
+    }
+
+    char current() const {
+      return pgm_read_byte_near(_ptr);
+    }
+
+    char next() const {
+      return pgm_read_byte_near(_ptr + 1);
+    }
+  };
+
+  static bool equals(const __FlashStringHelper* str, const char* expected) {
+    return strcmp_P(expected, (PGM_P)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;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy_P(dup, (PGM_P)str, size);
+    return static_cast<char*>(dup);
+  }
+
+  static const bool has_append = false;
+  static const bool has_equals = true;
+  static const bool should_duplicate = true;
+};
+}
+}
+
+#endif

src/ArduinoJson/StringTraits/StdStream.hpp

@@ -0,0 +1,63 @@
+// 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
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+
+#include <istream>
+#include "../TypeTraits/EnableIf.hpp"
+#include "../TypeTraits/IsBaseOf.hpp"
+#include "../TypeTraits/RemoveReference.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+struct StdStreamTraits {
+  class Reader {
+    std::istream& _stream;
+    char _current, _next;
+
+   public:
+    Reader(std::istream& stream) : _stream(stream), _current(0), _next(0) {}
+
+    void move() {
+      _current = _next;
+      _next = 0;
+    }
+
+    char current() {
+      if (!_current) _current = read();
+      return _current;
+    }
+
+    char next() {
+      // assumes that current() has been called
+      if (!_next) _next = read();
+      return _next;
+    }
+
+   private:
+    Reader& operator=(const Reader&);  // Visual Studio C4512
+
+    char read() {
+      return _stream.eof() ? '\0' : static_cast<char>(_stream.get());
+    }
+  };
+};
+
+template <typename TStream>
+struct StringTraits<TStream,
+                    // match any type that is derived from std::istream:
+                    typename TypeTraits::EnableIf<TypeTraits::IsBaseOf<
+                        std::istream, typename TypeTraits::RemoveReference<
+                                          TStream>::type>::value>::type>
+    : StdStreamTraits {};
+}
+}
+
+#endif

src/ArduinoJson/StringTraits/StdString.hpp

@@ -0,0 +1,66 @@
+// 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
+
+#if ARDUINOJSON_ENABLE_STD_STRING || ARDUINOJSON_ENABLE_ARDUINO_STRING
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+#include <WString.h>
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+#include <string>
+#endif
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TString>
+struct StdStringTraits {
+  template <typename Buffer>
+  static char* duplicate(const TString& str, Buffer* buffer) {
+    if (!str.c_str()) return NULL;  // <- Arduino string can return NULL
+    size_t size = str.length() + 1;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy(dup, str.c_str(), size);
+    return static_cast<char*>(dup);
+  }
+
+  struct Reader : CharPointerTraits<char>::Reader {
+    Reader(const TString& str) : CharPointerTraits<char>::Reader(str.c_str()) {}
+  };
+
+  static bool equals(const TString& str, const char* expected) {
+    return 0 == strcmp(str.c_str(), expected);
+  }
+
+  static void append(TString& str, char c) {
+    str += c;
+  }
+
+  static const bool has_append = true;
+  static const bool has_equals = true;
+  static const bool should_duplicate = true;
+};
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+template <>
+struct StringTraits<String, void> : StdStringTraits<String> {};
+template <>
+struct StringTraits<StringSumHelper, void> : StdStringTraits<StringSumHelper> {
+};
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+template <>
+struct StringTraits<std::string, void> : StdStringTraits<std::string> {};
+#endif
+}
+}
+
+#endif

src/ArduinoJson/StringTraits/StringTraits.hpp

@@ -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!
+
+#pragma once
+
+#include "../Configuration.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TString, typename Enable = void>
+struct StringTraits {};
+
+template <typename TString>
+struct StringTraits<const TString, void> : StringTraits<TString> {};
+
+template <typename TString>
+struct StringTraits<TString&, void> : StringTraits<TString> {};
+}
+}
+
+#include "ArduinoStream.hpp"
+#include "CharPointer.hpp"
+#include "FlashString.hpp"
+#include "StdStream.hpp"
+#include "StdString.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+template <typename T, typename Enable = void>
+struct IsString {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsString<T, typename TypeTraits::EnableIf<
+                       Internals::StringTraits<T>::has_equals>::type> {
+  static const bool value = Internals::StringTraits<T>::has_equals;
+};
+}
+}

src/ArduinoJson/TypeTraits/EnableIf.hpp

@@ -0,0 +1,22 @@
+// 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 TypeTraits {
+
+// A meta-function that return the type T if Condition is true.
+template <bool Condition, typename T = void>
+struct EnableIf {};
+
+template <typename T>
+struct EnableIf<true, T> {
+  typedef T type;
+};
+}
+}

src/ArduinoJson/TypeTraits/FloatTraits.hpp

@@ -0,0 +1,84 @@
+// 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 <stdint.h>
+#include <stdlib.h>  // for size_t
+#include "../Polyfills/math.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+template <typename T, size_t = sizeof(T)>
+struct FloatTraits {};
+
+#ifndef ARDUINO_ARCH_AVR  // double is 32 bits, so 1e64 gives a warning
+template <typename T>
+struct FloatTraits<T, 8 /*64bits*/> {
+  typedef int64_t mantissa_type;
+  static const short mantissa_bits = 52;
+  static const mantissa_type mantissa_max =
+      (static_cast<mantissa_type>(1) << mantissa_bits) - 1;
+
+  typedef int16_t exponent_type;
+  static const exponent_type exponent_max = 308;
+
+  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 = -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);
+  }
+
+  static T nan() {
+    return Polyfills::nan<T>();
+  }
+
+  static T inf() {
+    return Polyfills::inf<T>();
+  }
+};
+#endif
+
+template <typename T>
+struct FloatTraits<T, 4 /*32bits*/> {
+  typedef int32_t mantissa_type;
+  static const short mantissa_bits = 23;
+  static const mantissa_type mantissa_max =
+      (static_cast<mantissa_type>(1) << mantissa_bits) - 1;
+
+  typedef int8_t exponent_type;
+  static const exponent_type exponent_max = 38;
+
+  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);
+  }
+
+  static T nan() {
+    return Polyfills::nan<T>();
+  }
+
+  static T inf() {
+    return Polyfills::inf<T>();
+  }
+};
+}
+}

src/ArduinoJson/TypeTraits/IsArray.hpp

@@ -0,0 +1,27 @@
+// 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 TypeTraits {
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct IsArray {
+  static const bool value = false;
+};
+template <typename T>
+struct IsArray<T[]> {
+  static const bool value = true;
+};
+template <typename T, size_t N>
+struct IsArray<T[N]> {
+  static const bool value = true;
+};
+}
+}

src/ArduinoJson/TypeTraits/IsBaseOf.hpp

@@ -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!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if Derived inherits from TBase is an
+// integral type.
+template <typename TBase, typename TDerived>
+class IsBaseOf {
+ protected:  // <- to avoid GCC's "all member functions in class are private"
+  typedef char Yes[1];
+  typedef char No[2];
+
+  static Yes &probe(const TBase *);
+  static No &probe(...);
+
+ public:
+  enum {
+    value = sizeof(probe(reinterpret_cast<TDerived *>(0))) == sizeof(Yes)
+  };
+};
+}
+}

src/ArduinoJson/TypeTraits/IsChar.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
+
+#include "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is a charater
+template <typename T>
+struct IsChar {
+  static const bool value = IsSame<T, char>::value ||
+                            IsSame<T, signed char>::value ||
+                            IsSame<T, unsigned char>::value;
+};
+
+template <typename T>
+struct IsChar<const T> : IsChar<T> {};
+}
+}

src/ArduinoJson/TypeTraits/IsConst.hpp

@@ -0,0 +1,24 @@
+// 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 TypeTraits {
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct IsConst {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsConst<const T> {
+  static const bool value = true;
+};
+}
+}

src/ArduinoJson/TypeTraits/IsFloatingPoint.hpp

@@ -0,0 +1,21 @@
+// 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 "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is a floating point type
+template <typename T>
+struct IsFloatingPoint {
+  static const bool value = IsSame<T, float>::value || IsSame<T, double>::value;
+};
+}
+}

src/ArduinoJson/TypeTraits/IsIntegral.hpp

@@ -0,0 +1,29 @@
+// 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 "IsSame.hpp"
+#include "IsSignedIntegral.hpp"
+#include "IsUnsignedIntegral.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is an integral type.
+template <typename T>
+struct IsIntegral {
+  static const bool value = TypeTraits::IsSignedIntegral<T>::value ||
+                            TypeTraits::IsUnsignedIntegral<T>::value ||
+                            TypeTraits::IsSame<T, char>::value;
+  // CAUTION: differs from std::is_integral as it doesn't include bool
+};
+
+template <typename T>
+struct IsIntegral<const T> : IsIntegral<T> {};
+}
+}

src/ArduinoJson/TypeTraits/IsSame.hpp

@@ -0,0 +1,24 @@
+// 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 TypeTraits {
+
+// A meta-function that returns true if types T and U are the same.
+template <typename T, typename U>
+struct IsSame {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsSame<T, T> {
+  static const bool value = true;
+};
+}
+}

src/ArduinoJson/TypeTraits/IsSignedIntegral.hpp

@@ -0,0 +1,33 @@
+// 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 "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is an integral type.
+template <typename T>
+struct IsSignedIntegral {
+  static const bool value = TypeTraits::IsSame<T, signed char>::value ||
+                            TypeTraits::IsSame<T, signed short>::value ||
+                            TypeTraits::IsSame<T, signed int>::value ||
+                            TypeTraits::IsSame<T, signed long>::value ||
+#if ARDUINOJSON_USE_LONG_LONG
+                            TypeTraits::IsSame<T, signed long long>::value ||
+#endif
+
+#if ARDUINOJSON_USE_INT64
+                            TypeTraits::IsSame<T, signed __int64>::value ||
+#endif
+                            false;
+};
+}
+}

src/ArduinoJson/TypeTraits/IsUnsignedIntegral.hpp

@@ -0,0 +1,33 @@
+// 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 "IsSame.hpp"
+
+namespace ArduinoJson {
+namespace TypeTraits {
+
+// A meta-function that returns true if T is an integral type.
+template <typename T>
+struct IsUnsignedIntegral {
+  static const bool value = TypeTraits::IsSame<T, unsigned char>::value ||
+                            TypeTraits::IsSame<T, unsigned short>::value ||
+                            TypeTraits::IsSame<T, unsigned int>::value ||
+                            TypeTraits::IsSame<T, unsigned long>::value ||
+#if ARDUINOJSON_USE_LONG_LONG
+                            TypeTraits::IsSame<T, unsigned long long>::value ||
+#endif
+
+#if ARDUINOJSON_USE_INT64
+                            TypeTraits::IsSame<T, unsigned __int64>::value ||
+#endif
+                            false;
+};
+}
+}

src/ArduinoJson/TypeTraits/RemoveConst.hpp

@@ -0,0 +1,23 @@
+// 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 TypeTraits {
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct RemoveConst {
+  typedef T type;
+};
+template <typename T>
+struct RemoveConst<const T> {
+  typedef T type;
+};
+}
+}

src/ArduinoJson/TypeTraits/RemoveReference.hpp

@@ -0,0 +1,23 @@
+// 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 TypeTraits {
+
+// A meta-function that return the type T without the reference modifier.
+template <typename T>
+struct RemoveReference {
+  typedef T type;
+};
+template <typename T>
+struct RemoveReference<T&> {
+  typedef T type;
+};
+}
+}