Merge branch '4.0'

Conflicts:
	JsonGenerator.cpp
	JsonGenerator.h
	JsonGenerator/EscapedString.cpp
	JsonGenerator/EscapedString.h
	JsonGenerator/IndentedPrint.cpp
	JsonGenerator/IndentedPrint.h
	JsonGenerator/JsonArray.h
	JsonGenerator/JsonArrayBase.cpp
	JsonGenerator/JsonArrayBase.h
	JsonGenerator/JsonObject.h
	JsonGenerator/JsonObjectBase.cpp
	JsonGenerator/JsonObjectBase.h
	JsonGenerator/JsonPrettyPrint.cpp
	JsonGenerator/JsonPrettyPrint.h
	JsonGenerator/JsonPrintable.cpp
	JsonGenerator/JsonPrintable.h
	JsonGenerator/JsonValue.cpp
	JsonGenerator/JsonValue.h
	JsonGenerator/Print.cpp
	JsonGenerator/Print.h
	JsonGenerator/Printable.h
	JsonGenerator/StringBuilder.cpp
	JsonGenerator/StringBuilder.h
	JsonGeneratorTests/EscapedStringTests.cpp
	JsonGeneratorTests/Issue10.cpp
	JsonGeneratorTests/JsonArrayTests.cpp
	JsonGeneratorTests/JsonObject_Indexer_Tests.cpp
	JsonGeneratorTests/JsonObject_PrintTo_Tests.cpp
	JsonGeneratorTests/JsonValue_Cast_Tests.cpp
	JsonGeneratorTests/JsonValue_PrintTo_Tests.cpp
	JsonGeneratorTests/PrettyPrint_Array_Tests.cpp
	JsonGeneratorTests/PrettyPrint_Object_Tests.cpp
	JsonGeneratorTests/PrettyPrint_String_Tests.cpp
	JsonGeneratorTests/StringBuilderTests.cpp
	JsonParser.cpp
	JsonParser.h
	JsonParser/JsonArray.cpp
	JsonParser/JsonArray.h
	JsonParser/JsonArrayIterator.h
	JsonParser/JsonObject.cpp
	JsonParser/JsonObject.h
	JsonParser/JsonObjectIterator.h
	JsonParser/JsonPair.h
	JsonParser/JsonParser.h
	JsonParser/JsonParserBase.cpp
	JsonParser/JsonParserBase.h
	JsonParser/JsonToken.cpp
	JsonParser/JsonToken.h
	JsonParser/JsonValue.cpp
	JsonParser/JsonValue.h
	JsonParser/README.md
	JsonParserTests/GbathreeBug.cpp
	JsonParserTests/JsonArrayIteratorTests.cpp
	JsonParserTests/JsonArrayTests.cpp
	JsonParserTests/JsonObjectIteratorTests.cpp
	JsonParserTests/JsonObjectTests.cpp
	JsonParserTests/JsonStringTests.cpp
	JsonParserTests/TestHashGenerator.cpp
	README.md
	library.json

.gitignore

@@ -1,6 +1,5 @@
-*.sdf
-*.user
-*.suo
-Debug
-ipch
-*.opensdf
+.DS_Store
+/.idea
+/build
+/bin
+/lib

.travis.yml

@@ -0,0 +1,6 @@
+language: c++
+compiler:
+  - gcc
+  - clang
+before_script: cmake .
+script: make && make test

ArduinoJson.sln

@@ -1,28 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.21005.1
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonGeneratorTests", "JsonGeneratorTests\JsonGeneratorTests.vcxproj", "{B9545D97-E084-4A19-8E48-929157064360}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonParserTests", "JsonParserTests\JsonParserTests.vcxproj", "{4DD596EF-0185-4AB4-A3C2-F20C496F7806}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{B9545D97-E084-4A19-8E48-929157064360}.Debug|Win32.ActiveCfg = Debug|Win32
-		{B9545D97-E084-4A19-8E48-929157064360}.Debug|Win32.Build.0 = Debug|Win32
-		{B9545D97-E084-4A19-8E48-929157064360}.Release|Win32.ActiveCfg = Release|Win32
-		{B9545D97-E084-4A19-8E48-929157064360}.Release|Win32.Build.0 = Release|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Debug|Win32.ActiveCfg = Debug|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Debug|Win32.Build.0 = Debug|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Release|Win32.ActiveCfg = Release|Win32
-		{4DD596EF-0185-4AB4-A3C2-F20C496F7806}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

CHANGELOG.md

@@ -1,6 +1,84 @@
 Arduino JSON: change log
 ========================
 
+v4.0
+----
+
+* Unified parser and generator API (issue #23)
+* Updated library layout, now requires Arduino 1.0.6 or newer
+
+**BREAKING CHANGE**: API changed significantly, see `doc/Migrating to the new API.md`.
+
+
+v3.4
+----
+
+* Fixed escaped char parsing (issue #16)
+  
+
+v3.3
+----
+
+* Added indented output for the JSON generator (issue #11), see example bellow.
+* Added `IndentedPrint`, a decorator for `Print` to allow indented output
+
+Example:
+
+    JsonOject<2> json;
+    json["key"] = "value";
+    json.prettyPrintTo(Serial);
+
+v3.2
+----
+
+* Fixed a bug when adding nested object in `JsonArray` (bug introduced in v3.1).
+
+v3.1
+----
+
+* Calling `Generator::JsonObject::add()` twice with the same `key` now replaces the `value`
+* Added `Generator::JsonObject::operator[]`, see bellow the new API
+* Added `Generator::JsonObject::remove()` (issue #9)
+
+Old generator API:
+
+	JsonObject<3> root; 
+    root.add("sensor", "gps");
+    root.add("time", 1351824120);
+    root.add("data", array);
+
+New generator API:
+
+	JsonObject<3> root; 
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+    root["data"] = array;
+
+v3.0
+----
+
+* New parser API, see bellow
+* Renamed `JsonHashTable` into `JsonObject`
+* Added iterators for `JsonArray` and `JsonObject` (issue #4)
+
+Old parser API:
+
+    JsonHashTable root = parser.parseHashTable(json);
+
+	char*  sensor    = root.getString("sensor");
+	long   time      = root.getLong("time");
+	double latitude  = root.getArray("data").getDouble(0);
+    double longitude = root.getArray("data").getDouble(1);
+
+New parser API:
+
+	JsonObject root = parser.parse(json);
+
+	char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
 v2.1
 ----
 

CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 2.8.4)
+project(ArduinoJson)
+
+enable_testing()
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
+
+if(MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS -W4)
+endif()
+
+add_subdirectory(src)
+add_subdirectory(test)

JsonGenerator.cpp

@@ -1,12 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-// This file is here to help the Arduino IDE find the .cpp files
-
-#include "JsonGenerator/EscapedString.cpp"
-#include "JsonGenerator/JsonArrayBase.cpp"
-#include "JsonGenerator/JsonValue.cpp"
-#include "JsonGenerator/JsonHashTableBase.cpp"
-#include "JsonGenerator/StringBuilder.cpp"

JsonGenerator.h

@@ -1,7 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonGenerator/JsonArray.h"
-#include "JsonGenerator/JsonHashTable.h"

JsonGenerator/EscapedString.cpp

@@ -1,47 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include "EscapedString.h"
-
-using namespace ArduinoJson::Internals;
-
-static inline char getSpecialChar(char c)
-{
-    // Optimized for code size on a 8-bit AVR
-
-    const char* p = "\"\"\\\\\bb\ff\nn\rr\tt\0";
-
-    while (p[0] && p[0] != c)
-    {
-        p += 2;
-    }
-
-    return p[1];
-}
-
-static inline size_t printCharTo(char c, Print& p)
-{
-    char specialChar = getSpecialChar(c);
-
-    return specialChar != 0
-        ? p.write('\\') + p.write(specialChar)
-        : p.write(c);
-}
-
-size_t EscapedString::printTo(Print& p) const
-{
-    const char* s = rawString;
-
-    if (!s) return p.print("null");
-    
-    size_t n = p.write('\"');
-
-    while (*s)
-    {
-        n += printCharTo(*s++, p);
-    }
-
-    return n + p.write('\"');
-}

JsonGenerator/EscapedString.h

@@ -1,29 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "Print.h"
-
-namespace ArduinoJson
-{
-    namespace Internals
-    {
-        class EscapedString
-        {
-        public:
-
-            void set(const char* s)
-            {
-                rawString = s;
-            }
-
-            size_t printTo(Print&) const;
-
-        private:
-            const char* rawString;
-        };
-    }
-}

JsonGenerator/JsonArray.h

@@ -1,28 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonArrayBase.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        template<int N>
-        class JsonArray : public JsonArrayBase
-        {
-        public:
-            JsonArray()
-                : JsonArrayBase(items, N)
-            {
-
-            }         
-
-        private:
-            Internals::JsonValue items[N];
-        };
-    }
-}

JsonGenerator/JsonArrayBase.cpp

@@ -1,34 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArrayBase.h"
-
-using namespace ArduinoJson::Generator;
-using namespace ArduinoJson::Internals;
-
-size_t JsonArrayBase::printTo(Print& p) const
-{
-    size_t n = 0;
-
-    n += p.write('[');
-
-    // NB: the code has been optimized for a small size on a 8-bit AVR
-
-    const JsonValue* current = items;
-    for (int i = count; i > 0; i--)
-    {       
-        n += current->printTo(p);
-        current++;
-
-        if (i > 1)
-        {
-            n += p.write(',');
-        }
-    }
-
-    n += p.write(']');
-
-    return n;
-}

JsonGenerator/JsonArrayBase.h

@@ -1,49 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonObjectBase.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        class JsonArrayBase : public JsonObjectBase
-        {
-        public:
-            JsonArrayBase(Internals::JsonValue* items, int capacity)
-                : items(items), capacity(capacity), count(0)
-            {
-
-            }
-
-            template<typename T>
-            void add(T value)
-            {
-                if (count >= capacity) return;
-
-                items[count++].set(value);
-            }
-
-            template<int DIGITS>
-            void add(double value)
-            {
-                if (count >= capacity) return;
-
-                Internals::JsonValue& v = items[count++];
-                v.set<DIGITS>(value);
-            }
-
-            virtual size_t printTo(Print& p) const;
-
-            using JsonObjectBase::printTo;
-
-        private:
-            Internals::JsonValue* items;
-            int capacity, count;
-        };
-    }
-}

JsonGenerator/JsonHashTable.h

@@ -1,27 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonHashTableBase.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        template<int N>
-        class JsonHashTable : public JsonHashTableBase
-        {
-        public:
-            JsonHashTable()
-                : JsonHashTableBase(items, N)
-            {
-            }            
-
-        private:
-            KeyValuePair items[N];     
-        };
-    }
-}

JsonGenerator/JsonHashTableBase.cpp

@@ -1,36 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonHashTable.h"
-
-using namespace ArduinoJson::Generator;
-
-size_t JsonHashTableBase::printTo(Print& p) const
-{
-    size_t n = 0;
-
-    n += p.write('{');
-
-    // NB: the code has been optimized for a small size on a 8-bit AVR
-
-    const KeyValuePair* current = items;
-    for (int i = count; i > 0; i--)
-    {       
-        n += current->key.printTo(p);
-        n += p.write(':');
-        n += current->value.printTo(p);
-
-        current++;
-
-        if (i > 1)
-        {
-            n += p.write(',');
-        }
-    }
-
-    n += p.write('}');
-
-    return n;
-}

JsonGenerator/JsonHashTableBase.h

@@ -1,61 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonObjectBase.h"
-#include "EscapedString.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        class JsonHashTableBase : public JsonObjectBase
-        {
-        public:
-
-            template<typename T>
-            void add(const char* key, T value)
-            {
-                if (count >= capacity) return;
-
-                items[count].key.set(key);
-                items[count].value.set(value);
-                count++;
-            }
-
-            template<int DIGITS>
-            void add(const char* key, double value)
-            {
-                if (count >= capacity) return;
-
-                items[count].key.set(key);
-                items[count].value.set<DIGITS>(value);
-                count++;
-            }
-
-            using JsonObjectBase::printTo;
-
-            virtual size_t printTo(Print& p) const;
-
-        protected:
-
-            struct KeyValuePair
-            {
-                Internals::EscapedString  key;
-                Internals::JsonValue      value;
-            };
-
-            JsonHashTableBase(KeyValuePair* items, int capacity)
-                : items(items), capacity(capacity), count(0)
-            {
-            }
-
-        private:
-            KeyValuePair* items;
-            int capacity, count;
-        };
-    }
-}

JsonGenerator/JsonObjectBase.h

@@ -1,31 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonValue.h"
-#include "Print.h"
-#include "Printable.h"
-
-namespace ArduinoJson
-{
-    namespace Generator
-    {
-        class JsonObjectBase : public Printable
-        {
-        public:
-
-            size_t printTo(char* buffer, size_t bufferSize)
-            {
-                using namespace Internals;
-
-                StringBuilder sb(buffer, bufferSize);
-                return printTo(sb);
-            }
-
-            virtual size_t printTo(Print& p) const = 0;
-        };
-    }
-}

JsonGenerator/JsonValue.cpp

@@ -1,32 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include "EscapedString.h"
-#include "JsonValue.h"
-
-using namespace ArduinoJson::Internals;
-
-size_t JsonValue::printBoolTo(const Content& c, Print& p)
-{
-    return p.print(c.asBool ? "true" : "false");
-}
-
-size_t JsonValue::printLongTo(const Content& c, Print& p)
-{
-    return p.print(c.asLong);
-}
-
-size_t JsonValue::printPrintableTo(const Content& c, Print& p)
-{
-    if (c.asPrintable)
-        return c.asPrintable->printTo(p);
-    else
-        return p.print("null");
-}
-
-size_t JsonValue::printStringTo(const Content& c, Print& p)
-{
-    return c.asString.printTo(p);
-}

JsonGenerator/JsonValue.h

@@ -1,94 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "EscapedString.h"
-#include "Printable.h"
-#include "StringBuilder.h"
-
-namespace ArduinoJson
-{
-    namespace Internals
-    {
-        class JsonValue
-        {
-        public:
-            
-            void set(bool value)
-            {
-                printToImpl = &printBoolTo;
-                content.asBool = value;
-            }
-
-            void set(long value)               
-            {
-                printToImpl = &printLongTo;
-                content.asLong = value;
-            }
-
-            void set(int value)
-            {
-                printToImpl = &printLongTo;
-                content.asLong = value;
-            }
-
-            void set(Printable& value)
-            {
-                printToImpl = &printPrintableTo;
-                content.asPrintable = &value;
-            }
-
-            void set(const char* value)
-            {
-                printToImpl = &printStringTo;
-                content.asString.set(value);
-            }
-
-            void set(double value)
-            {
-                set<2>(value);
-            }
-
-            template<int DIGITS>
-            void set(double value)
-            {
-                printToImpl = &printDoubleTo<DIGITS>;
-                content.asDouble = value;
-            }
-
-            size_t printTo(Print& p) const
-            {
-                // handmade polymorphism
-                return printToImpl(content, p);
-            }
-
-        private:
-            union Content
-            {
-                bool          asBool;
-                long          asLong;
-                Printable*    asPrintable;
-                EscapedString asString;
-                double        asDouble;
-            };
-
-            Content content;
-
-            size_t(*printToImpl)(const Content&, Print&);
-
-            static size_t printBoolTo(const Content&, Print&);
-            static size_t printLongTo(const Content&, Print&);
-            static size_t printPrintableTo(const Content&, Print&);
-            static size_t printStringTo(const Content&, Print&);
-
-            template<int DIGITS>
-            static size_t printDoubleTo(const Content& c, Print& p)
-            {
-                return p.print(c.asDouble, DIGITS);
-            }
-        };
-    }
-}

JsonGenerator/Print.h

@@ -1,28 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#ifndef ARDUINO
-
-typedef unsigned char uint8_t;
-
-// This class reproduces Arduino's Print
-class Print
-{
-public:
-
-    virtual size_t write(uint8_t) = 0;
-
-    size_t print(const char[]);
-    size_t print(double, int = 2);
-    size_t print(long);
-};
-
-#else
-
-#include <Print.h>
-
-#endif

JsonGenerator/Printable.h

@@ -1,24 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#ifndef ARDUINO
-
-class Print;
-
-class Printable
-{
-public:
-
-    virtual size_t printTo(Print& p) const = 0;
-};
-
-#else
-
-#include <Printable.h>
-
-#endif
-

JsonGenerator/README.md

@@ -1,167 +0,0 @@
-Arduino JSON library - Generator
-================================
-
-This library is a simple JSON encoder for embedded systems.
-
-It's design to be very lightweight, works without any allocation on the heap (no malloc) and supports nested objects.
-
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
-
-
-Features
---------
-
-* Supports nested objects
-* Elegant API, very easy to use 
-* Fixed memory allocation (no malloc)
-* Small footprint
-* Implements Arduino's Printable interface
-* MIT License
-
-
-Example
--------
-
-    JsonArray<2> array;
-    array.add<6>(48.756080);
-    array.add<6>(2.302038);
-
-    JsonHashTable<3> root;
-    root.add("sensor", "gps");
-    root.add("time", 1351824120);
-    root.add("data", array);
-
-    Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
-
-
-How to  use?
-------------
-
-### 1. Install the library
-
-Download the library and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJson
-
-### 2. Import in your sketch
-
-Just add the following lines at the top of your `.ino` file:
-
-    #include <JsonGenerator.h>
-
-    using namespace ArduinoJson::Generator;
-   
-### 3. Create object tree
-
-In order to generate a JSON string, you need to build the equivalent object tree. You usually start by the root which can be either an array or an hash-table.
-
-#### Array
-
-You create an array with the following line:
-
-    JsonArray<8> array;
-
-See the little `<8>`? It's a template parameter that gives the capacity of the array, it's the maximum number of elements you can put in it. 
-
-> ##### About the capacity
-> As stated in the feature list, this library works with a fixed memory allocation.
-> This means that the size of the object must be know at the compilation time, therefore you can **not** use a variable to set the capacity of the array.
-
-Then you can add strings, integer, booleans, etc: 
-
-    array.add("bazinga!");
-    array.add(42);
-    array.add(true);
-
-There are two syntaxes for the floating point values:
-
-	array.add<4>(3.1415);  // 4 digits: "3.1415" 
-    array.add(3.14);	   // 2 digits: "3.14"
-
-> ##### About floating point precision
-> The overload of `add()` with 2 parameters allows you to specify the number of decimals to save in the JSON string. 
-> When you use the overload with one parameter, you use the default number of decimals which is two.
-> Note that this behavior is the exact same as Arduino's `Print::print(double,int);` which is implemented by `Serial`. 
-> So you may already be familiar with it. 
-
-Finally you can add nested object to the array:
-
-    JsonArray<8> nestedArray;
-    array.add(nestedArray);
-
-or
-
-    JsonHashTable<8> nestedHash;
-    array.add(nestedHash);
-
-#### Hash-table
-
-You create a hash-table with the following line:
-
-    JsonHashTable<8> hash;
-
-Like with the array class, there is a template parameter that gives the capacity of the hash-table.
-
-Then you can add strings, integer, booleans, etc: 
-
-    hash.add("key1", "bazinga!");
-    hash.add("key2", 42);
-    hash.add("key3", true);
-
-As for the arrays, there are two syntaxes for the floating point values:
-
-	array.add<4>("key4", 3.1415);  // 4 digits: "3.1415" 
-    array.add("key5", 3.14);	   // 2 digits: "3.14"
-
-Finally you can add nested objects:
-
-    JsonArray<8> nestedArray;
-    hash.add("key6", nestedArray);
-
-or
-
-    JsonHashTable<8> nestedHash;
-    hash.add("key7", nestedHash);
-
-### 4. Get the JSON string
-
-There are two ways tho get the resulting JSON string.
-
-Depending on your project, you may need to dump the string in a classic `char[]` or send it to a stream like `Serial` or `EthernetClient `.
-
-Both ways are the easy way :-)
-
-#### Use a classic `char[]`
-
-Whether you have a `JsonArray` or a `JsonHashTable`, simply call `printTo()` with the destination buffer, like so:
-
-	char buffer[256];
-    array.printTo(buffer, sizeof(buffer));
-
-#### Send to a stream
-
-It's very likely that the generated JSON will end up in a stream like `Serial` or `EthernetClient `, so you can save some time and memory by doing this:
-
-	Serial.print(array);
-
-or
-  
-    array.printTo(Serial);
-
-> ##### About the Printable interface
-> `JsonArray` and `JsonHashTable` implement Arduino's `Printable` interface.
-> This is why you can call `Serial.print()` like in the example above.
-> You can do the same with any other implementation of `Print`:  `HardwareSerial`,  `SoftwareSerial`, `LiquidCrystal`, `EthernetClient`, `WiFiClient`...
-   
-
-Memory usage
-------------
-
-Here are the size of the main classes of the library.
-
-This table is for an 8-bit Arduino, types would be bigger on a 32-bit processor.
-
-| Type                   | Size in bytes |
-| ---------------------- | ------------- |
-| JsonArray&lt;N&gt;     | 8 + 6 x N     |
-| JsonHashTable&lt;N&gt; | 8 + 8 x N     |

JsonGenerator/StringBuilder.cpp

@@ -1,17 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include "StringBuilder.h"
-
-using namespace ArduinoJson::Internals;
-
-size_t StringBuilder::write(uint8_t c)
-{
-    if (length >= capacity) return 0;
-
-    buffer[length++] = c;
-    buffer[length] = 0;
-    return 1;
-}

JsonGenerator/StringBuilder.h

@@ -1,31 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "Print.h"
-
-namespace ArduinoJson
-{
-    namespace Internals
-    {
-        class StringBuilder : public Print
-        {
-        public:
-            StringBuilder(char* buf, int size)
-                : buffer(buf), capacity(size - 1), length(0)
-            {
-                buffer[0] = 0;
-            }
-
-            virtual size_t write(uint8_t c);
-
-        private:
-            char* buffer;
-            int capacity;
-            int length;
-        };
-    }
-}

JsonGeneratorTests/EscapedStringTests.cpp

@@ -1,97 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "EscapedString.h"
-#include "StringBuilder.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Internals;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(EscapedStringTests)
-    {
-        char buffer[1024];
-        size_t returnValue;
-        EscapedString escapedString;
-
-    public:
-
-        TEST_METHOD(Null)
-        {
-            whenInputIs(0);
-            outputMustBe("null");
-        }
-
-        TEST_METHOD(EmptyString)
-        {
-            whenInputIs("");
-            outputMustBe("\"\"");
-        }
-
-        TEST_METHOD(QuotationMark)
-        {
-            whenInputIs("\"");
-            outputMustBe("\"\\\"\"");
-        }
-
-        TEST_METHOD(ReverseSolidus)
-        {
-            whenInputIs("\\");
-            outputMustBe("\"\\\\\"");
-        }
-
-        TEST_METHOD(Solidus)
-        {
-            whenInputIs("/");
-            outputMustBe("\"/\""); // but the JSON format allows \/
-        }
-
-        TEST_METHOD(Backspace)
-        {
-            whenInputIs("\b");
-            outputMustBe("\"\\b\"");
-        }
-
-        TEST_METHOD(Formfeed)
-        {
-            whenInputIs("\f");
-            outputMustBe("\"\\f\"");
-        }
-
-        TEST_METHOD(Newline)
-        {
-            whenInputIs("\n");
-            outputMustBe("\"\\n\"");
-        }
-
-        TEST_METHOD(CarriageReturn)
-        {
-            whenInputIs("\r");
-            outputMustBe("\"\\r\"");
-        }
-
-        TEST_METHOD(HorizontalTab)
-        {
-            whenInputIs("\t");
-            outputMustBe("\"\\t\"");
-        }
-
-    private:
-        void whenInputIs(const char* input)
-        {
-            StringBuilder sb(buffer, sizeof(buffer));            
-            escapedString.set(input);
-            returnValue = escapedString.printTo(sb);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), returnValue);
-        }
-    };
-}

JsonGeneratorTests/JsonArrayTests.cpp

@@ -1,173 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Generator;
-
-namespace JsonGeneratorTests
-{		
-    TEST_CLASS(JsonArrayTests)
-    {
-        JsonArray<2> arr;
-        char buffer[256];
-
-    public:
-        
-        TEST_METHOD(Empty)
-        {
-            outputMustBe("[]");
-        }
-
-        TEST_METHOD(Null)
-        {
-            add((char*)0);
-
-            outputMustBe("[null]");
-        }
-
-        TEST_METHOD(OneString)
-        {
-            add("hello");
-
-            outputMustBe("[\"hello\"]");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            add("hello");
-            add("world");
-
-            outputMustBe("[\"hello\",\"world\"]");
-        }
-
-        TEST_METHOD(OneStringOverCapacity)
-        {
-            add("hello");
-            add("world");
-            add("lost");
-
-            outputMustBe("[\"hello\",\"world\"]");
-        }
-
-        TEST_METHOD(OneDoubleDefaultDigits)
-        {
-            add(3.14159265358979323846);
-            outputMustBe("[3.14]");
-        }
-
-        TEST_METHOD(OneDoubleFourDigits)
-        {
-            add<4>(3.14159265358979323846);
-            outputMustBe("[3.1416]");
-        }
-
-        TEST_METHOD(OneInteger)
-        {
-            add(1);
-
-            outputMustBe("[1]");
-        }
-
-        TEST_METHOD(TwoIntegers)
-        {
-            add(1);
-            add(2);
-
-            outputMustBe("[1,2]");
-        }
-
-        TEST_METHOD(OneIntegerOverCapacity)
-        {
-            add(1);
-            add(2);
-            add(3);
-
-            outputMustBe("[1,2]");
-        }
-
-        TEST_METHOD(OneTrue)
-        {
-            add(true);
-
-            outputMustBe("[true]");
-        }
-
-        TEST_METHOD(OneFalse)
-        {
-            add(false);
-
-            outputMustBe("[false]");
-        }
-
-        TEST_METHOD(TwoBooleans)
-        {
-            add(false);
-            add(true);
-
-            outputMustBe("[false,true]");
-        }
-
-        TEST_METHOD(OneBooleanOverCapacity)
-        {
-            add(false);
-            add(true);
-            add(false);
-
-            outputMustBe("[false,true]");
-        }
-
-        TEST_METHOD(OneEmptyNestedArray)
-        {
-           addNested(JsonArray<1>());
-            outputMustBe("[[]]");
-        }
-
-        TEST_METHOD(OneEmptyNestedHash)
-        {
-            addNested(JsonHashTable<1>());
-            outputMustBe("[{}]");
-        }
-
-        TEST_METHOD(OneNestedArrayWithOneInteger)
-        {
-            JsonArray<1> nestedArray;
-            nestedArray.add(1);
-
-            addNested(nestedArray);
-
-            outputMustBe("[[1]]");
-        }
-
-    private:
-
-        void addNested(JsonObjectBase& value)
-        {
-            arr.add<JsonObjectBase&>(value);
-        }
-
-        template<typename T>
-        void add(T value)
-        {
-            arr.add(value);
-        }
-
-        template<int DIGITS>
-        void add(double value)
-        {
-            arr.add<DIGITS>(value);
-        }
-
-        void outputMustBe(const char* expected)
-        {      
-            size_t n = arr.printTo(buffer, sizeof(buffer));
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), n);
-        }
-    };
-}

JsonGeneratorTests/JsonGeneratorTests.vcxproj

@@ -1,114 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{B9545D97-E084-4A19-8E48-929157064360}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>JsonGeneratorTests</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir)/../JsonGenerator;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir)/../JsonGenerator;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\JsonGenerator\EscapedString.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonArrayBase.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonHashTableBase.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonValue.cpp" />
-    <ClCompile Include="..\JsonGenerator\StringBuilder.cpp" />
-    <ClCompile Include="EscapedStringTests.cpp" />
-    <ClCompile Include="JsonArrayTests.cpp" />
-    <ClCompile Include="JsonHashTableTests.cpp" />
-    <ClCompile Include="JsonValueTests.cpp" />
-    <ClCompile Include="Print.cpp" />
-    <ClCompile Include="StringBuilderTests.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\JsonGenerator\EscapedString.h" />
-    <ClInclude Include="..\JsonGenerator\JsonArray.h" />
-    <ClInclude Include="..\JsonGenerator\JsonArrayBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonHashTable.h" />
-    <ClInclude Include="..\JsonGenerator\JsonHashTableBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonObjectBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonValue.h" />
-    <ClInclude Include="..\JsonGenerator\Print.h" />
-    <ClInclude Include="..\JsonGenerator\Printable.h" />
-    <ClInclude Include="..\JsonGenerator\StringBuilder.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

JsonGeneratorTests/JsonGeneratorTests.vcxproj.filters

@@ -1,84 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="JsonArrayTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonHashTableTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonValueTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonValue.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\StringBuilder.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="StringBuilderTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Print.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\EscapedString.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonHashTableBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonArrayBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="EscapedStringTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\JsonGenerator\JsonArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonHashTable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonObjectBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonValue.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\Print.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\Printable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\StringBuilder.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\EscapedString.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonHashTableBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonArrayBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-</Project>

JsonGeneratorTests/JsonHashTableTests.cpp

@@ -1,124 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Generator;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(JsonHashTableTests)
-    {
-        JsonHashTable<2> hash;
-        char buffer[256];
-
-    public:
-        
-        TEST_METHOD(Empty)
-        {
-            outputMustBe("{}");
-        }
-
-        TEST_METHOD(OneString)
-        {
-            add("key", "value");
-            outputMustBe("{\"key\":\"value\"}");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            add("key1", "value1");
-            add("key2", "value2");
-
-            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
-        }
-
-        TEST_METHOD(OneStringOverCapacity)
-        {
-            add("key1", "value1");
-            add("key2", "value2");
-            add("key3", "value3");
-
-            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
-        }
-
-        TEST_METHOD(OneInteger)
-        {
-            add("key", 1);
-            outputMustBe("{\"key\":1}");
-        }
-
-        TEST_METHOD(OneDoubleFourDigits)
-        {
-            add<4>("key", 3.14159265358979323846);
-            outputMustBe("{\"key\":3.1416}");
-        }
-
-        TEST_METHOD(OneDoubleDefaultDigits)
-        {
-            add("key", 3.14159265358979323846);
-            outputMustBe("{\"key\":3.14}");
-        }
-
-        TEST_METHOD(OneNull)
-        {
-            add("key", (char*) 0);
-            outputMustBe("{\"key\":null}");
-        }
-
-        TEST_METHOD(OneTrue)
-        {
-            add("key", true);
-            outputMustBe("{\"key\":true}");
-        }
-
-        TEST_METHOD(OneFalse)
-        {
-            add("key", false);
-            outputMustBe("{\"key\":false}");
-        }
-
-        TEST_METHOD(OneEmptyNestedArray)
-        {
-            addNested("key", JsonArray<1>());
-            outputMustBe("{\"key\":[]}");
-        }
-
-        TEST_METHOD(OneEmptyNestedHash)
-        {
-            addNested("key", JsonHashTable<1>());
-            outputMustBe("{\"key\":{}}");
-        }
-
-    private:
-        
-        void addNested(const char* key, JsonObjectBase& value)
-        {
-            hash.add<JsonObjectBase&>(key, value);
-        }
-
-        template<typename T>
-        void add(const char* key, T value)
-        {
-            hash.add(key, value);
-        }
-
-        template<int DIGITS>
-        void add(const char* key, double value)
-        {
-            hash.add<DIGITS>(key, value);
-        }
-
-        void outputMustBe(const char* expected)
-        {            
-            size_t actual = hash.printTo(buffer, sizeof(buffer));
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), actual);
-        }
-    };
-}

JsonGeneratorTests/JsonValueTests.cpp

@@ -1,102 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "StringBuilder.h"
-#include "JsonValue.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Internals;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(JsonValueTests)
-    {
-        char buffer[1024];
-        size_t returnValue;
-
-    public:
-
-        TEST_METHOD(String)
-        {
-            whenInputIs("hello");
-            outputMustBe("\"hello\"");
-        }
-
-        TEST_METHOD(Float)
-        {
-            whenInputIs(3.1415f);
-            outputMustBe("3.14");
-        }
-
-        TEST_METHOD(DoubleZeroDigits)
-        {
-            whenInputIs<0>(3.14159265358979323846);
-            outputMustBe("3");
-        }
-
-        TEST_METHOD(DoubleOneDigit)
-        {
-            whenInputIs<1>(3.14159265358979323846);
-            outputMustBe("3.1");
-        }
-
-        TEST_METHOD(DoubleTwoDigits)
-        {
-            whenInputIs<2>(3.14159265358979323846);
-            outputMustBe("3.14");
-        }
-        
-        TEST_METHOD(Integer)
-        {
-            whenInputIs(314);
-            outputMustBe("314");
-        }
-
-        TEST_METHOD(Char)
-        {
-            whenInputIs('A');
-            outputMustBe("65");
-        }
-
-        TEST_METHOD(Short)
-        {
-            whenInputIs((short)314);
-            outputMustBe("314");
-        }
-
-        TEST_METHOD(Long)
-        {
-            whenInputIs(314159265L);
-            outputMustBe("314159265");
-        }
-
-    private:
-
-        template<int DIGITS>
-        void whenInputIs(double value)
-        {
-            StringBuilder sb(buffer, sizeof(buffer));
-            JsonValue jsonValue;
-            jsonValue.set<DIGITS>(value);
-            returnValue = jsonValue.printTo(sb);
-        }
-
-        template<typename T>
-        void whenInputIs(T value)
-        {
-            StringBuilder sb(buffer, sizeof(buffer));
-            JsonValue jsonValue;
-            jsonValue.set(value);
-            returnValue = jsonValue.printTo(sb);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-            Assert::AreEqual(strlen(expected), returnValue);
-        }
-    };
-}

JsonGeneratorTests/Print.cpp

@@ -1,35 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#ifndef ARDUINO
-
-#include "Print.h"
-#include <cstdio>
-
-size_t Print::print(const char s[])
-{
-    size_t n = 0;
-    while (*s)
-    {
-        n += write(*s++);
-    }
-    return n;
-}
-
-size_t Print::print(double value, int digits)
-{
-    char tmp[32];
-    sprintf(tmp, "%.*lg", digits+1, value);
-    return print(tmp);
-}
-
-size_t Print::print(long value)
-{
-    char tmp[32];
-    sprintf(tmp, "%ld", value);
-    return print(tmp);
-}
-
-#endif

JsonGeneratorTests/StringBuilderTests.cpp

@@ -1,85 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "StringBuilder.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Internals;
-
-namespace JsonGeneratorTests
-{
-    TEST_CLASS(StringBuilderTests)
-    {
-        char buffer[20];
-        Print* sb;
-        size_t returnValue;
-
-    public:
-        
-        TEST_METHOD_INITIALIZE(Initialize)
-        {
-            sb = new StringBuilder(buffer, sizeof(buffer));
-        }
-
-        TEST_METHOD(InitialState)
-        {
-            outputMustBe("");
-        }
-
-        TEST_METHOD(OverCapacity)
-        {
-            print("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
-            resultMustBe(19);
-
-            print("ABC");
-            resultMustBe(0);
-
-            outputMustBe("ABCDEFGHIJKLMNOPQRS");
-        }
-
-        TEST_METHOD(EmptyString)
-        {
-            print("");
-            resultMustBe(0);
-            outputMustBe("");
-        }
-
-        TEST_METHOD(OneString)
-        {
-            print("ABCD");
-            resultMustBe(4);
-            outputMustBe("ABCD");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            print("ABCD");
-            resultMustBe(4);
-
-            print("EFGH");
-            resultMustBe(4);
-
-            outputMustBe("ABCDEFGH");
-        }
-
-    private:
-
-        void print(const char* value)
-        {
-            returnValue = sb->print(value);
-        }
-
-        void outputMustBe(const char* expected)
-        {
-            Assert::AreEqual(expected, buffer);
-        }
-
-        void resultMustBe(size_t expected)
-        {
-            Assert::AreEqual(expected, returnValue);
-        }
-    };
-}

JsonParser.cpp

@@ -1,12 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-// This file is here to help the Arduino IDE find the .cpp files
-
-#include "JsonParser/JsonArray.cpp"
-#include "JsonParser/JsonHashTable.cpp"
-#include "JsonParser/JsonObjectBase.cpp"
-#include "JsonParser/JsonParserBase.cpp"
-#include "JsonParser/jsmn.cpp"

JsonParser.h

@@ -1,6 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonParser/JsonParser.h"

JsonParser/JsonArray.cpp

@@ -1,69 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-using namespace ArduinoJson::Parser;
-
-JsonArray::JsonArray(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (tokens == 0 || tokens[0].type != JSMN_ARRAY)
-		makeInvalid();
-}
-
-
-/*
-* Returns the token for the value at the specified index
-*/
-jsmntok_t* JsonArray::getToken(int index)
-{
-	// sanity check
-	if (json == 0 || tokens == 0 || index < 0 || index >= tokens[0].size)
-		return 0;
-
-	// skip first token, it's the whole object
-	jsmntok_t* currentToken = tokens + 1;
-
-	// skip all tokens before the specified index
-	for (int i = 0; i < index; i++)
-	{
-		// move forward: current + nested tokens
-		currentToken += 1 + getNestedTokenCount(currentToken);
-	}
-
-	return currentToken;
-}
-
-JsonArray JsonArray::getArray(int index)
-{
-	return JsonArray(json, getToken(index));
-}
-
-bool JsonArray::getBool(int index)
-{
-	return getBoolFromToken(getToken(index));
-}
-
-double JsonArray::getDouble(int index)
-{
-	return getDoubleFromToken(getToken(index));
-}
-
-JsonHashTable JsonArray::getHashTable(int index)
-{
-	return JsonHashTable(json, getToken(index));
-}
-
-long JsonArray::getLong(int index)
-{
-	return getLongFromToken(getToken(index));
-}
-
-char* JsonArray::getString(int index)
-{
-	return getStringFromToken(getToken(index));
-}

JsonParser/JsonArray.h

@@ -1,43 +0,0 @@
-/*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
-
-#pragma once
-
-#include "JsonObjectBase.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        class JsonHashTable;
-
-        class JsonArray : public JsonObjectBase
-        {
-            friend class JsonParserBase;
-            friend class JsonHashTable;
-
-        public:
-
-            JsonArray()	{}
-
-            int getLength()
-            {
-                return tokens != 0 ? tokens[0].size : 0;
-            }
-
-            JsonArray getArray(int index);
-            bool getBool(int index);
-            double getDouble(int index);
-            JsonHashTable getHashTable(int index);
-            long getLong(int index);
-            char* getString(int index);
-
-        private:
-
-            JsonArray(char* json, jsmntok_t* tokens);
-            jsmntok_t* getToken(int index);
-        };
-    }
-}

JsonParser/JsonHashTable.cpp

@@ -1,85 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include <string.h> // for strcmp()
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-using namespace ArduinoJson::Parser;
-
-JsonHashTable::JsonHashTable(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (tokens == 0 || tokens[0].type != JSMN_OBJECT)
-		makeInvalid();
-}
-
-/*
-* Returns the token for the value associated with the specified key
-*/
-jsmntok_t* JsonHashTable::getToken(const char* desiredKey)
-{	
-	// sanity check
-	if (json == 0 || tokens == 0 || desiredKey == 0)
-		return 0;
-
-	// skip first token, it's the whole object
-	jsmntok_t* currentToken = tokens + 1;
-
-	// scan each keys
-	for (int i = 0; i < tokens[0].size / 2 ; i++)
-	{
-		// get key token string
-		char* key = getStringFromToken(currentToken);
-
-		// compare with desired name
-		if (strcmp(desiredKey, key) == 0)
-		{
-			// return the value token that follows the key token
-			return currentToken + 1;
-		}
-
-		// move forward: key + value + nested tokens
-		currentToken += 2 + getNestedTokenCount(currentToken + 1);
-	}
-
-	// nothing found, return NULL
-	return 0; 
-}
-
-bool JsonHashTable::containsKey(const char* key)
-{
-	return getToken(key) != 0;
-}
-
-JsonArray JsonHashTable::getArray(const char* key)
-{
-	return JsonArray(json, getToken(key));
-}
-
-bool JsonHashTable::getBool(const char* key)
-{
-	return getBoolFromToken(getToken(key));
-}
-
-double JsonHashTable::getDouble(const char* key)
-{
-	return getDoubleFromToken(getToken(key));
-}
-
-JsonHashTable JsonHashTable::getHashTable(const char* key)
-{
-	return JsonHashTable(json, getToken(key));
-}
-
-long JsonHashTable::getLong(const char* key)
-{
-	return getLongFromToken(getToken(key));
-}
-
-char* JsonHashTable::getString(const char* key)
-{
-	return getStringFromToken(getToken(key));
-}

JsonParser/JsonHashTable.h

@@ -1,40 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonObjectBase.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        class JsonArray;
-
-        class JsonHashTable : public JsonObjectBase
-        {
-            friend class JsonParserBase;
-            friend class JsonArray;
-
-        public:
-
-            JsonHashTable() {}
-
-            bool containsKey(const char* key);
-
-            JsonArray getArray(const char* key);
-            bool getBool(const char* key);
-            double getDouble(const char* key);
-            JsonHashTable getHashTable(const char* key);
-            long getLong(const char* key);
-            char* getString(const char* key);
-
-        private:
-
-            JsonHashTable(char* json, jsmntok_t* tokens);
-            jsmntok_t* getToken(const char* key);
-        };
-    }
-}

JsonParser/JsonObjectBase.cpp

@@ -1,67 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include <stdlib.h> // for strtol, strtod
-#include "JsonObjectBase.h"
-
-using namespace ArduinoJson::Parser;
-
-int JsonObjectBase::getNestedTokenCount(jsmntok_t* token)
-{
-    int tokensToVisit = token->size;
-    int count = 0;
-
-    while (tokensToVisit)
-    {
-        count++;
-        token++;
-        tokensToVisit--;
-        tokensToVisit += token->size;
-    }
-
-    return count;
-}
-
-bool JsonObjectBase::getBoolFromToken(jsmntok_t* token)
-{
-    if (token == 0 || token->type != JSMN_PRIMITIVE) return 0;
-
-    // "true"
-    if (json[token->start] == 't') return true;
-
-    // "false"
-    if (json[token->start] == 'f') return false;
-
-    // "null"
-    if (json[token->start] == 'n') return false;
-    
-    // number
-    return strtol(json + token->start, 0, 0) != 0;
-}
-
-double JsonObjectBase::getDoubleFromToken(jsmntok_t* token)
-{
-    if (token == 0 || token->type != JSMN_PRIMITIVE) return 0;
-
-    return strtod(json + token->start, 0);
-}
-
-long JsonObjectBase::getLongFromToken(jsmntok_t* token)
-{
-    if (token == 0 || token->type != JSMN_PRIMITIVE) return 0;
-
-    return strtol(json + token->start, 0, 0);
-}
-
-char* JsonObjectBase::getStringFromToken(jsmntok_t* token)
-{
-    if (token == 0 || token->type != JSMN_PRIMITIVE && token->type != JSMN_STRING)
-        return 0;
-
-    // add null terminator to the string
-    json[token->end] = 0;
-
-    return json + token->start;
-}

JsonParser/JsonObjectBase.h

@@ -1,53 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "jsmn.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        class JsonObjectBase
-        {
-        public:
-
-            JsonObjectBase()
-            {
-                makeInvalid();
-            }
-
-            bool success()
-            {
-                return json != 0 && tokens != 0;
-            }
-
-        protected:
-
-            JsonObjectBase(char* json, jsmntok_t* tokens)
-            {
-                this->json = json;
-                this->tokens = tokens;
-            }
-
-            void makeInvalid()
-            {
-                json = 0;
-                tokens = 0;
-            }
-
-            static int getNestedTokenCount(jsmntok_t* token);
-
-            bool getBoolFromToken(jsmntok_t* token);
-            double getDoubleFromToken(jsmntok_t* token);
-            long getLongFromToken(jsmntok_t* token);
-            char* getStringFromToken(jsmntok_t* token);
-
-            char* json;
-            jsmntok_t* tokens;
-        };
-    }
-}

JsonParser/JsonParser.h

@@ -1,40 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonParserBase.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        /*
-        * The JSON parser.
-        *
-        * You need to specifiy the number of token to be allocated for that parser.
-        * Values from 16 to 32 are recommended.
-        * The parser size will be MAX_TOKEN*8 bytes.
-        * Don't forget that the memory size of standard Arduino board is only 2KB
-        *
-        * CAUTION: JsonArray and JsonHashTable contain pointers to tokens of the
-        * JsonParser, so they need the JsonParser to be in memory to work.
-        * As a result, you must not create JsonArray and JsonHashTable that have a
-        * longer life that the JsonParser.
-        */
-        template <int MAX_TOKENS>
-        class JsonParser : public JsonParserBase
-        {
-        public:
-            JsonParser()
-                : JsonParserBase(tokens, MAX_TOKENS)
-            {
-            }
-
-        private:
-            jsmntok_t tokens[MAX_TOKENS];
-        };
-    }
-}

JsonParser/JsonParserBase.cpp

@@ -1,19 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonParserBase.h"
-
-using namespace ArduinoJson::Parser;
-
-jsmntok_t* JsonParserBase::parse(char* json)
-{
-    jsmn_parser parser;
-    jsmn_init(&parser);
-
-    if (JSMN_SUCCESS != jsmn_parse(&parser, json, tokens, maxTokens))
-        return 0;
-
-    return tokens;
-}

JsonParser/JsonParserBase.h

@@ -1,53 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#pragma once
-
-#include "JsonHashTable.h"
-#include "JsonArray.h"
-
-namespace ArduinoJson
-{
-    namespace Parser
-    {
-        class JsonParserBase
-        {
-        public:
-
-            JsonParserBase(jsmntok_t* tokens, int maxTokens)
-                : tokens(tokens), maxTokens(maxTokens)
-            {
-            }
-
-            /*
-            * Parse the JSON string and return a array.
-            *
-            * The content of the string may be altered to add '\0' at the
-            * end of string tokens
-            */
-            JsonArray parseArray(char* json)
-            {
-                return JsonArray(json, parse(json));
-            }
-
-            /*
-            * Parse the JSON string and return a array.
-            *
-            * The content of the string may be altered to add '\0' at the
-            * end of string tokens
-            */
-            JsonHashTable parseHashTable(char* json)
-            {
-                return JsonHashTable(json, parse(json));
-            }
-
-        private:
-            jsmntok_t* tokens;
-            int maxTokens;
-
-            jsmntok_t* parse(char* json);
-        };
-    }
-}

JsonParser/README.md

@@ -1,404 +0,0 @@
-Arduino JSON library - Parser
-=============================
-
-This library is an thin C++ wrapper around the *jsmn* tokenizer: http://zserge.com/jsmn.html
-
-It's design to be very lightweight, works without any allocation on the heap (no malloc) and supports nested objects.
-
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
-
-
-Features
---------
-
-* Based on the well-proven [jsmn](http://zserge.com/jsmn.html) tokenizer
-* Supports nested objects
-* Elegant API, very easy to use 
-* Fixed memory allocation (no malloc)
-* Small footprint
-* MIT License
-
-
-Example
--------
-
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-
-    JsonParser<32> parser;
-
-    JsonHashTable root = parser.parseHashTable(json);
-
-    char* sensor = root.getString("sensor");
-
-    long time = root.getLong("time");
-    
-    JsonArray coords = root.getArray("data");
-
-
-How to  use ?
--------------
-
-### 1. Install the library
-
-Download the library and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJson
-
-### 2. Import in your sketch
-
-Just add the following lines at the top of your `.ino` file:
-
-    #include <JsonParser.h>
-
-    using namespace ArduinoJson::Parser;
-    
-### 3. Create a parser
-
-To extract data from the JSON string, you need to create a `JsonParser`, and specify the number of token you allocate for the parser itself:
-
-    JsonParser<32> parser;
-    
-> #### How to choose the number of tokens ?
-
-> A token is an element of the JSON object: either a key, a value, an hash-table or an array.
-> As an example the `char json[]` on the top of this page contains 12 tokens (don't forget to count 1 for the whole object and 1 more for the array itself).
-
-> The more tokens you allocate, the more complex the JSON can be, but also the more memory is occupied.
-> Each token takes 8 bytes, so `sizeof(JsonParser<32>)` is 256 bytes which is quite big in an Arduino with only 2KB of RAM.
-> Don't forget that you also have to store the JSON string in RAM and it's probably big.
-
-> 32 tokens may seem small, but it's very decent for an 8-bit processor, you wouldn't get better results with other JSON libraries.
-
-### 4. Extract data
-
-To use this library, you need to know beforehand what is the type of data contained in the JSON string, which is very likely.
-
-The root object has to be either a hash-table (like `{"key":"value"}`) or an array (like `[1,2]`). 
-
-The nested objects can be either arrays, booleans, hash-tables, numbers or strings.
-If you need other type, you can get the string value and parse it yourself.
-
-#### Hash-table
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    {
-        "Name":"Blanchon",
-        "Skills":[
-            "C",
-            "C++",
-            "C#"],
-        "Age":32,
-        "Online":true
-    }
-
-In this case the root object of the JSON string is a hash-table, so you need to extract a `JsonHashTable`:
-   
-    JsonHashTable root = parser.parseHashTable(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the member you need:
-    
-    char* name = hashTable.getString("Name");
-
-    JsonArray skills = hashTable.getArray("Skills");
-
-    int age = hashTable.getLong("Age");
-
-    bool online = hashTable.getBool("Online");
-    
-#### Array
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    [
-        [ 1.2, 3.4 ],
-        [ 5.6, 7.8 ]               
-    ]
-
-In this case the root object of the JSON string is an array, so you need to extract a `JsonArray`:
-   
-    JsonArray root = parser.parseArray(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the content by its index in the array:
-    
-    JsonArray row0 = root.getArray(0);
-    double a = row0.getDouble(0);
-    
-or simply:
-
-    double a = root.getArray(0).getDouble(0);
-
-
-Common pitfalls
----------------
-
-### 1. Not enough tokens
-
-By design, the library has no way to tell you why `JsonParser::parseArray()` or `JsonParser::parseHashTable()` failed.
-
-There are basically two reasons why they may fail:
-
-1. the JSON string is invalid
-2. the JSON string contains more tokens that the parser can store
-
-So, if you are sure the JSON string is correct and you still can't parse it, you should slightly increase the number of token of the parser.
-
-### 2. Not enough memory
-
-You may go into unpredictable trouble if you allocate more memory than your processor really has.
-It's a very common issue in embedded development. 
-
-To diagnose this, look at every big objects in you code and sum their size to check that they fit in RAM.
-
-For example, don't do this:
-
-    char json[1024];        // 1 KB
-    JsonParser<64> parser;    // 512 B
-
-because it may be too big for a processor with only 2 KB: you need free memory to store other variables and the call stack.
-
-That is why an 8-bit processor is not able to parse long and complex JSON strings.
-
-### 3. JsonParser not in memory
-
-To reduce the memory consumption, `JsonArray` and `JsonHashTable` contains pointer to the token that are inside the `JsonParser`. This can only work if the `JsonParser` is still in memory.
-
-For example, don't do this:
-
-    JsonArray getArray(char* json)
-    {
-        JsonParser<16> parser;
-        return parser.parseArray(parser); 
-    }
-
-because the local variable `parser` will be *removed* from memory when the function `getArray()` returns, and the pointer inside `JsonArray` will point to an invalid location.
-
-### 4. JSON string is altered
-
-This will probably never be an issue, but you need to be aware of this feature.
-
-When you pass a `char[]` to `JsonParser::parseArray()` or `JsonParser::parseHashTable()`, the content of the string will be altered to add `\0` at the end of the tokens.
-
-This is because we want functions like `JsonArray::getString()` to return a null-terminating string without any memory allocation.
-   
-
-Memory usage
-------------
-
-Here are the size of the main classes of the library.
-
-This table is for an 8-bit Arduino, types would be bigger on a 32-bit processor.
-
-<table>
-    <tr>
-        <th>Type</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>Parser&lt;N&gt;</td>
-        <td>4 + 8 x N</td>
-    </tr>
-    <tr>
-        <td>JsonArray</td>
-        <td>4</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable</td>
-        <td>4</td>
-    </tr>
-</table> 
-
-
-Code size
----------
-
-Theses tables has been created by analyzing the map file generated by AVR-GCC after adding `-Wl,-Map,foo.map` to the command line.
-
-As you'll see the code size is between 1680 and 3528 bytes, depending on the features you use.
-
-### Minimum setup
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strcmp(char*,char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>jsmn_init(jsmn_parser*)</td>
-        <td>20</td>
-    </tr>
-    <tr>
-        <td>jsmn_parse(jsmn_parser*, char const*, jsmntok_t*, unsigned int)</td>
-        <td>960</td>
-    </tr>
-    <tr>
-        <td>JsonParser::parse(char*)</td>
-        <td>106</td>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getNestedTokenCount(jsmntok_t*)</td>
-        <td>84</td>        
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getStringFromToken(jsmntok_t*)</td>
-        <td>68</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::JsonArray(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getToken(int)</td>
-        <td>112</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getString(int)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::JsonHashTable(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getToken(char*)</td>
-        <td>180</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getString(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>1680</td>
-    </tr>
-</table>
-
-### Additional space to parse nested  objects
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonArray::getArray(int)</td>
-        <td>42</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getHashTable(int)</td>
-        <td>64</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getArray(char*)</td>
-        <td>64</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::getHashTable(char*)</td>
-        <td>42</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>212</td>
-    </tr>
-</table>
-
-### Additional space to parse `bool` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getBoolFromToken(jsmntok_t*)</td>
-        <td>82</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getBool(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getBool(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>130</td>
-    </tr>
-</table>
-
-### Additional space to parse `double` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtod(char*,int)</td>
-        <td>704</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getDoubleFromToken(jsmntok_t*)</td>
-        <td>44</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getDouble(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getDouble(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>796</td>
-    </tr>
-</table>
-
-### Additional space to parse `long` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtol(char*,char**,int)</td>
-        <td>606</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getLongFromToken(jsmntok_t*)</td>
-        <td>56</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getLong(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getLong(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>710</td>
-    </tr>
-</table>

JsonParser/jsmn.cpp

@@ -1,255 +0,0 @@
-#include <stdlib.h>
-
-#include "jsmn.h"
-
-/**
- * Allocates a fresh unused token from the token pull.
- */
-static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser, 
-		jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *tok;
-	if (parser->toknext >= num_tokens) {
-		return NULL;
-	}
-	tok = &tokens[parser->toknext++];
-	tok->start = tok->end = -1;
-	tok->size = 0;
-#ifdef JSMN_PARENT_LINKS
-	tok->parent = -1;
-#endif
-	return tok;
-}
-
-/**
- * Fills token type and boundaries.
- */
-static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type, 
-                            int start, int end) {
-	token->type = type;
-	token->start = start;
-	token->end = end;
-	token->size = 0;
-}
-
-/**
- * Fills next available token with JSON primitive.
- */
-static jsmnerr_t jsmn_parse_primitive(jsmn_parser *parser, const char *js,
-		jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *token;
-	int start;
-
-	start = parser->pos;
-
-	for (; js[parser->pos] != '\0'; parser->pos++) {
-		switch (js[parser->pos]) {
-#ifndef JSMN_STRICT
-			/* In strict mode primitive must be followed by "," or "}" or "]" */
-			case ':':
-#endif
-			case '\t' : case '\r' : case '\n' : case ' ' :
-			case ','  : case ']'  : case '}' :
-				goto found;
-		}
-		if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
-			parser->pos = start;
-			return JSMN_ERROR_INVAL;
-		}
-	}
-#ifdef JSMN_STRICT
-	/* In strict mode primitive must be followed by a comma/object/array */
-	parser->pos = start;
-	return JSMN_ERROR_PART;
-#endif
-
-found:
-	token = jsmn_alloc_token(parser, tokens, num_tokens);
-	if (token == NULL) {
-		parser->pos = start;
-		return JSMN_ERROR_NOMEM;
-	}
-	jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
-#ifdef JSMN_PARENT_LINKS
-	token->parent = parser->toksuper;
-#endif
-	parser->pos--;
-	return JSMN_SUCCESS;
-}
-
-/**
- * Filsl next token with JSON string.
- */
-static jsmnerr_t jsmn_parse_string(jsmn_parser *parser, const char *js,
-		jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *token;
-
-	int start = parser->pos;
-
-	parser->pos++;
-
-	/* Skip starting quote */
-	for (; js[parser->pos] != '\0'; parser->pos++) {
-		char c = js[parser->pos];
-
-		/* Quote: end of string */
-		if (c == '\"') {
-			token = jsmn_alloc_token(parser, tokens, num_tokens);
-			if (token == NULL) {
-				parser->pos = start;
-				return JSMN_ERROR_NOMEM;
-			}
-			jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
-#ifdef JSMN_PARENT_LINKS
-			token->parent = parser->toksuper;
-#endif
-			return JSMN_SUCCESS;
-		}
-
-		/* Backslash: Quoted symbol expected */
-		if (c == '\\') {
-			parser->pos++;
-			switch (js[parser->pos]) {
-				/* Allowed escaped symbols */
-				case '\"': case '/' : case '\\' : case 'b' :
-				case 'f' : case 'r' : case 'n'  : case 't' :
-					break;
-				/* Allows escaped symbol \uXXXX */
-				case 'u':
-					/* TODO */
-					break;
-				/* Unexpected symbol */
-				default:
-					parser->pos = start;
-					return JSMN_ERROR_INVAL;
-			}
-		}
-	}
-	parser->pos = start;
-	return JSMN_ERROR_PART;
-}
-
-/**
- * Parse JSON string and fill tokens.
- */
-jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js, jsmntok_t *tokens, 
-		unsigned int num_tokens) {
-	jsmnerr_t r;
-	int i;
-	jsmntok_t *token;
-
-	for (; js[parser->pos] != '\0'; parser->pos++) {
-		char c;
-		jsmntype_t type;
-
-		c = js[parser->pos];
-		switch (c) {
-			case '{': case '[':
-				token = jsmn_alloc_token(parser, tokens, num_tokens);
-				if (token == NULL)
-					return JSMN_ERROR_NOMEM;
-				if (parser->toksuper != -1) {
-					tokens[parser->toksuper].size++;
-#ifdef JSMN_PARENT_LINKS
-					token->parent = parser->toksuper;
-#endif
-				}
-				token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
-				token->start = parser->pos;
-				parser->toksuper = parser->toknext - 1;
-				break;
-			case '}': case ']':
-				type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
-#ifdef JSMN_PARENT_LINKS
-				if (parser->toknext < 1) {
-					return JSMN_ERROR_INVAL;
-				}
-				token = &tokens[parser->toknext - 1];
-				for (;;) {
-					if (token->start != -1 && token->end == -1) {
-						if (token->type != type) {
-							return JSMN_ERROR_INVAL;
-						}
-						token->end = parser->pos + 1;
-						parser->toksuper = token->parent;
-						break;
-					}
-					if (token->parent == -1) {
-						break;
-					}
-					token = &tokens[token->parent];
-				}
-#else
-				for (i = parser->toknext - 1; i >= 0; i--) {
-					token = &tokens[i];
-					if (token->start != -1 && token->end == -1) {
-						if (token->type != type) {
-							return JSMN_ERROR_INVAL;
-						}
-						parser->toksuper = -1;
-						token->end = parser->pos + 1;
-						break;
-					}
-				}
-				/* Error if unmatched closing bracket */
-				if (i == -1) return JSMN_ERROR_INVAL;
-				for (; i >= 0; i--) {
-					token = &tokens[i];
-					if (token->start != -1 && token->end == -1) {
-						parser->toksuper = i;
-						break;
-					}
-				}
-#endif
-				break;
-			case '\"':
-				r = jsmn_parse_string(parser, js, tokens, num_tokens);
-				if (r < 0) return r;
-				if (parser->toksuper != -1)
-					tokens[parser->toksuper].size++;
-				break;
-			case '\t' : case '\r' : case '\n' : case ':' : case ',': case ' ': 
-				break;
-#ifdef JSMN_STRICT
-			/* In strict mode primitives are: numbers and booleans */
-			case '-': case '0': case '1' : case '2': case '3' : case '4':
-			case '5': case '6': case '7' : case '8': case '9':
-			case 't': case 'f': case 'n' :
-#else
-			/* In non-strict mode every unquoted value is a primitive */
-			default:
-#endif
-				r = jsmn_parse_primitive(parser, js, tokens, num_tokens);
-				if (r < 0) return r;
-				if (parser->toksuper != -1)
-					tokens[parser->toksuper].size++;
-				break;
-
-#ifdef JSMN_STRICT
-			/* Unexpected char in strict mode */
-			default:
-				return JSMN_ERROR_INVAL;
-#endif
-
-		}
-	}
-
-	for (i = parser->toknext - 1; i >= 0; i--) {
-		/* Unmatched opened object or array */
-		if (tokens[i].start != -1 && tokens[i].end == -1) {
-			return JSMN_ERROR_PART;
-		}
-	}
-
-	return JSMN_SUCCESS;
-}
-
-/**
- * Creates a new parser based over a given  buffer with an array of tokens 
- * available.
- */
-void jsmn_init(jsmn_parser *parser) {
-	parser->pos = 0;
-	parser->toknext = 0;
-	parser->toksuper = -1;
-}
-

JsonParser/jsmn.h

@@ -1,67 +0,0 @@
-#ifndef __JSMN_H_
-#define __JSMN_H_
-
-/**
- * JSON type identifier. Basic types are:
- * 	o Object
- * 	o Array
- * 	o String
- * 	o Other primitive: number, boolean (true/false) or null
- */
-typedef enum {
-	JSMN_PRIMITIVE = 0,
-	JSMN_OBJECT = 1,
-	JSMN_ARRAY = 2,
-	JSMN_STRING = 3
-} jsmntype_t;
-
-typedef enum {
-	/* Not enough tokens were provided */
-	JSMN_ERROR_NOMEM = -1,
-	/* Invalid character inside JSON string */
-	JSMN_ERROR_INVAL = -2,
-	/* The string is not a full JSON packet, more bytes expected */
-	JSMN_ERROR_PART = -3,
-	/* Everything was fine */
-	JSMN_SUCCESS = 0
-} jsmnerr_t;
-
-/**
- * JSON token description.
- * @param		type	type (object, array, string etc.)
- * @param		start	start position in JSON data string
- * @param		end		end position in JSON data string
- */
-typedef struct {
-	jsmntype_t type;
-	int start;
-	int end;
-	int size;
-#ifdef JSMN_PARENT_LINKS
-	int parent;
-#endif
-} jsmntok_t;
-
-/**
- * JSON parser. Contains an array of token blocks available. Also stores
- * the string being parsed now and current position in that string
- */
-typedef struct {
-	unsigned int pos; /* offset in the JSON string */
-	int toknext; /* next token to allocate */
-	int toksuper; /* superior token node, e.g parent object or array */
-} jsmn_parser;
-
-/**
- * Create JSON parser over an array of tokens
- */
-void jsmn_init(jsmn_parser *parser);
-
-/**
- * Run JSON parser. It parses a JSON data string into and array of tokens, each describing
- * a single JSON object.
- */
-jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js, 
-		jsmntok_t *tokens, unsigned int num_tokens);
-
-#endif /* __JSMN_H_ */

JsonParserTests/GbathreeBug.cpp

@@ -1,244 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-#include <string>
-
-using namespace std;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(GbathreeBug)
-	{
-		char json[1024];
-		JsonParser<200> parser;
-		JsonHashTable root;
-		
-
-	public:
-
-		TEST_METHOD_INITIALIZE(Initialize)
-		{
-			// BUG described here:
-			// http://forum.arduino.cc/index.php?topic=172578.msg1608219#msg1608219
-			strcpy(json, "{ \"protocol_name\":\"fluorescence\",\"repeats\":1,\"wait\":0,\"averages\":1,\"measurements\":3,\"meas2_light\":15,\"meas1_baseline\":0,\"act_light\":20,\"pulsesize\":25,\"pulsedistance\":10000,\"actintensity1\":50,\"actintensity2\":255,\"measintensity\":255,\"calintensity\":255,\"pulses\":[50,50,50],\"act\":[2,1,2,2],\"red\":[2,2,2,2],\"detectors\":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]],\"alta\":[2,2,2,2],\"altb\":[2,2,2,2],\"measlights\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]],\"measlights2\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]],\"altc\":[2,2,2,2],\"altd\":[2,2,2,2]}");
-			root = parser.parseHashTable(json);
-		}
-
-		TEST_METHOD(Root)
-		{
-			Assert::IsTrue(root.success());
-		}
-
-		TEST_METHOD(ProtocolName)
-		{
-			string protocol_name = root.getString("protocol_name");
-			Assert::AreEqual(string("fluorescence"), protocol_name);
-		}
-
-		TEST_METHOD(Repeats)
-		{
-			Assert::AreEqual(1L, root.getLong("repeats"));
-		}
-
-		TEST_METHOD(Wait)
-		{
-			Assert::AreEqual(0L, root.getLong("wait"));
-		}
-
-		TEST_METHOD(Measurements)
-		{
-			Assert::AreEqual(3L, root.getLong("measurements"));
-		}
-
-		TEST_METHOD(Meas2_Light)
-		{
-			Assert::AreEqual(15L, root.getLong("meas2_light"));
-		}
-
-		TEST_METHOD(Meas1_Baseline)
-		{
-			Assert::AreEqual(0L, root.getLong("meas1_baseline"));
-		}
-
-		TEST_METHOD(Act_Light)
-		{
-			Assert::AreEqual(20L, root.getLong("act_light"));
-		}
-
-		TEST_METHOD(Pulsesize)
-		{
-			Assert::AreEqual(25L, root.getLong("pulsesize"));
-		}
-
-		TEST_METHOD(Pulsedistance)
-		{
-			Assert::AreEqual(10000L, root.getLong("pulsedistance"));
-		}
-
-		TEST_METHOD(Actintensity1)
-		{
-			Assert::AreEqual(50L, root.getLong("actintensity1"));
-		}
-				
-		TEST_METHOD(Actintensity2)
-		{
-			Assert::AreEqual(255L, root.getLong("actintensity2"));
-		}
-		
-		TEST_METHOD(Measintensity)
-		{
-			Assert::AreEqual(255L, root.getLong("measintensity"));
-		}
-		
-		TEST_METHOD(Calintensity)
-		{
-			Assert::AreEqual(255L, root.getLong("calintensity"));
-		}
-
-		TEST_METHOD(Pulses)
-		{
-			// "pulses":[50,50,50]
-
-			JsonArray array = root.getArray("pulses");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(3, array.getLength());
-
-			for (int i = 0; i < 3; i++)
-			{
-				Assert::AreEqual(50L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Act)
-		{
-			// "act":[2,1,2,2]
-
-			JsonArray array = root.getArray("act");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-			Assert::AreEqual(2L, array.getLong(0));
-			Assert::AreEqual(1L, array.getLong(1));
-			Assert::AreEqual(2L, array.getLong(2));
-			Assert::AreEqual(2L, array.getLong(3));			
-		}
-
-		TEST_METHOD(Detectors)
-		{
-			// "detectors":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]]
-
-			JsonArray array = root.getArray("detectors");
-			Assert::IsTrue(array.success());
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(4, array.getArray(i).getLength());
-
-				for (int j = 0; j < 4; j++)
-					Assert::AreEqual(34L, array.getArray(i).getLong(j));
-			}
-		}
-
-		TEST_METHOD(Alta)
-		{
-			// alta:[2,2,2,2]
-
-			JsonArray array = root.getArray("alta");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Altb)
-		{
-			// altb:[2,2,2,2]
-
-			JsonArray array = root.getArray("altb");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Measlights)
-		{
-			// "measlights":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
-
-			JsonArray array = root.getArray("measlights");
-			Assert::IsTrue(array.success());
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(4, array.getArray(i).getLength());
-
-				for (int j = 0; j < 4; j++)
-					Assert::AreEqual(15L, array.getArray(i).getLong(j));
-			}
-		}
-
-		TEST_METHOD(Measlights2)
-		{
-			// "measlights2":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
-
-			JsonArray array = root.getArray("measlights2");
-			Assert::IsTrue(array.success());
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(4, array.getArray(i).getLength());
-
-				for (int j = 0; j < 4; j++)
-					Assert::AreEqual(15L, array.getArray(i).getLong(j));
-			}
-		}
-
-		TEST_METHOD(Altc)
-		{
-			// altc:[2,2,2,2]
-
-			JsonArray array = root.getArray("altc");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(Altd)
-		{
-			// altd:[2,2,2,2]
-
-			JsonArray array = root.getArray("altd");
-			Assert::IsTrue(array.success());
-
-			Assert::AreEqual(4, array.getLength());
-
-			for (int i = 0; i < 4; i++)
-			{
-				Assert::AreEqual(2L, array.getLong(i));
-			}
-		}
-	};
-}

JsonParserTests/JsonArrayTests.cpp

@@ -1,195 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(JsonArrayTests)
-	{
-        JsonArray array;
-        char json[256];
-        jsmntok_t tokens[32];
-        JsonParserBase parser = JsonParserBase(tokens, 32);
-
-	public:
-		
-		TEST_METHOD(EmptyString)
-		{
-            whenInputIs("");
-            parseMustFail();             
-		}
-
-		TEST_METHOD(TooFewClosingBrackets)
-		{
-            whenInputIs("[[]");
-            parseMustFail();
-		}
-
-		TEST_METHOD(TooManyClosingBrackets)
-		{
-            whenInputIs("[]]");
-            parseMustFail();
-		}
-		
-        TEST_METHOD(EmptyArray)
-        {
-            whenInputIs("[]");
-            parseMustSucceed();
-            lengthMustBe(0);
-        }
-
-        TEST_METHOD(NotEnoughTokens)
-        {
-            setTokenCountTo(2);
-
-            whenInputIs("[1,2]");
-
-            parseMustFail();
-            itemMustNotExist(0);
-        }
-
-		TEST_METHOD(TwoIntegers)
-		{
-            setTokenCountTo(3);
-
-            whenInputIs("[1,2]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, 1L);
-            itemMustBe(1, 2L);
-            itemMustNotExist(2);
-		}
-
-        TEST_METHOD(TwoBooleans)
-        {
-            setTokenCountTo(3);
-
-            whenInputIs("[true,false]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, true);
-            itemMustBe(1, false);
-            itemMustNotExist(2);
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            setTokenCountTo(3);
-
-            whenInputIs("[\"hello\",\"world\"]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, "hello");
-            itemMustBe(1, "world");
-            itemMustNotExist(2);
-        }
-
-		TEST_METHOD(TwoDimensionsArray)
-		{
-            setTokenCountTo(7);
-
-            whenInputIs("[[1,2],[3,4]]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, 0, 1L);
-            itemMustBe(0, 1, 2L);
-            itemMustBe(1, 0, 3L);
-            itemMustBe(1, 1, 4L);
-            itemMustNotExist(2);
-		}
-
-        TEST_METHOD(ThreeDimensionsArray)
-        {
-            setTokenCountTo(15);
-
-            whenInputIs("[[[1,2],[3,4]],[[5,6],[7,8]]]");
-
-            parseMustSucceed();
-            lengthMustBe(2);
-            itemMustBe(0, 0, 0, 1L);
-            itemMustBe(0, 0, 1, 2L);
-            itemMustBe(0, 1, 0, 3L);
-            itemMustBe(0, 1, 1, 4L);
-            itemMustBe(1, 0, 0, 5L);
-            itemMustBe(1, 0, 1, 6L);
-            itemMustBe(1, 1, 0, 7L);
-            itemMustBe(1, 1, 1, 8L);
-            itemMustNotExist(2);
-        }        
-		
-    private:
-
-        void setTokenCountTo(int n)
-        {
-            parser = JsonParserBase(tokens, n);
-        }
-
-        void whenInputIs(const char* input)
-        {
-            strcpy(json, input);
-            array = parser.parseArray(json);
-        }
-
-        void parseMustFail()
-        {
-            Assert::IsFalse(array.success());
-            lengthMustBe(0);
-        }
-
-        void parseMustSucceed()
-        {
-            Assert::IsTrue(array.success());
-        }
-
-        void lengthMustBe(int expected)
-        {
-            Assert::AreEqual(expected, array.getLength());
-        }
-
-        void itemMustBe(int index, long expected)
-        {
-            Assert::AreEqual(expected, array.getLong(index));
-        }
-
-        void itemMustBe(int index, bool expected)
-        {
-            Assert::AreEqual(expected, array.getBool(index));
-        }
-
-        void itemMustBe(int index, const char* expected)
-        {
-            Assert::AreEqual(expected, array.getString(index));
-        }
-
-        void itemMustBe(int index0, int index1, long expected)
-        {
-            Assert::AreEqual(expected, array.getArray(index0).getLong(index1));
-        }
-
-        void itemMustBe(int index0, int index1, int index2, long expected)
-        {
-            Assert::AreEqual(expected, array.getArray(index0).getArray(index1).getLong(index2));
-        }
-
-        void itemMustNotExist(int index)
-        {
-            Assert::IsFalse(array.getHashTable(index).success());
-            Assert::IsFalse(array.getArray(index).success());
-            Assert::IsFalse(array.getBool(index));
-            Assert::AreEqual(0.0, array.getDouble(index));
-            Assert::AreEqual(0L, array.getLong(index));
-            Assert::IsNull(array.getString(index));
-        }
-	};
-}

JsonParserTests/JsonHashTableTests.cpp

@@ -1,171 +0,0 @@
-/*
-* Arduino JSON library
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-#include <string>
-
-using namespace std;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace ArduinoJsonParserTests
-{		
-    TEST_CLASS(JsonHashTableTests)
-	{
-		JsonHashTable hashTable;
-        JsonArray nestedArray;
-		char json[256];
-        jsmntok_t tokens[32];
-        JsonParserBase parser = JsonParserBase(tokens, 32);
-
-	public:
-
-        TEST_METHOD(EmptyString)
-        {
-            whenInputIs("");
-            parseMustFail();
-        }
-
-        TEST_METHOD(EmptyHashTable)
-        {
-            whenInputIs("{}");
-            parseMustSucceed();
-        }
-
-        TEST_METHOD(NotEnoughTokens)
-        {
-            setTokenCountTo(2);
-
-            whenInputIs("{\"key\":0}");
-
-            parseMustFail();
-            itemMustNotExist("key");
-        }
-
-        TEST_METHOD(TwoIntegers)
-        {
-            setTokenCountTo(5);
-
-            whenInputIs("{\"key1\":1,\"key2\":2}");
-
-            parseMustSucceed();
-            itemMustBe("key1", 1L);
-            itemMustBe("key2", 2L);
-            itemMustNotExist("key3");
-        }
-
-        TEST_METHOD(TwoBooleans)
-        {
-            setTokenCountTo(5);
-
-            whenInputIs("{\"key1\":true,\"key2\":false}");
-
-            parseMustSucceed();
-            itemMustBe("key1", true);
-            itemMustBe("key2", false);
-            itemMustNotExist("key3");
-        }
-
-        TEST_METHOD(TwoStrings)
-        {
-            setTokenCountTo(5);
-
-            whenInputIs("{\"key1\":\"hello\",\"key2\":\"world\"}");
-
-            parseMustSucceed();
-            itemMustBe("key1", "hello");
-            itemMustBe("key2", "world");
-            itemMustNotExist("key3");
-        }
-
-        TEST_METHOD(TwoNestedArrays)
-        {
-            setTokenCountTo(9);
-
-            whenInputIs("{\"key1\":[1,2],\"key2\":[3,4]}");
-            parseMustSucceed();
-
-            itemMustBeAnArray("key1");
-            arrayLengthMustBe(2);
-            arrayItemMustBe(0, 1L);
-            arrayItemMustBe(1, 2L);
-            arrayItemMustBe(2, 0L);
-
-            itemMustBeAnArray("key2");
-            arrayLengthMustBe(2);
-            arrayItemMustBe(0, 3L);
-            arrayItemMustBe(1, 4L);
-            arrayItemMustBe(2, 0L);
-
-            itemMustNotExist("key3");
-        }
-
-    private:
-
-        void setTokenCountTo(int n)
-        {
-            parser = JsonParserBase(tokens, n);
-        }
-
-        void whenInputIs(const char* input)
-        {
-            strcpy(json, input);
-            hashTable = parser.parseHashTable(json);
-        }
-
-        void parseMustFail()
-        {
-            Assert::IsFalse(hashTable.success());
-        }
-
-        void parseMustSucceed()
-        {
-            Assert::IsTrue(hashTable.success());
-        }
-
-        void itemMustBe(const char* key, long expected)
-        {
-            Assert::AreEqual(expected, hashTable.getLong(key));
-        }
-
-        void itemMustBe(const char* key, bool expected)
-        {
-            Assert::AreEqual(expected, hashTable.getBool(key));
-        }
-
-        void itemMustBe(const char* key, const char* expected)
-        {
-            Assert::AreEqual(expected, hashTable.getString(key));
-        }
-
-        void itemMustNotExist(const char* key)
-        {
-            Assert::IsFalse(hashTable.containsKey(key));
-            Assert::IsFalse(hashTable.getHashTable(key).success());
-            Assert::IsFalse(hashTable.getArray(key).success());
-            Assert::IsFalse(hashTable.getBool(key));
-            Assert::AreEqual(0.0, hashTable.getDouble(key));
-            Assert::AreEqual(0L,  hashTable.getLong(key));
-            Assert::IsNull(hashTable.getString(key));
-        }
-
-        void itemMustBeAnArray(const char* key)
-        {
-            nestedArray = hashTable.getArray(key);
-            Assert::IsTrue(nestedArray.success());
-        }
-
-        void arrayLengthMustBe(int expected)
-        {
-            Assert::AreEqual(expected, nestedArray.getLength());
-        }
-
-        void arrayItemMustBe(int index, long expected)
-        {
-            Assert::AreEqual(expected, nestedArray.getLong(index));
-        }
-	};
-}

JsonParserTests/JsonParserTests.vcxproj

@@ -1,108 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{4DD596EF-0185-4AB4-A3C2-F20C496F7806}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>ArduinoJsonParserTests</RootNamespace>
-    <ProjectName>JsonParserTests</ProjectName>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>false</UseOfMfc>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);..</IncludePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <UseFullPaths>true</UseFullPaths>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\JsonParser\jsmn.cpp" />
-    <ClCompile Include="..\JsonParser\JsonArray.cpp" />
-    <ClCompile Include="..\JsonParser\JsonHashTable.cpp" />
-    <ClCompile Include="..\JsonParser\JsonObjectBase.cpp" />
-    <ClCompile Include="..\JsonParser\JsonParserBase.cpp" />
-    <ClCompile Include="JsonArrayTests.cpp" />
-    <ClCompile Include="JsonHashTableTests.cpp" />
-    <ClCompile Include="GbathreeBug.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\JsonParser\jsmn.h" />
-    <ClInclude Include="..\JsonParser\JsonArray.h" />
-    <ClInclude Include="..\JsonParser\JsonHashTable.h" />
-    <ClInclude Include="..\JsonParser\JsonObjectBase.h" />
-    <ClInclude Include="..\JsonParser\JsonParser.h" />
-    <ClInclude Include="..\JsonParser\JsonParserBase.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

JsonParserTests/JsonParserTests.vcxproj.filters

@@ -1,63 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\JsonParser\jsmn.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonArray.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonHashTable.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonObjectBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonArrayTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="GbathreeBug.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonHashTableTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonParserBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\JsonParser\jsmn.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonHashTable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonObjectBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonParser.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonParserBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-</Project>

JsonParserTests/TestHashGenerator.cpp

@@ -1,25 +0,0 @@
-#include "stdafx.h"
-#include "CppUnitTest.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(TestHashGenerator)
-	{
-	public:
-		
-		TEST_METHOD(TestMethod1)
-		{
-            JsonArray<5> arr;
-            arr.Add(1);
-            arr.Add("Hi!");
-
-            JsonHashTable<4> hash;
-            hash.Add("key1", 1);
-            hash.Add("key2", "Hello!");
-            hash.Add("key3", arr);
-		}
-
-	};
-}

LICENSE.md

@@ -0,0 +1,10 @@
+The MIT License (MIT)
+---------------------
+
+Copyright © 2014 Benoit BLANCHON
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,46 +1,65 @@
 Arduino JSON library
 ====================
 
-*A simple and efficient JSON library for embedded systems.*
+[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson)
 
-It's design to be very lightweight, works without any allocation on the heap (no malloc).
+*An elegant and efficient JSON library for embedded systems.*
+
+It's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
 
 It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
 
 Features
 --------
 
-* JSON decoding: [more details here](/JsonParser/)
-* JSON encoding: [more details here](/JsonGenerator/)
+* JSON decoding
+* JSON encoding (with optional indentation)
 * Elegant API, very easy to use 
 * Fixed memory allocation (no malloc)
 * Small footprint
 * MIT License
 
-Feature comparison
-------------------
+Quick start
+-----------
 
-| Library      | Memory allocation | Nested objects | Parser size | Encoder size  |
-| ------------ | ----------------- | -------------- | ----------- | ------------- |
-| Arduino JSON | static            | yes            | 2616 Bytes  | 628 bytes     |
-| json-arduino | dynamic           | no             | 3348 (+28%) | not supported |
-| aJson        | dynamic           | yes            | 5088 (+94%) | 4678 (+640%)  |
+#### Decoding / Parsing
+   
+    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-"Parser size" was measured with a program parsing `{"sensor":"outdoor","value":25.6}`.
-For each library, I wrote a program that extracts a string and a float. I subtracted the size of a program doing the same without any JSON parsing involved. [Source files are here](https://gist.github.com/bblanchon/e8ba914a7109f3642c0f).
+    StaticJsonBuffer<200> jsonBuffer;
 
-"Encoder size" was measured with a program generating `{"sensor":"outdoor","value":25.6}`.
-[Source files are here](https://gist.github.com/bblanchon/60224e9dcfeab4ddc7e9).
+    JsonObject& root = jsonBuffer.parseObject(json);
 
-In each case the target platform was an Arduino Duemilanove and Arduino IDE 1.0.5 was used. 
+    const char* sensor = root["sensor"];
+    long time          = root["time"];
+    double latitude    = root["data"][0];
+    double longitude   = root["data"][1];
 
-Links: [json-arduino](https://github.com/not404/json-arduino), [aJson](https://github.com/interactive-matter/aJson) 
+[See complete guide](/doc/Decoding JSON.md)
+
+#### Encoding / Generating
+   
+    StaticJsonBuffer<200> jsonBuffer;
+
+    JsonObject& root = jsonBuffer.createObject();
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+
+    JsonArray& data = root.createNestedArray("data");
+    data.add(48.756080, 6);  // 6 is the number of decimals to print
+    data.add(2.302038, 6);   // if not specified, 2 digits are printed
+
+    root.printTo(Serial);
+    // This prints:
+    // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+[See complete guide](/doc/Encoding JSON.md)
 
 Testimonials
 ------------
 
 From Arduino's Forum user `jflaplante`:
-> I tried the  [aJson and json-arduino] before trying your library. I always ran into memory problem after a while. 
+> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while. 
 > I have no such problem so far with your library. It is working perfectly with my web services.
 
 From Arduino's Forum user `gbathree`:
@@ -49,8 +68,12 @@ From Arduino's Forum user `gbathree`:
 From StackOverflow user `thegreendroid`:
 > It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
 
-Links
------
+From GitHub user `zacsketches`:
 
-* [The project for which I made me this library](http://blog.benoitblanchon.fr/rfid-payment-terminal/)
-* [Blog post on the motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
+> Thanks for a great library!!!
+> I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
+> ArduinoJson saved me a week's worth of time!!
+
+---
+
+Found this library useful? [Help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:

doc/Avoiding pitfalls.md

@@ -0,0 +1,102 @@
+Avoiding common pitfalls in Arduino JSON
+========================================
+
+As `StaticJsonBuffer` is the corner stone of this library, you'll see that every pitfall listed here are related to a wrong understanding of the memory model.
+
+Make sure you read [Arduino JSON memory model](Memory model.md) before going further.
+
+## 1. Make `StaticJsonBuffer` big enough
+
+By design, the library has no way to tell you why `parseArray()` or `parseObject()` failed.
+
+There are basically two reasons why they may fail:
+
+1. the JSON string is invalid,
+2. the JSON string contains more values that the buffer can store.
+
+So, if you are sure the JSON string is correct and you still can't parse it, you should try to increase the size of the `StaticJsonBuffer`.
+
+## 2. Make sure everything fits in memory
+
+You may go into unpredictable trouble if you allocate more memory than your processor really has.
+It's a very common issue in embedded development.
+
+To diagnose this, look at every big objects in you code and sum their size to check that they fit in RAM.
+
+For example, don't do this:
+
+    char json[1024];                // 1 KB
+    StaticJsonBuffer<512> buffer;   // 514 B
+
+because it may be too big for a processor with only 2 KB: you need free memory to store other variables and the call stack.
+
+That is why an 8-bit processor is not able to parse long and complex JSON strings.
+
+## 3. Keep the `StaticJsonBuffer` in memory long enough
+
+Remember that `StaticJsonBuffer`'s function return references.
+References don't contain data, they are just pointer to the actual.
+So they can only work if the actual data is in memory.
+
+For example, don't do this:
+
+    JsonArray& getArray(char* json)
+    {
+        StaticJsonBuffer<200> buffer;
+        return buffer.parseArray(json); 
+    }
+
+because the local variable `buffer` will be *removed* from memory when the function `parseArray()` returns, and the `JsonArray&` will point to an invalid location.
+
+## 4. Don't reuse the same `StaticJsonBuffer`
+
+During is lifetime a `StaticJsonBuffer` growth until it's discarded. If you try to reuse the same instance several time, it will rapidly get full.
+
+For this reason, you should not use a global variable for your `StaticJsonBuffer`. I don't think there is any scenario in which a global `StaticJsonBuffer` would be a valid option.
+
+The best practice is to declare it in a local scope, so that it's discarded as soon as possible. My advice it to declare it in a function which unique role is to handle the JSON serialization.
+
+## 5. Keep the JSON string in memory long enough
+
+The library never make memory duplication.
+This has an important implication on string values, it means that the library will return pointer to chunks of the string.
+
+For instance, let's imagine that you parse `["hello","world"]`, like this:
+
+    char[] json = "[\"hello\",\"world\"]";
+    StaticJsonBuffer<32> buffer;
+    JsonArray& array = buffer.parseArray(json);
+
+    const char* first = array[0];
+    const char* second = array[1];
+
+In that case, both `first` and `second` are pointers to the content of the original string `json`.
+So this will only work if `json` is still in memory.
+
+## 6. JSON string is altered
+
+If you read carefully the previous section, you may have come to the conclusion that the JSON parser modifies the JSON string.
+
+Indeed, the parser modifies the string for two reasons:
+
+1. it inserts `\0` to terminate substrings,
+2. it translate escaped characters like `\n` or `\t`.
+
+Most of the time this wont be an issue, but there are some corner cases that can be problematic.
+
+Let take the example bellow:
+
+    char[] json = "[\"hello\",\"world\"]";
+    StaticJsonBuffer<32> buffer;
+    JsonArray& array = buffer.parseArray(json);
+
+If you replace it by:
+
+    char* json = "[\"hello\",\"world\"]";
+    StaticJsonBuffer<32> buffer;
+    JsonArray& array = buffer.parseArray(json);
+
+Depending on your platform, you may have an exception because the parser tries to write at a location that is read-only.
+In the first case `char json[]` declares an array of `char` initialized to the specified string.
+In the second case `char* json` declares a pointer to a read-only string, in fact it should be a `const char*` instead of a `char*`.
+

doc/Contributing.md

@@ -0,0 +1,15 @@
+Contributing to Arduino JSON
+============================
+
+If you want to contribute to the project, please:
+
+1. Use GitHub pull request feature
+2. Follow the coding conventions
+3. Write tests
+
+About the coding conventions: I try to follow the [Google C++ Style Guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.html) with few variations to match the Arduino conventions.
+
+I use [ClangFormat](http://clang.llvm.org/docs/ClangFormat.html) to format the code for me.
+I use [CppLint](http://google-styleguide.googlecode.com/svn/trunk/cpplint/cpplint.py) to detect non-compliant stuff.
+
+You should have a look at the `scripts/` folder as it contains a few helpers scripts.

doc/Decoding JSON.md

@@ -0,0 +1,148 @@
+Decoding JSON with Arduino JSON
+===============================
+
+Before writing any code, don't forget to include the header:
+
+    #include <ArduinoJson.h>
+
+For instructions on how to install the library, please read [Using the library with Arduino](Using the library with Arduino.md) or [Using the library without Arduino](Using the library without Arduino.md).
+
+## Example
+
+Here an example that parse the string `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`:
+
+    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+    
+    //
+    // Step 1: Reserve memory space
+    //
+    StaticJsonBuffer<200> jsonBuffer;
+    
+    //
+    // Step 2: Deserialize the JSON string
+    //
+    JsonObject& root = jsonBuffer.parseObject(json);
+
+    if (!root.success())
+    {
+      Serial.println("parseObject() failed");
+      return;
+    }
+
+    //
+    // Step 3: Retrieve the values
+    //
+    const char* sensor    = root["sensor"];
+    long        time      = root["time"];
+    double      latitude  = root["data"][0];
+    double      longitude = root["data"][1];
+
+## Step 1: Reserve memory space
+
+Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer`.
+
+Before continuing please read the page [Arduino JSON memory model](Memory model.md) that explains everything you need to know about `StaticJsonBuffer`.
+
+## Step 2: Parse the JSON string
+
+You invoke the JSON parser through the instance of `StaticJsonBuffer`.
+It exposes two functions for parsing JSON:
+
+1. `parseArray()` that returns a reference to a `JsonArray`
+2. `parseObject()` that returns a reference to a `JsonObject`
+
+Let's see an example.
+Say we want to parse `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`, it's an object so we call `parseObject()` as follows:
+
+    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+
+    JsonObject& root = jsonBuffer.parseObject(json);
+
+As you can see `parseObject()` takes a `char*` as a parameter.
+Be careful, it's not a `const char*`, the memory must be writable.
+Indeed, the parser will modify the string in two cases:
+
+1. to insert string endings (character `\0`),
+2. to translate escaped characters (like `\n` or `\t`).
+
+Another thing that you must keep in mind is that the string (`char json[]` in the example above) must stay in memory during the whole parsing process.
+That is because the in memory object tree will store pointer to chunks of the string, so as to avoid any memory duplication. 
+
+Now, to check if the parsing was successful, you can call `JsonObject::success()`:
+
+    if (!root.success())
+    {
+        // Parsing fail
+    }
+
+The result can be `false` for tree reasons:
+
+1. the JSON string is invalid,
+2. the JSON string doesn't represent an object,
+3. the `StaticJsonBuffer` is too small.
+
+We just saw how to parse an object, there is nothing more to say for arrays, the procedure is exactly the same.
+
+## Step 3: Retrieve the values
+
+Now that the object or array is in memory, you can extract the data very easily.
+
+In this section, we'll see how to do it with a `JsonObject`.
+Once again, there is nothing more to say about arrays, `JsonArray` works exactly the same as `JsonObject`.
+
+#### Subscript operator
+
+The simplest way is to use the subscript operator of `JsonObject`:
+    
+    const char* sensor = root["sensor"];
+    long time = root["time"];
+
+You can chain the subscript operator if you have nested arrays or objects:
+
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
+But alternatively, you can get a reference to the nested array:
+
+    JsonArray& nestedArray = root["data"];
+
+#### Casting values
+
+In the previous examples, the values were implicitly casted to the target type.
+You can also do this explicitly
+
+    const char* sensor = root["sensor"].asString();
+    long time = root["time"].as<long>();
+    JsonArray& nestedArray = root["data"].asArray();
+
+If the actual value doesn't match the target type, a default value will be return:
+
+1. `false` for boolean values
+2. `0` for integer values
+3. `NULL` for string values
+4. `JsonArray::invalid()` for nested arrays
+5. `JsonObject::invalid()` for nested object
+
+#### Check values
+
+If you want to know if some value is present, call `containsKey()`:
+
+    if (root.contains("extra"))
+    {
+        // root["extra"] is valid
+    }
+
+If you want to check the type value has a certain type, call `is<T>()`:
+
+    if (root["extra"].is<JsonArray&>())
+    {
+        // root["extra"] is an array
+    }
+
+You can also iterate through the key-value pairs of the object:
+
+    for (JsonObject::itertor it=root.begin(); it!=root.end(); ++it)
+    {
+      Serial.println(it->key);
+      Serial.println(i->value.asString());
+    }

doc/Encoding JSON.md

@@ -0,0 +1,140 @@
+Encoding JSON with Arduino JSON
+===============================
+
+Before writing any code, don't forget to include the header:
+
+    #include <ArduinoJson.h>
+
+For instructions on how to install the library, please read [Using the library with Arduino](Using the library with Arduino.md) or [Using the library without Arduino](Using the library without Arduino.md).
+
+## Example
+
+Here is an example to generate `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`
+
+    //
+    // Step 1: Reserve memory space
+    //
+    StaticJsonBuffer<200> jsonBuffer;
+
+    //
+    // Step 2: Build object tree in memory
+    //
+    JsonObject& root = jsonBuffer.createObject();
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+
+    JsonArray& data = root.createNestedArray("data");
+    data.add(48.756080, 6);  // 6 is the number of decimals to print
+    data.add(2.302038, 6);   // if not specified, 2 digits are printed
+
+    //
+    // Step 3: Generate the JSON string
+    //
+    root.printTo(Serial);
+
+## Step 1: Reserve memory space
+
+Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer`.
+
+Before continuing please read the page [Arduino JSON memory model](Memory model.md) that explains everything you need to know about `StaticJsonBuffer`.
+
+## Step 2: Build object tree in memory
+
+Now that you have enough memory hold by the `StaticJsonBuffer`, you can use it to build your in-memory representation of the JSON string.
+
+#### Arrays
+
+You create an array like this:
+
+    JsonArray& array = jsonBuffer.createArray();
+
+Don't forget the `&` after `JsonArray`, it needs to be a reference to the array.
+
+Then you can add strings, integer, booleans, etc:
+
+    array.add("bazinga!");
+    array.add(42);
+    array.add(true);
+
+There are two syntaxes for floating point values:
+
+	array.add(3.1415, 4);  // 4 digits: "3.1415"
+    array.add(3.1415);	   // 2 digits: "3.14"
+
+> ##### About floating point precision
+> The overload of `add()` with 2 parameters allows you to specify the number of decimals to save in the JSON string.
+> When you use the overload with one parameter, you use the default number of decimals which is 2.
+> Note that this behavior is the exact same as Arduino's `Print::print(double,int);` which is implemented by `Serial`, so you may already be familiar with this behavior.
+
+You can add a nested array or object if you have a reference to it.
+Or simpler, you can create nested array or nested objects from the array:
+
+    JsonArray&  nestedArray  = array.createNestedArray();
+    JsonObject& nestedObject = array.createNestedObject();
+
+#### Objects
+
+You create an object like this:
+
+    JsonObject& object = jsonBuffer.createObject();
+
+Again, don't forget the `&` after `JsonObject`, it needs to be a reference to the object.
+
+Then you can add strings, integer, booleans, etc:
+
+    object["key1"] = "bazinga!";
+    object["key2"] = 42;
+    object["key3"] = true;
+
+As for the arrays, there are two syntaxes for the floating point values:
+
+	object["key4"].set(3.1415, 4);  // 4 digits "3.1415"
+    object["key5"] = 3.1415;	    // default: 2 digits "3.14"
+
+You can add a nested array or object if you have a reference to it.
+Or simpler, you can create nested array or nested objects from the object:
+
+    JsonArray&  nestedArray  = object.createNestedArray("key6");
+    JsonObject& nestedObject = object.createNestedObject("key7");
+
+> ##### Other JsonObject functions
+> * `object.add(key, value)` is a synonym for `object[key] = value`
+> * `object.containsKey(key)` returns `true` is the `key` is present in `object`
+> * `object.remove(key)` removes the `value` associated with `key`
+
+## Step 3: Generate the JSON string
+
+There are two ways tho get the resulting JSON string.
+
+Depending on your project, you may need to dump the string in a classic `char[]` or send it to a `Print` implementation like `Serial` or `EthernetClient `.
+
+Both ways are the easy way :-)
+
+#### Use a classic `char[]`
+
+Whether you have a `JsonArray&` or a `JsonObject&`, simply call `printTo()` with the destination buffer, like so:
+
+	char buffer[256];
+    array.printTo(buffer, sizeof(buffer));
+
+> ##### Want an indented output?
+> By default the generated JSON is as small as possible. It contains no extra space, nor line break.
+> But if you want an indented, more readable output, you can.
+> Simply call `prettyPrintTo` instead of `printTo()`:
+> 
+>     array.prettyPrintTo(buffer, sizeof(buffer));
+
+#### Send to a `Print` implementation
+
+It's very likely that the generated JSON will end up in a stream like `Serial` or `EthernetClient `, so you can save some time and memory by doing this:
+
+    array.printTo(Serial);
+
+And, of course if you need an indented JSON string:
+
+    array.prettyPrintTo(Serial);
+
+> ##### About the Print interface
+> The library is designed to send the JSON string to an implementation of the `Print` interface that is part of Arduino.
+> In the example above we used `Serial`, but they are many other implementations that would work as well, including: `HardwareSerial`,  `SoftwareSerial`, `LiquidCrystal`, `EthernetClient`, `WiFiClient`, `Wire`...
+> When you use this library out of the Arduino environment, it will use it's own implementation of `Print` and everything will be the same.

doc/Memory model.md

@@ -0,0 +1,58 @@
+Arduino JSON memory model
+=========================
+
+## Fixed memory allocation
+
+### Introducing `StaticJsonBuffer`
+
+Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer` class.
+
+Before using any function of the library you need to create a `StaticJsonBuffer`. Then you can use this instance to create arrays and objects, or parse a JSON string.
+
+`StaticJsonBuffer` has a template parameter that determines its capacity. For example, the following line create a `StaticJsonBuffer` with a capacity of 200 bytes:
+
+    StaticJsonBuffer<200> jsonBuffer;
+
+The bigger the buffer is, the more complex the object tree can be, but also the more memory you need.
+
+### How to determine the buffer size?
+
+So the big question you should have in mind right now is *How can I determine the size?*.
+
+There are basically two approaches here:
+
+1. either you can predict the content of the object tree,
+2. or, you know how much memory is available.
+
+In the first case, you know some constraints on the object tree. For instance, let's say that your know in advance (and by that I mean "at compilation time") that you want to generate an object with 3 values, one of them being an array with 2 values, like the following:
+
+    {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+To determine the memory usage of this object tree, you use the two macros `JSON_ARRAY_SIZE(n)` and `JSON_OBJECT_SIZE(n)`, both take the number of elements as an argument.
+For the example above, it would be:
+
+    const int BUFFER_SIZE = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2);
+    StaticJsonBuffer<BUFFER_SIZE> jsonBuffer;
+
+In the second case, let's say you dynamically generate a JSON object tree of a random complexity so you can't put a limit based on that. But on the other hand, you don't want your program to crash because the object tree doesn't fit in memory.
+The solution here is to determine how much memory is available, or in other words how much memory you can afford for the JSON object tree.
+
+### Why choosing fixed allocation?
+
+This fixed allocation approach may seem a bit strange, especially if your a desktop application developer used to dynamic allocation, but it make a lot of sense in an embedded context:
+
+1. the code is smaller
+2. it uses less memory
+3. it doesn't create memory fragmentation
+4. it predictable
+
+Don't forget that the memory is "freed" as soon as the `StaticJsonBuffer` is out of scope, like any other variable. It only hold the memory for a short amount of time.
+
+## Memory usage
+
+#### Object size for 8-bit AVR
+
+| Type                    | Size       |
+|-------------------------|------------|
+| JsonArray of N element  | 4 + 8 * N  |
+| JsonObject of N element | 4 + 10 * N |

doc/Migrating code to new API.md

@@ -0,0 +1,80 @@
+Migrating code written for Arduino JSON v3 to v4
+================================================
+
+Arduino JSON v4 was a major rewrite of the library, and the API changed significantly.
+
+## Includes
+
+Arduino JSON v3 had two include files:
+
+    #include <JsonParser.h>
+    #include <JsonGenerator.h>
+
+Arduino JSON v4 only has one:
+
+	#include <ArduinoJson.h>
+
+## Namespaces
+
+Arduino JSON v3 had two namespaces:
+
+	using namespace ArduinoJson::Parser;
+	using namespace ArduinoJson::Generator;
+
+Arduino JSON v4 doesn't require the `using namespace` statement.
+It has a namespace but the `using namespace` is done in the header file.
+
+## StaticJsonBuffer
+
+Arduino JSON v3 had different memory allocation models for the parser:
+
+	JsonParser<16> parser; // 16 being the capacity in "tokens"
+
+and for the generator:
+
+	JsonArray<4> array; // 4 being the number of element
+	JsonObject<4> object;
+
+Arduino JSON v4 only has one memory allocation model:
+
+	StaticJsonBuffer<128> buffer; // 128 being the capacity in bytes
+
+## Return values for the parser
+
+Arduino JSON v3 returned value types:
+
+	JsonArray array = parser.parseArray(json);
+	JsonObject object = parser.parseObject(json);
+
+Arduino JSON v4 returns references types:
+
+	JsonArray& array = buffer.parseArray(json);
+	JsonObject& object = buffer.parseObject(json);
+
+Everything else is compatible
+
+## Creating arrays and objects
+
+Arduino JSON v3 allowed to create `JsonArray` and `JsonObject` directly:
+
+	JsonArray<4> array;
+	JsonObject<4> object;
+
+Arduino JSON v4 requires that you use a `StaticJsonBuffer` for that:
+
+	JsonArray& array = buffer.createArray();
+	JsonObject& object = buffer.createObject();
+
+Note: you don't have to specify the capacity anymore.
+
+## Printable interface
+
+Arduino JSON v3 used to implement the Printable interface, which allowed statements like:
+
+    Serial.print(array);
+
+But Arduino JSON v4 doesn't, instead you need to write this:
+
+	array.printTo(Serial);
+
+Note: there was a good reason for removing that feature, and it's reducing the size of `JsonArray` and `JsonObject`.

doc/Using the library with Arduino.md

@@ -0,0 +1,30 @@
+Using the library with Arduino
+==============================
+
+This library is primarily design to be used with the Arduino IDE and therefore has a simplified setup procedure for that environment.
+If you don't use the Arduino IDE, please read [Using the library without Arduino](Using the library without Arduino.md).
+
+## Install the library
+
+[Download the zip package](https://github.com/bblanchon/ArduinoJson/releases) and extract it to:
+
+    <your Arduino Sketch folder>/libraries/ArduinoJson
+
+Then restart the Arduino IDE.
+
+## Run the examples sketches
+
+Click `File` / `Example` / `ArduinoJson`.
+
+![Screen capture of Arduino IDE](http://i.imgur.com/g5UwkVh.png)
+
+## Use the library in your sketches
+
+Just add the following line at the top of your program:
+
+    #include <ArduinoJson.h>
+
+Then follow the instructions:
+
+1. [Parsing JSON](Parsin JSON.md)
+2. [Generating JSON](Generating JSON.md)

doc/Using the library without Arduino.md

@@ -0,0 +1,37 @@
+Using the library without Arduino
+=================================
+
+This library is primarily design to be used with the Arduino IDE and therefore has a simplified setup procedure for that environment.
+If you use the Arduino IDE, please read [Using the library with Arduino](Using the library with Arduino.md).
+
+However, it can be used without Arduino IDE with very little effort.
+
+## Compiling the library
+
+Step 1: Download source code:
+
+    git clone https://github.com/bblanchon/ArduinoJson.git
+
+Step 2: Generate the `Makefile` for your environment
+
+    cd ArduinoJson
+    cmake .
+
+Step 3: Build
+
+	make
+
+## File paths
+
+Assuming you installed the library into `<arduino-json>`, you need to add:
+
+1. `<arduino-json>/include` to your include path
+2. `<arduino-json>/lib` to your library path
+
+
+----------
+
+You are now ready to follow the instructions:
+
+1. [Parsing JSON](Parsin JSON.md)
+2. [Generating JSON](Generating JSON.md)

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -0,0 +1,30 @@
+/*
+ * Arduino JSON library - IndentedPrint example
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#include <ArduinoJson.h>
+
+using namespace ArduinoJson::Internals;
+
+void setup() {
+  Serial.begin(9600);
+
+  IndentedPrint serial(Serial);
+  serial.setTabSize(4);
+
+  serial.println("This is at indentation 0");
+  serial.indent();
+  serial.println("This is at indentation 1");
+  serial.println("This is also at indentation 1");
+  serial.indent();
+  serial.println("This is at indentation 2");
+
+  serial.unindent();
+  serial.unindent();
+  serial.println("This is back at indentation 0");
+}
+
+void loop() {
+  // not used in this example
+}

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,29 +1,42 @@
-/*
- * Arduino JSON library - Generator example
- * Benoit Blanchon 2014 - MIT License
- */
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
 
-#include <JsonGenerator.h>
+#include <ArduinoJson.h>
 
-using namespace ArduinoJson::Generator;
+void setup() {
+  Serial.begin(9600);
 
-void setup()
-{
-    Serial.begin(9600);
+  StaticJsonBuffer<200> jsonBuffer;
 
-    JsonArray<2> array;
-    array.add<6>(48.756080); // 6 is the number of decimals to print
-    array.add<6>(2.302038);  // if not specified, 2 digits are printed
+  JsonObject& root = jsonBuffer.createObject();
+  root["sensor"] = "gps";
+  root["time"] = 1351824120;
 
-    JsonHashTable<3> root; 
-    root.add("sensor", "gps");
-    root.add("time", 1351824120);
-    root.add("data", array);
+  JsonArray& data = root.createNestedArray("data");
+  data.add(48.756080, 6);  // 6 is the number of decimals to print
+  data.add(2.302038, 6);   // if not specified, 2 digits are printed
 
-    Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+  root.printTo(Serial);
+  // This prints:
+  // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+  Serial.println();
+
+  root.prettyPrintTo(Serial);
+  // This prints:
+  // {
+  //   "sensor": "gps",
+  //   "time": 1351824120,
+  //   "data": [
+  //     48.756080,
+  //     2.302038
+  //   ]
+  // }
 }
 
-void loop()
-{
-
+void loop() {
+  // not used in this example
 }

examples/JsonParserExample/JsonParserExample.ino

@@ -1,44 +1,37 @@
-/*
-* Arduino JSON library - Parser Example
-* Benoit Blanchon 2014 - MIT License
-*/
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
 
-#include <JsonParser.h>
+#include <ArduinoJson.h>
 
-using namespace ArduinoJson::Parser;
+void setup() {
+  Serial.begin(9600);
 
-void setup()
-{
-    Serial.begin(9600);
+  StaticJsonBuffer<200> jsonBuffer;
 
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+  char json[] =
+      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    JsonParser<16> parser;
+  JsonObject& root = jsonBuffer.parseObject(json);
 
-    JsonHashTable root = parser.parseHashTable(json);
+  if (!root.success()) {
+    Serial.println("parseObject() failed");
+    return;
+  }
 
-    if (!root.success())
-    {
-        Serial.println("JsonParser.parseHashTable() failed");
-        return;
-    }
+  const char* sensor = root["sensor"];
+  long time = root["time"];
+  double latitude = root["data"][0];
+  double longitude = root["data"][1];
 
-    char* sensor = root.getString("sensor");
-    Serial.println(sensor);
-
-    long time = root.getLong("time");
-    Serial.println(time);
-    
-    JsonArray coords = root.getArray("data");
-    
-    for (int i = 0; i < coords.getLength(); i++)
-    {
-        double value = coords.getDouble(i);
-        Serial.println(value, 6);
-    }
+  Serial.println(sensor);
+  Serial.println(time);
+  Serial.println(latitude, 6);
+  Serial.println(longitude, 6);
 }
 
-void loop()
-{
-
+void loop() {
+  // not used in this example
 }

include/ArduinoJson.h

@@ -0,0 +1,11 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../include/ArduinoJson/JsonArray.hpp"
+#include "../include/ArduinoJson/JsonObject.hpp"
+#include "../include/ArduinoJson/StaticJsonBuffer.hpp"
+
+using namespace ArduinoJson;

include/ArduinoJson/Arduino/Print.hpp

@@ -0,0 +1,31 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#ifndef ARDUINO
+
+#include <stddef.h>
+#include <stdint.h>
+
+// This class reproduces Arduino's Print
+class Print {
+ public:
+  virtual ~Print() {}
+
+  virtual size_t write(uint8_t) = 0;
+
+  size_t print(const char[]);
+  size_t print(double, int = 2);
+  size_t print(long);
+  size_t println();
+};
+
+#else
+
+#include <Print.h>
+
+#endif

include/ArduinoJson/Internals/IndentedPrint.hpp

@@ -0,0 +1,54 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/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);
+
+  // 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();
+
+  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
+};
+}
+}

include/ArduinoJson/Internals/JsonParser.hpp

@@ -0,0 +1,42 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+#include "../JsonVariant.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()
+class JsonParser {
+ public:
+  JsonParser(JsonBuffer *buffer, char *json, uint8_t nestingLimit)
+      : _buffer(buffer), _ptr(json), _nestingLimit(nestingLimit) {}
+
+  JsonArray &parseArray();
+  JsonObject &parseObject();
+
+ private:
+  bool skip(char charToSkip);
+  bool skip(const char *wordToSkip);
+  void skipSpaces();
+
+  void parseAnythingTo(JsonVariant &destination);
+  inline void parseBooleanTo(JsonVariant &destination);
+  inline void parseNullTo(JsonVariant &destination);
+  inline void parseNumberTo(JsonVariant &destination);
+  inline const char *parseString();
+
+  JsonBuffer *_buffer;
+  char *_ptr;
+  uint8_t _nestingLimit;
+};
+}
+}

include/ArduinoJson/Internals/JsonPrintable.hpp

@@ -0,0 +1,54 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "IndentedPrint.hpp"
+#include "JsonWriter.hpp"
+#include "Prettyfier.hpp"
+#include "StringBuilder.hpp"
+
+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);
+    downcast().writeTo(writer);
+    return writer.bytesWritten();
+  }
+
+  size_t printTo(char *buffer, size_t bufferSize) const {
+    StringBuilder sb(buffer, bufferSize);
+    return printTo(sb);
+  }
+
+  size_t prettyPrintTo(IndentedPrint &print) const {
+    Prettyfier p(print);
+    return printTo(p);
+  }
+
+  size_t prettyPrintTo(char *buffer, size_t bufferSize) const {
+    StringBuilder sb(buffer, bufferSize);
+    return prettyPrintTo(sb);
+  }
+
+  size_t prettyPrintTo(Print &print) const {
+    IndentedPrint indentedPrint = IndentedPrint(print);
+    return prettyPrintTo(indentedPrint);
+  }
+
+ private:
+  const T &downcast() const { return *static_cast<const T *>(this); }
+};
+}
+}

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -0,0 +1,28 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+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 {
+  bool asBoolean;
+  double asDouble;       // asDouble is also used for float
+  long asLong;           // asLong is also used for char, short and int
+  const char* asString;  // asString can be null
+  JsonArray* asArray;    // asArray cannot be null
+  JsonObject* asObject;  // asObject cannot be null
+};
+}
+}

include/ArduinoJson/Internals/JsonVariantType.hpp

@@ -0,0 +1,33 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Enumerated type to know the current type of a JsonVariant.
+// The value determines which member of JsonVariantContent is used.
+enum JsonVariantType {
+  JSON_INVALID,    // a special state for JsonVariant::invalid()
+  JSON_UNDEFINED,  // the JsonVariant has not been initialized
+  JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
+  JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject
+  JSON_BOOLEAN,    // the JsonVariant stores a bool
+  JSON_STRING,     // the JsonVariant stores a const char*
+  JSON_LONG,       // the JsonVariant stores a long
+
+  // The following values are reserved for double values
+  // Multiple values are used for double, depending on the number of decimal
+  // digits that must be printed in the JSON output.
+  // This little trick allow to save one extra member in JsonVariant
+  JSON_DOUBLE_0_DECIMALS
+  // JSON_DOUBLE_1_DECIMAL
+  // JSON_DOUBLE_2_DECIMALS
+  // ...
+};
+}
+}

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -0,0 +1,64 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+#include "QuotedString.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() { return _length; }
+
+  void beginArray() { write('['); }
+  void endArray() { write(']'); }
+
+  void beginObject() { write('{'); }
+  void endObject() { write('}'); }
+
+  void writeColon() { write(':'); }
+  void writeComma() { write(','); }
+
+  void writeString(const char *value) {
+    _length += QuotedString::printTo(value, _sink);
+  }
+
+  void writeLong(long value) { _length += _sink.print(value); }
+
+  void writeBoolean(bool value) {
+    _length += _sink.print(value ? "true" : "false");
+  }
+  void writeDouble(double value, uint8_t decimals) {
+    _length += _sink.print(value, decimals);
+  }
+
+ protected:
+  void write(char c) { _length += _sink.write(c); }
+  void write(const char *s) { _length += _sink.print(s); }
+
+  Print &_sink;
+  size_t _length;
+
+ private:
+  JsonWriter &operator=(const JsonWriter &);  // cannot be assigned
+};
+}
+}

include/ArduinoJson/Internals/List.hpp

@@ -0,0 +1,74 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+#include "ListConstIterator.hpp"
+#include "ListIterator.hpp"
+#include "PlacementNew.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
+  int size() const;
+
+  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); }
+
+ protected:
+  node_type *createNode() {
+    if (!_buffer) return NULL;
+    void *ptr = _buffer->alloc(sizeof(node_type));
+    return ptr ? new (ptr) node_type() : NULL;
+  }
+
+  void addNode(node_type *nodeToAdd) {
+    if (_firstNode) {
+      node_type *lastNode = _firstNode;
+      while (lastNode->next) lastNode = lastNode->next;
+      lastNode->next = nodeToAdd;
+    } else {
+      _firstNode = nodeToAdd;
+    }
+  }
+
+  void removeNode(node_type *nodeToRemove);
+
+  JsonBuffer *_buffer;
+  node_type *_firstNode;
+};
+}
+}

include/ArduinoJson/Internals/ListConstIterator.hpp

@@ -0,0 +1,40 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#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;
+  }
+
+ private:
+  const ListNode<T> *_node;
+};
+}
+}

include/ArduinoJson/Internals/ListIterator.hpp

@@ -0,0 +1,40 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "ListNode.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A read-write forward iterator for List<T>
+template <typename T>
+class ListIterator {
+ 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;
+  }
+
+ private:
+  ListNode<T> *_node;
+};
+}
+}

include/ArduinoJson/Internals/ListNode.hpp

@@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include <stddef.h>  // for NULL
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A node for a singly-linked list.
+// Used by List<T> and its iterators.
+template <typename T>
+struct ListNode {
+  ListNode() : next(NULL) {}
+
+  ListNode<T>* next;
+  T content;
+};
+}
+}

include/ArduinoJson/Internals/PlacementNew.hpp

@@ -0,0 +1,19 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#ifdef ARDUINO
+
+// Declares the placement new as in <new>.
+// This is required for Arduino IDE because it doesn't include the <new> header.
+inline void *operator new(size_t, void *p) throw() { return p; }
+
+#else
+
+#include <new>
+
+#endif

include/ArduinoJson/Internals/Prettyfier.hpp

@@ -0,0 +1,46 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#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);
+
+ private:
+  Prettyfier& operator=(const Prettyfier&);  // cannot be assigned
+
+  bool inEmptyBlock() { return _previousChar == '{' || _previousChar == '['; }
+
+  size_t handleStringChar(uint8_t);
+  size_t handleMarkupChar(uint8_t);
+
+  size_t handleBlockClose(uint8_t);
+  size_t handleBlockOpen(uint8_t);
+  size_t handleColumn();
+  size_t handleComma();
+  size_t handleQuoteOpen();
+  size_t handleNormalChar(uint8_t);
+  size_t indentIfNeeded();
+  size_t unindentIfNeeded();
+
+  uint8_t _previousChar;
+  IndentedPrint& _sink;
+  bool _inString;
+};
+}
+}

include/ArduinoJson/Internals/QuotedString.hpp

@@ -0,0 +1,29 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// An helper class to print and extract doubly-quoted strings
+class QuotedString {
+ public:
+  // Writes a doubly-quote string to a Print implementation.
+  // It adds the double quotes (") at the beginning and the end of the string.
+  // It escapes the special characters as required by the JSON specifications.
+  static size_t printTo(const char *, Print &);
+
+  // Reads a doubly-quoted string from a buffer.
+  // It removes the double quotes (").
+  // It unescapes the special character as required by the JSON specification,
+  // with the exception of the Unicode characters (\u0000).
+  static char *extractFrom(char *input, char **end);
+};
+}
+}

include/ArduinoJson/Internals/ReferenceType.hpp

@@ -0,0 +1,34 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#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&);
+};
+}
+}

include/ArduinoJson/Internals/StringBuilder.hpp

@@ -0,0 +1,30 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A Print implementation that allows to write in a char[]
+class StringBuilder : public Print {
+ public:
+  StringBuilder(char *buf, int size)
+      : buffer(buf), capacity(size - 1), length(0) {
+    buffer[0] = '\0';
+  }
+
+  virtual size_t write(uint8_t c);
+
+ private:
+  char *buffer;
+  int capacity;
+  int length;
+};
+}
+}

include/ArduinoJson/JsonArray.hpp

@@ -0,0 +1,88 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "Internals/JsonPrintable.hpp"
+#include "Internals/List.hpp"
+#include "Internals/ReferenceType.hpp"
+#include "JsonVariant.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;
+
+// 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> {
+  // JsonBuffer is a friend because it needs to call the private constructor.
+  friend class JsonBuffer;
+
+ public:
+  // Returns the JsonVariant at the specified index (synonym for operator[])
+  JsonVariant &at(int index) const;
+
+  // Returns the JsonVariant at the specified index (synonym for at())
+  JsonVariant &operator[](int index) const { return at(index); }
+
+  // Adds an uninitialized JsonVariant at the end of the array.
+  // Return a reference or JsonVariant::invalid() if allocation fails.
+  JsonVariant &add();
+
+  // Adds the specified value at the end of the array.
+  template <typename T>
+  void add(T value) {
+    add().set(value);
+  }
+
+  // Adds the specified double value at the end of the array.
+  // The value will be printed with the specified number of decimal digits.
+  void add(double value, uint8_t decimals) { add().set(value, decimals); }
+
+  // Adds a reference to the specified JsonArray at the end of the array.
+  void add(JsonArray &array) { add().set(array); }
+
+  // Adds a reference to the specified JsonObject at the end of the array.
+  void add(JsonObject &obejct) { add().set(obejct); }
+
+  // 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();
+
+  // 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() { return _invalid; }
+
+  // Serialize the array to the specified JsonWriter.
+  void writeTo(Internals::JsonWriter &writer) const;
+
+ private:
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  explicit JsonArray(JsonBuffer *buffer)
+      : Internals::List<JsonVariant>(buffer) {}
+
+  // The instance returned by JsonArray::invalid()
+  static JsonArray _invalid;
+};
+}

include/ArduinoJson/JsonBuffer.hpp

@@ -0,0 +1,81 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include <stddef.h>  // for size_t
+#include <stdint.h>  // for uint8_t
+
+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();
+
+  // 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 (see comment on DEFAULT_LIMIT)
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  JsonArray &parseArray(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+
+  // 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 (see comment on DEFAULT_LIMIT)
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  JsonObject &parseObject(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+
+  // 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;
+
+  // Default value of nesting limit of parseArray() and parseObject().
+  //
+  // The nesting limit is a contain on the level of nesting allowed in the JSON
+  // string.
+  // If set to 0, only a flat array or objects can be parsed.
+  // If set to 1, the object can contain nested arrays or objects but only 1
+  // level deep.
+  // And bigger values will allow more level of nesting.
+  //
+  // The purpose of this feature is to prevent stack overflow that could lead to
+  // a security risk.
+  static const uint8_t DEFAULT_LIMIT = 10;
+};
+}

include/ArduinoJson/JsonObject.hpp

@@ -0,0 +1,105 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "Internals/JsonPrintable.hpp"
+#include "Internals/List.hpp"
+#include "Internals/ReferenceType.hpp"
+#include "JsonPair.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> {
+  // JsonBuffer is a friend because it needs to call the private constructor.
+  friend class JsonBuffer;
+
+ public:
+  typedef const char *key_type;
+  typedef JsonPair value_type;
+
+  // Gets the JsonVariant associated with the specified key.
+  // Returns a reference or JsonVariant::invalid() if not found.
+  JsonVariant &at(key_type key);
+
+  // Gets the JsonVariant associated with the specified key.
+  // Returns a constant reference or JsonVariant::invalid() if not found.
+  const JsonVariant &at(key_type key) const;
+
+  // Gets or create the JsonVariant associated with the specified key.
+  // Returns a reference or JsonVariant::invalid() if allocation failed.
+  JsonVariant &operator[](key_type key);
+
+  // Gets the JsonVariant associated with the specified key.
+  // Returns a constant reference or JsonVariant::invalid() if not found.
+  const JsonVariant &operator[](key_type key) const { return at(key); }
+
+  // Adds an uninitialized JsonVariant associated with the specified key.
+  // Return a reference or JsonVariant::invalid() if allocation fails.
+  JsonVariant &add(key_type key) { return (*this)[key]; }
+
+  // Adds the specified key with the specified value.
+  template <typename T>
+  void add(key_type key, T value) {
+    add(key).set(value);
+  }
+
+  // Adds the specified key with a reference to the specified JsonArray.
+  void add(key_type key, JsonArray &array) { add(key).set(array); }
+
+  // Adds the specified key with a reference to the specified JsonObject.
+  void add(key_type key, JsonObject &object) { add(key).set(object); }
+
+  // Creates and adds a JsonArray.
+  // This is a shortcut for JsonBuffer::createArray() and JsonObject::add().
+  JsonArray &createNestedArray(key_type key);
+
+  // Creates and adds a JsonObject.
+  // This is a shortcut for JsonBuffer::createObject() and JsonObject::add().
+  JsonObject &createNestedObject(key_type key);
+
+  // Tells weither the specified key is present and associated with a value.
+  bool containsKey(key_type key) const { return at(key).success(); }
+
+  // Removes the specified key and the associated value.
+  void remove(key_type key);
+
+  // 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() { return _invalid; }
+
+  // Serialize the object to the specified JsonWriter
+  void writeTo(Internals::JsonWriter &writer) const;
+
+ private:
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  explicit JsonObject(JsonBuffer *buffer) : Internals::List<JsonPair>(buffer) {}
+
+  // Returns the list node that matches the specified key.
+  node_type *getNodeAt(key_type key) const;
+
+  // The instance returned by JsonObject::invalid()
+  static JsonObject _invalid;
+};
+}

include/ArduinoJson/JsonPair.hpp

@@ -0,0 +1,18 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "JsonVariant.hpp"
+
+namespace ArduinoJson {
+
+// A key value pair for JsonObject.
+struct JsonPair {
+  const char* key;
+  JsonVariant value;
+};
+}

include/ArduinoJson/JsonVariant.hpp

@@ -0,0 +1,286 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>  // for uint8_t
+
+#include "Internals/JsonPrintable.hpp"
+#include "Internals/JsonVariantContent.hpp"
+#include "Internals/JsonVariantType.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 Internals::JsonPrintable<JsonVariant> {
+ public:
+  // Creates an uninitialized JsonVariant
+  JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
+
+  // Initializes a JsonVariant with the specified value.
+  template <typename T>
+  explicit JsonVariant(T value) {
+    set(value);
+  }
+
+  // Tells weither the variant is valid.
+  bool success() const {
+    return _type != Internals::JSON_INVALID &&
+           _type != Internals::JSON_UNDEFINED;
+  }
+
+  // Sets the variant to a boolean value.
+  // It will be serialized as "true" or "false" in JSON.
+  void set(bool value);
+
+  // Sets the variant to a floating point value.
+  // The second argument specifies the number of decimal digits to write in
+  // the JSON string.
+  void set(double value, uint8_t decimals = 2);
+
+  // Sets the variant to be an integer value.
+  void set(signed long value);
+  void set(signed char value) { set(static_cast<long>(value)); }
+  void set(signed int value) { set(static_cast<long>(value)); }
+  void set(signed short value) { set(static_cast<long>(value)); }
+  void set(unsigned char value) { set(static_cast<long>(value)); }
+  void set(unsigned int value) { set(static_cast<long>(value)); }
+  void set(unsigned long value) { set(static_cast<long>(value)); }
+  void set(unsigned short value) { set(static_cast<long>(value)); }
+
+  // Sets the variant to be a string.
+  void set(const char *value);
+
+  // Sets the variant to be a reference to an array.
+  void set(JsonArray &array);
+
+  // Sets the variant to be a reference to an object.
+  void set(JsonObject &object);
+
+  // Sets the variant to the specified value.
+  template <typename T>
+  JsonVariant &operator=(T value) {
+    set(value);
+    return *this;
+  }
+
+  // Sets the variant to be a reference to an array.
+  JsonVariant &operator=(JsonArray &array) {
+    set(array);
+    return *this;
+  }
+
+  // Sets the variant to be a reference to an object.
+  JsonVariant &operator=(JsonObject &object) {
+    set(object);
+    return *this;
+  }
+
+  // Gets the variant as a boolean value.
+  // Returns false if the variant is not a boolean value.
+  operator bool() const;
+
+  // Gets the variant as a floating-point value.
+  // Returns 0.0 if the variant is not a floating-point value
+  operator double() const;
+  operator float() const { return static_cast<float>(as<double>()); }
+
+  // Gets the variant as an integer value.
+  // Returns 0 if the variant is not an integer value.
+  operator signed long() const;
+  operator signed char() const { return cast_long_to<signed char>(); }
+  operator signed int() const { return cast_long_to<signed int>(); }
+  operator signed short() const { return cast_long_to<signed short>(); }
+  operator unsigned char() const { return cast_long_to<unsigned char>(); }
+  operator unsigned int() const { return cast_long_to<unsigned int>(); }
+  operator unsigned long() const { return cast_long_to<unsigned long>(); }
+  operator unsigned short() const { return cast_long_to<unsigned short>(); }
+
+  // Gets the variant as a string.
+  // Returns NULL if variant is not a string.
+  operator const char *() const;
+  const char *asString() const { return as<const char *>(); }
+
+  // Gets the variant as an array.
+  // Returns a reference to the JsonArray or JsonArray::invalid() if the variant
+  // is not an array.
+  operator JsonArray &() const;
+  JsonArray &asArray() 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.
+  operator JsonObject &() const;
+  JsonObject &asObject() const { return as<JsonObject &>(); }
+
+  // Get the variant as the specified type.
+  // See cast operators for details.
+  template <typename T>
+  T as() const {
+    return static_cast<T>(*this);
+  }
+
+  // Tells weither the variant has the specified type.
+  // Returns true if the variant has type type T, false otherwise.
+  template <typename T>
+  bool is() const {
+    return false;
+  }
+
+  // Returns an invalid variant.
+  // This is meant to replace a NULL pointer.
+  static JsonVariant &invalid() { return _invalid; }
+
+  // Serialize the variant to a JsonWriter
+  void writeTo(Internals::JsonWriter &writer) const;
+
+  // 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;
+
+  // 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.
+  JsonVariant &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.
+  JsonVariant &operator[](const char *key);
+
+ private:
+  // Special constructor used only to create _invalid.
+  explicit JsonVariant(Internals::JsonVariantType type) : _type(type) {}
+
+  // Helper for interger cast operators
+  template <typename T>
+  T cast_long_to() const {
+    return static_cast<T>(as<long>());
+  }
+
+  // The current type of the variant
+  Internals::JsonVariantType _type;
+
+  // The various alternatives for the value of the variant.
+  Internals::JsonVariantContent _content;
+
+  // The instance returned by JsonVariant::invalid()
+  static JsonVariant _invalid;
+};
+
+template <>
+inline bool JsonVariant::is<long>() const {
+  return _type == Internals::JSON_LONG;
+}
+
+template <>
+inline bool JsonVariant::is<double>() const {
+  return _type >= Internals::JSON_DOUBLE_0_DECIMALS;
+}
+
+template <>
+inline bool JsonVariant::is<bool>() const {
+  return _type == Internals::JSON_BOOLEAN;
+}
+
+template <>
+inline bool JsonVariant::is<const char *>() const {
+  return _type == Internals::JSON_STRING;
+}
+
+template <>
+inline bool JsonVariant::is<JsonArray &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<const JsonArray &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<JsonObject &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <>
+inline bool JsonVariant::is<const JsonObject &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <typename T>
+inline bool operator==(const JsonVariant &left, T right) {
+  return left.as<T>() == right;
+}
+
+template <typename T>
+inline bool operator==(T left, const JsonVariant &right) {
+  return left == right.as<T>();
+}
+
+template <typename T>
+inline bool operator!=(const JsonVariant &left, T right) {
+  return left.as<T>() != right;
+}
+
+template <typename T>
+inline bool operator!=(T left, const JsonVariant &right) {
+  return left != right.as<T>();
+}
+
+template <typename T>
+inline bool operator<=(const JsonVariant &left, T right) {
+  return left.as<T>() <= right;
+}
+
+template <typename T>
+inline bool operator<=(T left, const JsonVariant &right) {
+  return left <= right.as<T>();
+}
+
+template <typename T>
+inline bool operator>=(const JsonVariant &left, T right) {
+  return left.as<T>() >= right;
+}
+
+template <typename T>
+inline bool operator>=(T left, const JsonVariant &right) {
+  return left >= right.as<T>();
+}
+
+template <typename T>
+inline bool operator<(const JsonVariant &left, T right) {
+  return left.as<T>() < right;
+}
+
+template <typename T>
+inline bool operator<(T left, const JsonVariant &right) {
+  return left < right.as<T>();
+}
+
+template <typename T>
+inline bool operator>(const JsonVariant &left, T right) {
+  return left.as<T>() > right;
+}
+
+template <typename T>
+inline bool operator>(T left, const JsonVariant &right) {
+  return left > right.as<T>();
+}
+}

include/ArduinoJson/StaticJsonBuffer.hpp

@@ -0,0 +1,36 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "JsonBuffer.hpp"
+
+namespace ArduinoJson {
+
+// 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 JsonBuffer {
+ public:
+  explicit StaticJsonBuffer() : _size(0) {}
+
+  size_t capacity() const { return CAPACITY; }
+  size_t size() const { return _size; }
+
+ protected:
+  virtual void* alloc(size_t size) {
+    if (_size + size > CAPACITY) return NULL;
+    void* p = &_buffer[_size];
+    _size += size;
+    return p;
+  }
+
+ private:
+  uint8_t _buffer[CAPACITY];
+  size_t _size;
+};
+}

keywords.txt

@@ -1,10 +1,14 @@
-JsonParser	KEYWORD1
 JsonArray	KEYWORD1
-JsonHashTable	KEYWORD1
-getArray	KEYWORD2
-getBool	KEYWORD2
-getDouble	KEYWORD2
-getHashTableKEYWORD2
-getLong	KEYWORD2
+JsonObject	KEYWORD1
+JsonVariant	KEYWORD1
+StaticJsonBuffer	KEYWORD1
+add	KEYWORD2
+createArray	KEYWORD2
+createNestedArray	KEYWORD2
+createNestedObject	KEYWORD2
+createObject	KEYWORD2
 parseArray	KEYWORD2
-parseHashTable	KEYWORD2
+parseObject	KEYWORD2
+prettyPrintTo	KEYWORD2
+printTo	KEYWORD2
+success	KEYWORD2

library.json

@@ -0,0 +1,17 @@
+{
+  "name": "Json",
+  "keywords": "json, rest, http, web",
+  "description": "An elegant and efficient JSON library for embedded systems",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/bblanchon/ArduinoJson.git"
+  },
+  "authors":
+  {
+    "name": "Benoit Blanchon",
+    "url": "http://blog.benoitblanchon.fr"
+  },
+  "frameworks": "arduino",
+  "platforms": "atmelavr"  
+}

library.properties

@@ -0,0 +1,8 @@
+name=ArduinoJson
+version=4.0
+author=Benoit Blanchon <http://blog.benoitblanchon.fr/>
+maintainer=Benoit Blanchon <http://blog.benoitblanchon.fr/>
+sentence=An efficient and elegant JSON library for Arduino
+paragraph=Supports JSON parsing and formatting. Uses fixed memory allocation.
+url=https://github.com/bblanchon/ArduinoJson
+architectures=*

scripts/build-arduino-package.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+ZIP="C:\Program Files\7-Zip\7z.exe"
+TAG=$(git describe)
+OUTPUT="ArduinoJson-$TAG.zip"
+
+cd ../..
+
+# remove existing file
+rm -f $OUTPUT
+
+# create zip
+"$ZIP" a $OUTPUT \
+	ArduinoJson/CHANGELOG.md \
+	ArduinoJson/doc \
+	ArduinoJson/examples \
+	ArduinoJson/include \
+	ArduinoJson/keywords.txt \
+	ArduinoJson/library.properties \
+	ArduinoJson/LICENSE.md \
+	ArduinoJson/README.md \
+	ArduinoJson/src	

scripts/cpplint.sh

@@ -0,0 +1,5 @@
+CPPLINT="python third-party/cpplint/cpplint.py"
+FLAGS="--filter=-runtime/printf,-runtime/int,-readability/todo,-build/namespace,-runtime/references,-readability/streams"
+
+cd ..
+$CPPLINT $FLAGS $(find include src test -regex ".*\.[hc]pp$")

scripts/create-build-envs.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+export PATH="$PATH:/Applications/CMake.app/Contents/bin/"
+
+cd $(dirname $0)/..
+ROOT=$(pwd)
+
+mkdir "build"
+cd build
+BUILD=$(pwd)
+
+build-env()
+{
+	cd $BUILD
+	mkdir "$1"
+	cd "$1"
+	cmake "$ROOT" -G "$2"
+}
+
+if [[ $(uname) == MINGW* ]]
+then
+	build-env "Make" "MinGW Makefiles"
+	build-env "SublimeText" "Sublime Text 2 - MinGW Makefiles"
+	build-env "VisualStudio" "Visual Studio 12 2013"
+else
+	build-env "SublimeText" "Sublime Text 2 - Unix Makefiles"
+	build-env "Make" "Unix Makefiles"
+	build-env "Xcode" "Xcode"
+fi

scripts/format-code.sh

@@ -0,0 +1,7 @@
+cd ..
+FILES=$(find include src test -regex ".*\.[ch]pp$")
+
+clang-format -style=Google -i  $FILES
+
+# insert newline at end of file
+sed -i -e '$a\' $FILES

scripts/run-tests.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+FILE=../bin/ArduinoJsonTests.exe
+MD5=""
+
+file_changed() {
+	[[ ! -f  "$FILE" ]] && return 1
+	NEW_MD5=$(md5sum $FILE)
+	[[ "$MD5" == "$NEW_MD5" ]] && return 1
+	MD5=$NEW_MD5
+	return 0
+}
+
+test_succeed() {
+	echo -en "\007"{,}
+}
+
+test_failed() {
+	echo -en "\007"{,,,,,,,,,,,}
+}
+
+run_tests() {
+	$FILE
+	case $? in
+	0)
+		test_succeed
+		;;
+	1)	
+		test_failed
+		;;
+	esac
+}
+
+while true
+do
+	if file_changed
+	then	
+		run_tests
+	else
+		sleep 2
+	fi
+done
+
+

src/Arduino/Print.cpp

@@ -0,0 +1,35 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#ifndef ARDUINO
+
+#include "../../include/ArduinoJson/Arduino/Print.hpp"
+
+#include <stdio.h>  // for sprintf
+
+size_t Print::print(const char s[]) {
+  size_t n = 0;
+  while (*s) {
+    n += write(*s++);
+  }
+  return n;
+}
+
+size_t Print::print(double value, int digits) {
+  char tmp[32];
+  sprintf(tmp, "%.*f", digits, value);
+  return print(tmp);
+}
+
+size_t Print::print(long value) {
+  char tmp[32];
+  sprintf(tmp, "%ld", value);
+  return print(tmp);
+}
+
+size_t Print::println() { return write('\r') + write('\n'); }
+
+#endif

src/ArduinoJson.h

@@ -0,0 +1,13 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+// About this file
+// ---------------
+// This file is here to please the Arduino IDE. It must be present in the src/
+// for the IDE to find it. Feel free to ignore this file if your working in
+// another environment
+
+#include "../include/ArduinoJson.h"

src/CMakeLists.txt

@@ -0,0 +1,42 @@
+file(GLOB_RECURSE INC_FILES ../include/*.hpp)
+file(GLOB_RECURSE SRC_FILES *.cpp)
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+	add_definitions(
+		-fno-exceptions
+		-pedantic
+		-Wall
+		-Wcast-align
+		-Wcast-qual
+		-Wconversion
+		-Wctor-dtor-privacy
+		-Wdisabled-optimization
+		-Werror
+		-Wextra
+		-Wformat=2
+		-Winit-self
+		-Wmissing-include-dirs
+		-Wno-parentheses
+		-Wno-sign-conversion
+		-Wno-unused
+		-Wno-variadic-macros
+		-Wold-style-cast
+		-Woverloaded-virtual
+		-Wredundant-decls
+		-Wshadow
+		-Wsign-promo
+		-Wstrict-overflow=5
+		-Wundef
+	)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU)")
+	add_definitions(
+		-Wlogical-op
+		-Wnoexcept
+		-Wstrict-null-sentinel
+	)
+endif()
+
+
+add_library(ArduinoJson ${SRC_FILES} ${INC_FILES})

src/Internals/IndentedPrint.cpp

@@ -0,0 +1,29 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/IndentedPrint.hpp"
+
+using namespace ArduinoJson::Internals;
+
+size_t IndentedPrint::write(uint8_t c) {
+  size_t n = 0;
+
+  if (isNewLine) n += writeTabs();
+
+  n += sink->write(c);
+
+  isNewLine = c == '\n';
+
+  return n;
+}
+
+inline size_t IndentedPrint::writeTabs() {
+  size_t n = 0;
+
+  for (int i = 0; i < level * tabSize; i++) n += sink->write(' ');
+
+  return n;
+}

src/Internals/JsonParser.cpp

@@ -0,0 +1,197 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/JsonParser.hpp"
+
+#include <stdlib.h>  // for strtol, strtod
+#include <ctype.h>
+
+#include "../../include/ArduinoJson/Internals/QuotedString.hpp"
+#include "../../include/ArduinoJson/JsonArray.hpp"
+#include "../../include/ArduinoJson/JsonBuffer.hpp"
+#include "../../include/ArduinoJson/JsonObject.hpp"
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+void JsonParser::skipSpaces() {
+  while (isspace(*_ptr)) _ptr++;
+}
+
+bool JsonParser::skip(char charToSkip) {
+  skipSpaces();
+  if (*_ptr != charToSkip) return false;
+  _ptr++;
+  skipSpaces();
+  return true;
+}
+
+bool JsonParser::skip(const char *wordToSkip) {
+  const char *charToSkip = wordToSkip;
+  while (*charToSkip && *_ptr == *charToSkip) {
+    charToSkip++;
+    _ptr++;
+  }
+  return *charToSkip == '\0';
+}
+
+void JsonParser::parseAnythingTo(JsonVariant &destination) {
+  if (_nestingLimit == 0) return;
+  _nestingLimit--;
+
+  skipSpaces();
+
+  switch (*_ptr) {
+    case '[':
+      destination = parseArray();
+      break;
+
+    case '{':
+      destination = parseObject();
+      break;
+
+    case 't':
+    case 'f':
+      parseBooleanTo(destination);
+      break;
+
+    case '-':
+    case '.':
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+      parseNumberTo(destination);
+      break;
+
+    case 'n':
+      parseNullTo(destination);
+      break;
+
+    case '\'':
+    case '\"':
+      destination = parseString();
+      break;
+  }
+
+  _nestingLimit++;
+}
+
+JsonArray &JsonParser::parseArray() {
+  // Create an empty array
+  JsonArray &array = _buffer->createArray();
+
+  // Check opening braket
+  if (!skip('[')) goto ERROR_MISSING_BRACKET;
+  if (skip(']')) goto SUCCESS_EMPTY_ARRAY;
+
+  // Read each value
+  for (;;) {
+    // 1 - Parse value
+    JsonVariant &value = array.add();
+    parseAnythingTo(value);
+    if (!value.success()) goto ERROR_INVALID_VALUE;
+
+    // 2 - More values?
+    if (skip(']')) goto SUCCES_NON_EMPTY_ARRAY;
+    if (!skip(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_ARRAY:
+SUCCES_NON_EMPTY_ARRAY:
+  return array;
+
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACKET:
+ERROR_MISSING_COMMA:
+  return JsonArray::invalid();
+}
+
+JsonObject &JsonParser::parseObject() {
+  // Create an empty object
+  JsonObject &object = _buffer->createObject();
+
+  // Check opening brace
+  if (!skip('{')) goto ERROR_MISSING_BRACE;
+  if (skip('}')) goto SUCCESS_EMPTY_OBJECT;
+
+  // Read each key value pair
+  for (;;) {
+    // 1 - Parse key
+    const char *key = parseString();
+    if (!key) goto ERROR_INVALID_KEY;
+    if (!skip(':')) goto ERROR_MISSING_COLON;
+
+    // 2 - Parse value
+    JsonVariant &value = object.add(key);
+    parseAnythingTo(value);
+    if (!value.success()) goto ERROR_INVALID_VALUE;
+
+    // 3 - More keys/values?
+    if (skip('}')) goto SUCCESS_NON_EMPTY_OBJECT;
+    if (!skip(',')) 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:
+  return JsonObject::invalid();
+}
+
+void JsonParser::parseBooleanTo(JsonVariant &destination) {
+  if (skip("true"))
+    destination = true;
+  else if (skip("false"))
+    destination = false;
+  else
+    destination = JsonVariant::invalid();
+}
+
+void JsonParser::parseNumberTo(JsonVariant &destination) {
+  char *endOfLong;
+  long longValue = strtol(_ptr, &endOfLong, 10);
+  char stopChar = *endOfLong;
+
+  // Could it be a floating point value?
+  bool couldBeFloat = stopChar == '.' || stopChar == 'e' || stopChar == 'E';
+
+  if (couldBeFloat) {
+    // Yes => parse it as a double
+    double doubleValue = strtod(_ptr, &_ptr);
+    // Count the decimal digits
+    uint8_t decimals = static_cast<uint8_t>(_ptr - endOfLong - 1);
+    // Set the variant as a double
+    destination.set(doubleValue, decimals);
+  } else {
+    // No => set the variant as a long
+    _ptr = endOfLong;
+    destination = longValue;
+  }
+}
+
+void JsonParser::parseNullTo(JsonVariant &destination) {
+  const char *NULL_STRING = NULL;
+  if (skip("null"))
+    destination = NULL_STRING;
+  else
+    destination = JsonVariant::invalid();
+}
+
+const char *JsonParser::parseString() {
+  return QuotedString::extractFrom(_ptr, &_ptr);
+}