Merge branch 'parse-escaped-chars'

Added subscript operator on JsonArray and JsonHashTable

.gitignore

@@ -0,0 +1,6 @@
+*.sdf
+*.user
+*.suo
+Debug
+ipch
+*.opensdf

ArduinoJson.sln

@@ -0,0 +1,40 @@
+
+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
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonParser", "JsonParser\JsonParser.vcxproj", "{C15274DE-2695-4DFE-8520-4424223FE6DA}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonGenerator", "JsonGenerator\JsonGenerator.vcxproj", "{C6536D27-738D-4CEB-A2BC-E13C8897D894}"
+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
+		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Debug|Win32.Build.0 = Debug|Win32
+		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Release|Win32.ActiveCfg = Release|Win32
+		{C15274DE-2695-4DFE-8520-4424223FE6DA}.Release|Win32.Build.0 = Release|Win32
+		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Debug|Win32.Build.0 = Debug|Win32
+		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Release|Win32.ActiveCfg = Release|Win32
+		{C6536D27-738D-4CEB-A2BC-E13C8897D894}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

BuildArduinoPackage.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+ZIP="C:\Program Files\7-Zip\7z.exe"
+
+TAG=$(git describe)
+OUTPUT="ArduinoJson-$TAG.zip"
+
+cd ..
+
+INPUT=$(find ArduinoJson -regex ".*\.\(cpp\|h\|md\|txt\|ino\)$" -not -regex ".*Tests/.*")
+
+rm -f $OUTPUT
+"$ZIP" a $OUTPUT $INPUT

CHANGELOG.md

@@ -0,0 +1,103 @@
+Arduino JSON: change log
+========================
+
+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
+----
+
+* Fixed case `#include "jsmn.cpp"` which caused an error in Linux (issue #6)
+* Fixed a buffer overrun in JSON Parser (issue #5)
+
+v2.0
+----
+
+* Added JSON encoding (issue #2)
+* Renamed the library `ArduinoJsonParser` becomes `ArduinoJson`
+
+**Breaking change**: you need to add the following line at the top of your program.
+
+	using namespace ArduinoJson::Parser;
+
+v1.2
+----
+
+* Fixed error in JSON parser example (issue #1)
+
+v1.1
+----
+
+* Example: changed `char* json` into `char[] json` so that the bytes are not write protected
+* Fixed parsing bug when the JSON contains multi-dimensional arrays
+
+v1.0 
+----
+
+Initial release

JsonArray.cpp

@@ -1,67 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-JsonArray::JsonArray(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (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));
-}

JsonArray.h

@@ -1,42 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014 - MIT License
- */
-
-#ifndef __JSONARRAY_H
-#define __JSONARRAY_H
-
-#include "JsonObjectBase.h"
-
-class JsonHashTable;
-
-class JsonArray : public JsonObjectBase
-{
-	template <int N>
-	friend class JsonParser;
-
-	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);
-};
-
-#endif

JsonGenerator.cpp

@@ -0,0 +1,15 @@
+/*
+* 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/IndentedPrint.cpp"
+#include "JsonGenerator/JsonArrayBase.cpp"
+#include "JsonGenerator/JsonObjectBase.cpp"
+#include "JsonGenerator/JsonValue.cpp"
+#include "JsonGenerator/JsonPrettyPrint.cpp"
+#include "JsonGenerator/JsonPrintable.cpp"
+#include "JsonGenerator/StringBuilder.cpp"

JsonGenerator.h

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

JsonGenerator/EscapedString.cpp

@@ -0,0 +1,45 @@
+/*
+ * 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(const char* s, Print& p)
+{
+    if (!s) return p.print("null");
+    
+    size_t n = p.write('\"');
+
+    while (*s)
+    {
+        n += printCharTo(*s++, p);
+    }
+
+    return n + p.write('\"');
+}

JsonGenerator/EscapedString.h

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

JsonGenerator/IndentedPrint.cpp

@@ -0,0 +1,45 @@
+#include "IndentedPrint.h"
+
+using namespace ArduinoJson::Generator;
+
+void IndentedPrint::indent()
+{
+    if (level < MAX_LEVEL)
+        level++;
+}
+
+void IndentedPrint::unindent()
+{
+    if (level > 0)
+        level--;
+}
+
+void IndentedPrint::setTabSize(uint8_t n)
+{
+    if (n < MAX_TAB_SIZE)
+        tabSize = n;
+}
+
+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;
+}

JsonGenerator/IndentedPrint.h

@@ -0,0 +1,53 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "Print.h"
+
+namespace ArduinoJson
+{
+    namespace Generator
+    {
+        // 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:
+
+            IndentedPrint(Print& p)
+                : sink(p)
+            {
+                level = 0;
+                tabSize = 2;
+                isNewLine = true;
+            }
+
+            virtual size_t write(uint8_t);
+
+            // Adds one level of indentation
+            void indent();
+
+            // Removes one level of indentation
+            void unindent();
+
+            // Set the number of space printed for each level of indentation
+            void setTabSize(uint8_t n);
+
+        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
+        };
+    }
+}
+

JsonGenerator/JsonArray.h

@@ -0,0 +1,28 @@
+/*
+ * 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:
+            JsonValue items[N];
+        };
+    }
+}

JsonGenerator/JsonArrayBase.cpp

@@ -0,0 +1,34 @@
+/*
+* 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

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

JsonGenerator/JsonGenerator.vcxproj

@@ -0,0 +1,101 @@
+<?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>
+  <ItemGroup>
+    <ClInclude Include="EscapedString.h" />
+    <ClInclude Include="IndentedPrint.h" />
+    <ClInclude Include="JsonPrettyPrint.h" />
+    <ClInclude Include="JsonArray.h" />
+    <ClInclude Include="JsonArrayBase.h" />
+    <ClInclude Include="JsonObject.h" />
+    <ClInclude Include="JsonObjectBase.h" />
+    <ClInclude Include="JsonPrintable.h" />
+    <ClInclude Include="JsonValue.h" />
+    <ClInclude Include="Print.h" />
+    <ClInclude Include="Printable.h" />
+    <ClInclude Include="StringBuilder.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="EscapedString.cpp" />
+    <ClCompile Include="IndentedPrint.cpp" />
+    <ClCompile Include="JsonPrettyPrint.cpp" />
+    <ClCompile Include="JsonArrayBase.cpp" />
+    <ClCompile Include="JsonObjectBase.cpp" />
+    <ClCompile Include="JsonPrintable.cpp" />
+    <ClCompile Include="JsonValue.cpp" />
+    <ClCompile Include="Print.cpp" />
+    <ClCompile Include="StringBuilder.cpp" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C6536D27-738D-4CEB-A2BC-E13C8897D894}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>JsonGenerator</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </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 />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

JsonGenerator/JsonGenerator.vcxproj.filters

@@ -0,0 +1,84 @@
+<?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>
+    <ClInclude Include="EscapedString.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonArray.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonArrayBase.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonPrintable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonValue.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Print.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Printable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="StringBuilder.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonObjectBase.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonObject.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="IndentedPrint.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonPrettyPrint.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="EscapedString.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonArrayBase.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonValue.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="StringBuilder.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Print.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonObjectBase.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="IndentedPrint.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonPrettyPrint.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonPrintable.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

JsonGenerator/JsonObject.h

@@ -0,0 +1,44 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#pragma once
+
+#include "JsonObjectBase.h"
+
+#ifndef ARDUINO_JSON_NO_DEPRECATION_WARNING
+#ifdef __GNUC__
+#define DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#endif
+#else
+#define DEPRECATED
+#endif
+
+namespace ArduinoJson
+{
+    namespace Generator
+    {
+        template <int N>
+        class JsonObject : public JsonObjectBase
+        {
+        public:
+            JsonObject()
+                : JsonObjectBase(items, N)
+            {
+            }
+
+        private:
+            KeyValuePair items[N];
+        };
+
+        
+        // Obsolete: use JsonObject instead
+        template <int N>
+        class DEPRECATED JsonHashTable : public JsonObject<N>
+        {            
+        };
+    }
+}

JsonGenerator/JsonObjectBase.cpp

@@ -0,0 +1,92 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonObjectBase.h"
+#include <string.h> // for strcmp
+
+using namespace ArduinoJson::Generator;
+using namespace ArduinoJson::Internals;
+
+JsonValue JsonObjectBase::nullValue;
+
+size_t JsonObjectBase::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 += EscapedString::printTo(current->key, p);
+        n += p.write(':');
+        n += current->value.printTo(p);
+
+        current++;
+
+        if (i > 1)
+        {
+            n += p.write(',');
+        }
+    }
+
+    n += p.write('}');
+
+    return n;
+}
+
+JsonObjectBase::KeyValuePair* JsonObjectBase::getMatchingPair(JsonKey key) const
+{
+    KeyValuePair* p = items;
+
+    for (int i = count; i > 0; --i)
+    {
+        if (!strcmp(p->key, key))
+            return p;
+
+        p++;
+    }
+
+    return 0;
+}
+
+JsonValue& JsonObjectBase::operator[](JsonKey key)
+{
+    KeyValuePair* match = getMatchingPair(key);
+
+    if (match)
+        return match->value;
+
+    JsonValue* value;
+
+    if (count < capacity)
+    {
+        items[count].key = key;
+        value = &items[count].value;
+        count++;
+    }
+    else
+    {
+        value = &nullValue;
+    }
+
+    value->reset();
+    return *value;
+}
+
+bool JsonObjectBase::containsKey(JsonKey key) const
+{
+    return getMatchingPair(key) != 0;
+}
+
+void JsonObjectBase::remove(JsonKey key)
+{
+    KeyValuePair* match = getMatchingPair(key);    
+    if (match == 0) return;
+
+    *match = items[--count];
+}

JsonGenerator/JsonObjectBase.h

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

JsonGenerator/JsonPrettyPrint.cpp

@@ -0,0 +1,97 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonPrettyPrint.h"
+
+using namespace ArduinoJson::Generator;
+
+size_t JsonPrettyPrint::write(uint8_t c)
+{
+    size_t n = inString ? handleStringChar(c) : handleMarkupChar(c);    
+    previousChar = c;
+    return n;
+}
+
+inline size_t JsonPrettyPrint::handleStringChar(uint8_t c)
+{
+    bool isQuote = c == '"' && previousChar != '\\';
+
+    if (isQuote) inString = false;
+
+    return sink.write(c);
+}
+
+inline size_t JsonPrettyPrint::handleMarkupChar(uint8_t c)
+{
+    switch (c)
+    {
+    case '{':
+    case '[':
+        return handleBlockOpen(c);
+
+    case '}':
+    case ']':
+        return handleBlockClose(c);
+
+    case ':':
+        return handleColumn();
+
+    case ',':
+        return handleComma();
+
+    case '"':
+        return handleQuoteOpen();
+
+    default:
+        return handleNormalChar(c);
+    }
+}
+
+inline size_t JsonPrettyPrint::handleBlockOpen(uint8_t c)
+{
+    return indentIfNeeded() + sink.write(c);
+}
+
+inline size_t JsonPrettyPrint::handleBlockClose(uint8_t c)
+{  
+    return unindentIfNeeded() + sink.write(c);
+}
+
+inline size_t JsonPrettyPrint::handleColumn()
+{
+    return sink.write(':') + sink.write(' ');
+}
+
+inline size_t JsonPrettyPrint::handleComma() 
+{
+    return sink.write(',') + sink.println();
+}
+
+inline size_t JsonPrettyPrint::handleQuoteOpen()
+{
+    inString = true;
+    return indentIfNeeded() + sink.write('"');
+}
+
+inline size_t JsonPrettyPrint::handleNormalChar(uint8_t c)
+{
+    return indentIfNeeded() + sink.write(c);
+}
+
+size_t JsonPrettyPrint::indentIfNeeded()
+{
+    if (!inEmptyBlock()) return 0;
+
+    sink.indent();
+    return sink.println();
+}
+
+size_t JsonPrettyPrint::unindentIfNeeded()
+{
+    if (inEmptyBlock()) return 0;
+
+    sink.unindent();
+    return sink.println();
+}

JsonGenerator/JsonPrettyPrint.h

@@ -0,0 +1,52 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "Print.h"
+#include "IndentedPrint.h"
+
+namespace ArduinoJson
+{
+    namespace Generator
+    {
+        // Converts a compact JSON string into an indented one.
+        class JsonPrettyPrint : public Print
+        {
+        public:
+
+            JsonPrettyPrint(IndentedPrint& p)
+                : sink(p)
+            {
+                previousChar = 0;
+                inString = false;
+            }
+
+            virtual size_t write(uint8_t);
+
+        private:            
+            uint8_t previousChar;
+            IndentedPrint& sink;
+            bool inString;
+
+            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();
+        };
+    }
+}

JsonGenerator/JsonPrintable.cpp

@@ -0,0 +1,35 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonPrintable.h"
+#include "JsonPrettyPrint.h"
+#include "StringBuilder.h"
+
+using namespace ArduinoJson::Generator;
+using namespace ArduinoJson::Internals;
+
+size_t JsonPrintable::printTo(char* buffer, size_t bufferSize) const
+{
+    StringBuilder sb(buffer, bufferSize);
+    return printTo(sb);
+}
+
+size_t JsonPrintable::prettyPrintTo(char* buffer, size_t bufferSize) const
+{
+    StringBuilder sb(buffer, bufferSize);
+    return prettyPrintTo(sb);
+}
+
+size_t JsonPrintable::prettyPrintTo(IndentedPrint& p) const
+{
+    JsonPrettyPrint prettyPrint(p);
+    return printTo(prettyPrint);
+}
+
+size_t JsonPrintable::prettyPrintTo(Print& p) const
+{
+    IndentedPrint indentedPrint(p);
+    return prettyPrintTo(indentedPrint);
+}

JsonGenerator/JsonPrintable.h

@@ -0,0 +1,40 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#pragma once
+
+#include "Print.h"
+#include "Printable.h"
+#include "IndentedPrint.h"
+
+namespace ArduinoJson
+{
+    namespace Generator
+    {
+        // Contains methods to generate a JSON string.
+        // Implemented by both JsonObject and JsonArray
+        class JsonPrintable : public Printable
+        {
+        public:
+
+            // Generates the compact JSON string and sends it to a Print stream 
+            virtual size_t printTo(Print& p) const = 0;
+
+            // Generates the compact JSON string and writes it in a buffer
+            size_t printTo(char* buffer, size_t bufferSize) const;
+
+            // Generates the indented JSON string and sends it to a Print stream
+            size_t prettyPrintTo(Print& p) const;
+
+            // Generates the indented JSON string and sends it to a IndentedPrint stream
+            // This overload allows a finer control of the output because you can customize
+            // the IndentedPrint.
+            size_t prettyPrintTo(IndentedPrint& p) const;
+
+            // Generates the indented JSON string and writes it in a buffer
+            size_t prettyPrintTo(char* buffer, size_t bufferSize) const;
+        };
+    }
+}

JsonGenerator/JsonValue.cpp

@@ -0,0 +1,33 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#include "EscapedString.h"
+#include "JsonValue.h"
+
+using namespace ArduinoJson::Generator;
+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 EscapedString::printTo(c.asString, p);
+}

JsonGenerator/JsonValue.h

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

@@ -0,0 +1,40 @@
+/*
+ * 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);
+}
+
+size_t Print::println()
+{
+    return write('\r') + write('\n');
+}
+
+#endif

JsonGenerator/Print.h

@@ -0,0 +1,29 @@
+/*
+ * 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);
+    size_t println();
+};
+
+#else
+
+#include <Print.h>
+
+#endif

JsonGenerator/Printable.h

@@ -0,0 +1,24 @@
+/*
+ * 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

@@ -0,0 +1,247 @@
+Arduino JSON library - Generator
+================================
+
+*An elegant and efficient JSON encoder 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
+--------
+
+* Elegant API, very easy to use 
+* Fixed memory allocation (no malloc)
+* Small footprint
+* Supports nested objects
+* Supports indented output
+* Implements Arduino's `Printable interface
+* MIT License
+
+
+Example
+-------
+
+    JsonArray<2> array;
+    array.add<6>(48.756080);  // <6> specifies the number of digits in the output
+    array.add<6>(2.302038);   // (the default is 2)
+
+    JsonObject<3> root;
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+    root["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;
+
+> ##### Having a namespace conflict?
+> To be able to use both `ArduinoJson::Generator` and `ArduinoJson::Parser` in the same file, you need to do one of the followings:
+> 
+> * Put the `using` statements into different functions
+> * `using namespace ArduinoJson`, then prefix the type names by `Generator::` or `Parser::`
+> * Create aliases for the namespaces or the types (C++11 only)
+   
+### 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 a JSON Array or a JSON Object.
+
+#### JSON 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 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
+
+    JsonObject<8> nestedObject;
+    array.add(nestedObject);
+
+> ##### CAUTION! Nested objects must be in memory
+> Calling `add()` makes the `JsonArray` store a pointer to the nested object.
+> This is designed to avoid memory duplication.
+> But it can only work if the object is in memory when `printTo()` is executed.
+> For instance, don't do this:
+> 
+>     void addNestedObject()
+>     {
+>         JsonObject<2> nestedObject;
+>         // ...
+>         array.add(nestedObject); // <- DON'T !!
+>         
+>         // array now contains a pointer to a local variable that will be
+>         // discarded as soon as the function exits 
+>     } 
+>     
+> For the same reason, don't do this either:
+> 
+>     for( int i=0; i<100; i++)
+>     {
+>         JsonObject<2> nestedObject;
+>         // ...
+>         array.add(nestedObject); // <- DON'T !!
+>     }  
+>     // array now contains 100 pointers to the same a local variable
+>     // that is out of the scope anyway
+
+#### JSON Object
+
+You create a JSON object (ie hash-table/dictionary) with the following line:
+
+    JsonObject<8> object;
+
+Like with the array class, there is a template parameter that gives the capacity of 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<4>(3.1415);  // 4 digits "3.1415" 
+    object["key5"] = 3.1415;	    // default: 2 digits "3.14"
+
+Finally you can add nested objects:
+
+    JsonArray<8> nestedArray;
+    object["key6"] = nestedArray;
+
+or
+
+    JsonObject<8> nestedObject;
+    object["key7"] = nestedObject;
+
+> ##### 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`
+
+### 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 `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 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 `JsonObject` 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`, `Wire`...
+   
+
+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     |
+| JsonObject&lt;N&gt; | 8 + 8 x N     |
+
+
+Code size
+---------
+
+The following values has been obtained with Arduino IDE 1.0.5, targeting an Arduino Duelmilanove with an ATmega 328.
+
+### Minimum setup
+
+| Function                            | Size |
+| ----------------------------------- | ---- |
+| `JsonObjectBase::printTo()`         | 234  |
+| `EscapedString::printTo()`          | 196  |
+| `JsonArrayBase::printTo()`          | 164  |
+| `Print::print(char const*)`         | 146  |
+| `JsonObjectBase::operator[]`        | 114  |
+| `JsonObjectBase::getMatchingPair()` | 72   |
+| `JsonValue::printPrintableTo()`     | 40   |
+| `JsonValue::printStringTo()`        | 12   |
+
+### Additional space for integers
+
+| Function                     | Size |
+| ---------------------------- | ---- |
+| `Print::print(long, int)`    | 328  |
+| `JsonValue::printLongTo()`   | 22   |
+
+### Additional space for floating point
+
+| Function                       | Size |
+| ------------------------------ | ---- |
+| `Print::print(double, int)`    | 1548 |
+| `JsonValue::printDouleTo<2>()` | 22   |

JsonGenerator/StringBuilder.cpp

@@ -0,0 +1,17 @@
+/*
+ * 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

@@ -0,0 +1,31 @@
+/*
+ * 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

@@ -0,0 +1,95 @@
+/*
+* 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;
+        
+    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));  
+            returnValue = EscapedString::printTo(input, sb);
+        }
+
+        void outputMustBe(const char* expected)
+        {
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), returnValue);
+        }
+    };
+}

JsonGeneratorTests/Issue10.cpp

@@ -0,0 +1,73 @@
+#include "CppUnitTest.h"
+#include "JsonArray.h"
+#include "JsonObject.h"
+
+using namespace ArduinoJson::Generator;
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(Issue10)
+    {
+        struct Person {
+            int id;
+            char name[32];
+        };
+
+        Person persons[2];
+
+    public:
+
+        TEST_METHOD_INITIALIZE(Initialize)
+        {
+            Person boss;
+            boss.id = 1;
+            strcpy(boss.name, "Jeff");
+            Person employee;
+            employee.id = 2;
+            strcpy(employee.name, "John");
+            persons[0] = boss;
+            persons[1] = employee;
+        }
+
+        TEST_METHOD(WrongWayToAddObjectInAnArray)
+        {
+            JsonArray<2> json;
+
+            for (int i = 0; i < 2; i++)
+            {
+                JsonObject<2> object;
+                
+                object["id"] = persons[i].id;
+                object["name"] = persons[i].name;
+
+                json.add(object); // <- Adding a reference to a temporary variable
+            }
+
+            char buffer[256];
+            json.printTo(buffer, sizeof(buffer));
+
+            // the same values are repeated, that's normal
+            Assert::AreEqual("[{\"id\":2,\"name\":\"John\"},{\"id\":2,\"name\":\"John\"}]", buffer);  
+        }
+
+        TEST_METHOD(RightWayToAddObjectInAnArray)
+        {
+            JsonArray<2> json;
+            JsonObject<2> object[2];
+
+            for (int i = 0; i < 2; i++) 
+            {
+                object[i]["id"] = persons[i].id;
+                object[i]["name"] = persons[i].name;
+
+                json.add(object[i]);
+            }
+
+            char buffer[256];
+            json.printTo(buffer, sizeof(buffer));
+
+            Assert::AreEqual("[{\"id\":1,\"name\":\"Jeff\"},{\"id\":2,\"name\":\"John\"}]", buffer);
+        }
+    };
+}

JsonGeneratorTests/JsonArrayTests.cpp

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

JsonGeneratorTests/JsonGeneratorTests.vcxproj

@@ -0,0 +1,107 @@
+<?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>ARDUINO_JSON_NO_DEPRECATION_WARNING;_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="EscapedStringTests.cpp" />
+    <ClCompile Include="PrettyPrint_Array_Tests.cpp" />
+    <ClCompile Include="PrettyPrint_Object_Tests.cpp" />
+    <ClCompile Include="PrettyPrint_String_Tests.cpp" />
+    <ClCompile Include="Issue10.cpp" />
+    <ClCompile Include="JsonArrayTests.cpp" />
+    <ClCompile Include="JsonObject_Indexer_Tests.cpp" />
+    <ClCompile Include="JsonObject_PrintTo_Tests.cpp" />
+    <ClCompile Include="JsonValue_Cast_Tests.cpp" />
+    <ClCompile Include="JsonValue_PrintTo_Tests.cpp" />
+    <ClCompile Include="StringBuilderTests.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\JsonGenerator\JsonGenerator.vcxproj">
+      <Project>{c6536d27-738d-4ceb-a2bc-e13c8897d894}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

JsonGeneratorTests/JsonGeneratorTests.vcxproj.filters

@@ -0,0 +1,52 @@
+<?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="StringBuilderTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="EscapedStringTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonObject_PrintTo_Tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonObject_Indexer_Tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonValue_PrintTo_Tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonValue_Cast_Tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Issue10.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="PrettyPrint_Array_Tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="PrettyPrint_Object_Tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="PrettyPrint_String_Tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

JsonGeneratorTests/JsonObject_Indexer_Tests.cpp

@@ -0,0 +1,73 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "JsonArray.h"
+#include "JsonObject.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Generator;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(JsonObject_Indexer_Tests)
+    {
+        JsonObject<2> object;
+
+    public:
+
+        TEST_METHOD(Empty)
+        {
+            mustNotContain("key");
+        }
+        
+        TEST_METHOD(TwoStrings)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+
+            mustContain("key1", "value1");
+            mustContain("key2", "value2");
+        }
+
+        TEST_METHOD(RemoveFirst)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+            object.remove("key1");
+
+            mustNotContain("key1");
+            mustContain("key2", "value2");
+        }
+
+        TEST_METHOD(RemoveLast)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+            object.remove("key2");
+
+            mustContain("key1", "value1");
+            mustNotContain("key2");
+        }
+
+    private:
+
+        void mustContain(const char* key, const char* expected)
+        {
+            Assert::IsTrue(object.containsKey(key));
+
+            const char* actual = object[key];
+            Assert::AreEqual(expected, actual);
+        }
+
+        void mustNotContain(const char* key)
+        {
+            Assert::IsFalse(object.containsKey(key));
+
+            const char* actual = object[key];
+            Assert::IsNull(actual);
+        }
+    };
+}

JsonGeneratorTests/JsonObject_PrintTo_Tests.cpp

@@ -0,0 +1,152 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "JsonArray.h"
+#include "JsonObject.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Generator;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(JsonObject_PrintTo_Tests)
+    {
+        JsonObject<2> object;
+
+    public:
+
+        TEST_METHOD(Empty)
+        {
+            outputMustBe("{}");
+        }
+
+        TEST_METHOD(OneString)
+        {
+            object["key"] = "value";
+
+            outputMustBe("{\"key\":\"value\"}");
+        }
+
+        TEST_METHOD(TwoStrings)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+
+            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+        }
+
+        TEST_METHOD(RemoveFirst)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+            object.remove("key1");
+
+            outputMustBe("{\"key2\":\"value2\"}");
+        }
+
+        TEST_METHOD(RemoveLast)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+            object.remove("key2");
+
+            outputMustBe("{\"key1\":\"value1\"}");
+        }
+
+        TEST_METHOD(RemoveUnexistingKey)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+            object.remove("key3");
+
+            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+        }
+
+        TEST_METHOD(ReplaceExistingKey)
+        {
+            object["key"] = "value1";
+            object["key"] = "value2";
+
+            outputMustBe("{\"key\":\"value2\"}");
+        }
+
+        TEST_METHOD(OneStringOverCapacity)
+        {
+            object["key1"] = "value1";
+            object["key2"] = "value2";
+            object["key3"] = "value3";
+
+            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+        }
+
+        TEST_METHOD(OneInteger)
+        {
+            object["key"] = 1;
+            outputMustBe("{\"key\":1}");
+        }
+
+        TEST_METHOD(OneDoubleFourDigits)
+        {
+            object["key"].set<4>(3.14159265358979323846);
+            outputMustBe("{\"key\":3.1416}");
+        }
+
+        TEST_METHOD(OneDoubleDefaultDigits)
+        {
+            object["key"] = 3.14159265358979323846;
+            outputMustBe("{\"key\":3.14}");
+        }
+
+        TEST_METHOD(OneNull)
+        {
+            object["key"] = (char*) 0;
+            outputMustBe("{\"key\":null}");
+        }
+
+        TEST_METHOD(OneTrue)
+        {
+            object["key"] = true;
+            outputMustBe("{\"key\":true}");
+        }
+
+        TEST_METHOD(OneFalse)
+        {
+            object["key"] = false;
+            outputMustBe("{\"key\":false}");
+        }
+
+        TEST_METHOD(OneEmptyNestedArray)
+        {
+            auto nestedArray = JsonArray<1>();
+
+            object["key"] = nestedArray;
+            
+            outputMustBe("{\"key\":[]}");
+        }
+
+        TEST_METHOD(OneEmptyNestedObject)
+        {
+            auto nestedObject = JsonObject<1>();
+
+            object["key"] = nestedObject;
+
+            outputMustBe("{\"key\":{}}");
+        }
+
+    private:
+
+        void outputMustBe(const char* expected)
+        {
+            char buffer[256];
+            size_t result;
+            
+            result = object.printTo(buffer, sizeof(buffer));
+            
+            Assert::AreEqual(strlen(expected), result);
+            Assert::AreEqual(expected, buffer);
+        }
+    };
+}

JsonGeneratorTests/JsonValue_Cast_Tests.cpp

@@ -0,0 +1,78 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "StringBuilder.h"
+#include "JsonValue.h"
+#include "JsonArray.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Generator;
+using namespace ArduinoJson::Internals;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(JsonValue_Cast_Tests)
+    {
+        JsonValue value;
+
+    public:
+
+        TEST_METHOD(Bool)
+        {
+            setValueAndCheckCast(true);
+            setValueAndCheckCast(false);
+        }
+
+        TEST_METHOD(Double)
+        {
+            setValueAndCheckCast(3.14156);
+        }
+
+        TEST_METHOD(Float)
+        {
+            setValueAndCheckCast(3.14f);
+        }
+
+        TEST_METHOD(Integer)
+        {
+            setValueAndCheckCast(42);
+        }
+
+        TEST_METHOD(Long)
+        {
+            setValueAndCheckCast(42L);
+        }
+
+        TEST_METHOD(Array)
+        {
+            JsonArray<2> array;
+            setValueAndCheckCast(array);
+        }
+
+        TEST_METHOD(String)
+        {
+            setValueAndCheckCast("hello");
+        }
+
+    private:
+
+        template<typename T>
+        void setValueAndCheckCast(T expected)
+        {
+            value = expected;
+            T actual = value;
+            Assert::AreEqual(expected, actual);
+        }
+
+        template<int N>
+        void setValueAndCheckCast(JsonArray<N>& expected)
+        {
+            value = expected;
+            const Printable& actual = value;
+            Assert::AreEqual((void*) &expected, (void*) &actual);
+        }
+    };
+}

JsonGeneratorTests/JsonValue_PrintTo_Tests.cpp

@@ -0,0 +1,103 @@
+/*
+* 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::Generator;
+using namespace ArduinoJson::Internals;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(JsonValue_PrintTo_Tests)
+    {
+        char buffer[1024];
+        size_t returnValue;
+
+    public:
+
+        TEST_METHOD(String)
+        {
+            setValueTo("hello");
+            outputMustBe("\"hello\"");
+        }
+
+        TEST_METHOD(Float)
+        {
+            setValueTo(3.1415f);
+            outputMustBe("3.14");
+        }
+
+        TEST_METHOD(DoubleZeroDigits)
+        {
+            setValueTo<0>(3.14159265358979323846);
+            outputMustBe("3");
+        }
+
+        TEST_METHOD(DoubleOneDigit)
+        {
+            setValueTo<1>(3.14159265358979323846);
+            outputMustBe("3.1");
+        }
+
+        TEST_METHOD(DoubleTwoDigits)
+        {
+            setValueTo<2>(3.14159265358979323846);
+            outputMustBe("3.14");
+        }
+        
+        TEST_METHOD(Integer)
+        {
+            setValueTo(314);
+            outputMustBe("314");
+        }
+
+        TEST_METHOD(Char)
+        {
+            setValueTo('A');
+            outputMustBe("65");
+        }
+
+        TEST_METHOD(Short)
+        {
+            setValueTo((short)314);
+            outputMustBe("314");
+        }
+
+        TEST_METHOD(Long)
+        {
+            setValueTo(314159265L);
+            outputMustBe("314159265");
+        }
+
+    private:
+
+        template<int DIGITS>
+        void setValueTo(double value)
+        {
+            StringBuilder sb(buffer, sizeof(buffer));
+            JsonValue jsonValue;
+            jsonValue.set<DIGITS>(value);
+            returnValue = jsonValue.printTo(sb);
+        }
+
+        template<typename T>
+        void setValueTo(T value)
+        {
+            StringBuilder sb(buffer, sizeof(buffer));
+            JsonValue jsonValue;
+            jsonValue = value;
+            returnValue = jsonValue.printTo(sb);
+        }
+
+        void outputMustBe(const char* expected)
+        {
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), returnValue);
+        }
+    };
+}

JsonGeneratorTests/PrettyPrint_Array_Tests.cpp

@@ -0,0 +1,91 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "JsonPrettyPrint.h"
+#include "StringBuilder.h"
+
+using namespace ArduinoJson::Internals;
+using namespace ArduinoJson::Generator;
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(PrettyPrint_Array_Tests)
+    {
+        char buffer[1024];
+        size_t returnValue;
+
+    public:
+        
+        TEST_METHOD(EmptyArray)
+        {
+            whenInputIs("[]");
+            outputMustBe("[]");
+        }
+
+        TEST_METHOD(OneElement)
+        {
+            whenInputIs("[1]");
+            outputMustBe(
+                "[\r\n"
+                "  1\r\n"
+                "]");
+        }
+
+        TEST_METHOD(TwoElements)
+        {
+            whenInputIs("[1,2]");
+            outputMustBe(
+                "[\r\n"
+                "  1,\r\n"
+                "  2\r\n"
+                "]");
+        }
+
+        TEST_METHOD(EmptyNestedArrays)
+        {
+            whenInputIs("[[],[]]");
+            outputMustBe(
+                "[\r\n"
+                "  [],\r\n"
+                "  []\r\n"
+                "]");
+        }
+
+        TEST_METHOD(NestedArrays)
+        {
+            whenInputIs("[[1,2],[3,4]]");
+            outputMustBe(
+                "[\r\n"
+                "  [\r\n"
+                "    1,\r\n"
+                "    2\r\n"
+                "  ],\r\n"
+                "  [\r\n"
+                "    3,\r\n"
+                "    4\r\n"
+                "  ]\r\n"
+                "]");
+        }
+
+    private:
+
+        void whenInputIs(const char input[])
+        {
+            StringBuilder sb(buffer, sizeof(buffer));
+            IndentedPrint indentedPrint(sb);
+            JsonPrettyPrint decorator(indentedPrint);
+
+            returnValue = decorator.print(input);
+        }
+
+        void outputMustBe(const char* expected)
+        {
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), returnValue);
+        }
+    };
+}

JsonGeneratorTests/PrettyPrint_Object_Tests.cpp

@@ -0,0 +1,89 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "JsonPrettyPrint.h"
+#include "StringBuilder.h"
+
+using namespace ArduinoJson::Internals;
+using namespace ArduinoJson::Generator;
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(PrettyPrint_Object_Tests)
+    {
+        char buffer[1024];
+        size_t returnValue;
+
+    public:
+
+        TEST_METHOD(EmptyObject)
+        {
+            whenInputIs("{}");
+            outputMustBe("{}");
+        }
+
+        TEST_METHOD(OneMember)
+        {
+            whenInputIs("{\"key\":\"value\"}");
+            outputMustBe(
+                "{\r\n"
+                "  \"key\": \"value\"\r\n"
+                "}");
+        }
+
+        TEST_METHOD(TwoMembers)
+        {
+            whenInputIs("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+            outputMustBe(
+                "{\r\n"
+                "  \"key1\": \"value1\",\r\n"
+                "  \"key2\": \"value2\"\r\n"
+                "}");
+        }
+
+        TEST_METHOD(EmptyNestedObjects)
+        {
+            whenInputIs("{\"key1\":{},\"key2\":{}}");
+            outputMustBe(
+                "{\r\n"
+                "  \"key1\": {},\r\n"
+                "  \"key2\": {}\r\n"
+                "}");
+        }
+
+        TEST_METHOD(NestedObjects)
+        {
+            whenInputIs("{\"key1\":{\"a\":1},\"key2\":{\"b\":2}}");
+            outputMustBe(
+                "{\r\n"
+                "  \"key1\": {\r\n"
+                "    \"a\": 1\r\n"
+                "  },\r\n"
+                "  \"key2\": {\r\n"
+                "    \"b\": 2\r\n"
+                "  }\r\n"
+                "}");
+        }
+
+    private:
+
+        void whenInputIs(const char input[])
+        {
+            StringBuilder sb(buffer, sizeof(buffer));
+            IndentedPrint indentedPrint(sb);
+            JsonPrettyPrint decorator(indentedPrint);
+
+            returnValue = decorator.print(input);
+        }
+
+        void outputMustBe(const char* expected)
+        {
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), returnValue);
+        }
+    };
+}

JsonGeneratorTests/PrettyPrint_String_Tests.cpp

@@ -0,0 +1,76 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "JsonPrettyPrint.h"
+#include "StringBuilder.h"
+
+using namespace ArduinoJson::Internals;
+using namespace ArduinoJson::Generator;
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(PrettyPrint_String_Tests)
+    {
+        char buffer[1024];
+        size_t returnValue;
+
+    public:
+        
+        TEST_METHOD(EmptyString)
+        {
+            whenInputIs("");
+            outputMustBe("");
+        }
+
+        TEST_METHOD(TrickyCharacters)
+        {
+            whenInputIs ("\":\\\"',\"");
+            outputMustBe("\":\\\"',\"");
+        }
+
+        TEST_METHOD(OpeningCurlyBrace)
+        {
+            whenInputIs ("\"{\"");
+            outputMustBe("\"{\"");
+        }
+
+        TEST_METHOD(OpeningSquareBrace)
+        {
+            whenInputIs("\"[\"");
+            outputMustBe("\"[\"");
+        }
+
+        TEST_METHOD(ClosingCurlyBrace)
+        {
+            whenInputIs("\"}\"");
+            outputMustBe("\"}\"");
+        }
+
+        TEST_METHOD(ClosingSquareBrace)
+        {
+            whenInputIs("\"]\"");
+            outputMustBe("\"]\"");
+        }
+               
+    private:
+
+        void whenInputIs(const char input[])
+        {
+            StringBuilder sb(buffer, sizeof(buffer));
+            IndentedPrint indentedPrint(sb);
+            JsonPrettyPrint decorator(indentedPrint);
+
+            returnValue = decorator.print(input);
+        }
+
+        void outputMustBe(const char* expected)
+        {
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), returnValue);
+        }
+    };
+}

JsonGeneratorTests/StringBuilderTests.cpp

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

JsonHashTable.cpp

@@ -1,84 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-#include <string.h> // for strcmp()
-
-JsonHashTable::JsonHashTable(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (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));
-}

JsonHashTable.h

@@ -1,39 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#ifndef __JSONHASHTABLE_H
-#define __JSONHASHTABLE_H
-
-#include "JsonObjectBase.h"
-
-class JsonArray;
-
-class JsonHashTable : public JsonObjectBase
-{
-	template <int N>
-	friend class JsonParser;
-
-	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);
-};
-
-#endif

JsonObjectBase.cpp

@@ -1,63 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014
- * MIT License
- */
-
-#include "JsonObjectBase.h"
-
-#include <stdlib.h> // for strtol, strtod
-
-int JsonObjectBase::getNestedTokenCount(jsmntok_t* token)
-{
-	int count = 0;
-
-	for (int i = 0; i < token->size; i++)
-	{
-		count += 1 + getNestedTokenCount(token + 1 + i);
-	}
-
-	return count;
-}
-
-bool JsonObjectBase::getBoolFromToken(jsmntok_t* token)
-{
-	if (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;
-}

JsonObjectBase.h

@@ -1,52 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014
- * MIT License
- */
-
-#ifndef __JSONOBJECTBASE_H
-#define __JSONOBJECTBASE_H
-
-#include "utility/jsmn.h"
-
-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;
-};
-
-#endif
-

JsonParser.cpp

@@ -0,0 +1,13 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+// This file is here to help the Arduino IDE find the .cpp files
+
+#include "JsonParser/JsonArray.cpp"
+#include "JsonParser/JsonObject.cpp"
+#include "JsonParser/JsonParserBase.cpp"
+#include "JsonParser/JsonValue.cpp"
+#include "JsonParser/JsonToken.cpp"
+#include "JsonParser/jsmn.cpp"

JsonParser.h

@@ -3,67 +3,4 @@
 * Benoit Blanchon 2014 - MIT License
 */
 
-#ifndef __JSONPARSER_H
-#define __JSONPARSER_H
-
-#include "JsonHashTable.h"
-#include "JsonArray.h"
-
-/*
-* 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:
-
-	/*
-	* 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* parse(char* json)
-	{
-		jsmn_parser parser;
-		jsmn_init(&parser);
-
-		if (JSMN_SUCCESS != jsmn_parse(&parser, json, tokens, MAX_TOKENS))
-			return 0;
-
-		return tokens;
-	}
-
-	jsmntok_t tokens[MAX_TOKENS];
-};
-
-#endif
-
+#include "JsonParser/JsonParser.h"

JsonParser/JsonArray.cpp

@@ -0,0 +1,14 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonArray.h"
+#include "JsonObject.h"
+
+using namespace ArduinoJson::Parser;
+
+DEPRECATED JsonObject JsonArray::getHashTable(int index)
+{
+    return operator[](index);
+}

JsonParser/JsonArray.h

@@ -0,0 +1,103 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#pragma once
+
+#include "JsonValue.h"
+#include "JsonArrayIterator.h"
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        class JsonObject;
+                
+        // A JSON array
+        class JsonArray : JsonValue
+        {          
+        public:
+
+            // Create an invalid array
+            JsonArray() 
+            {            
+            }
+
+            // Convert a JsonValue into a JsonArray
+            JsonArray(JsonValue value)
+                : JsonValue(value)
+            {
+            }
+
+            // Tell if the array is valid
+            bool success()
+            {
+                return isArray();
+            }
+
+            // Get the JsonValue at specified index
+            JsonValue operator[](int index)
+            {
+                return JsonValue::operator[](index);
+            }
+
+            // Get the size of the array
+            int size()
+            {
+                return isArray() ? childrenCount() : 0;
+            }
+
+            // Get an iterator pointing to the beginning of the array
+            JsonArrayIterator begin()
+            {
+                return isArray() ? firstChild() : null();
+            }
+
+            // Gets an iterator pointing to the end of the array
+            JsonArrayIterator end()
+            {
+                return isArray() ? nextSibling() : null();
+            }
+
+            // Obsolete: Use size() instead
+            DEPRECATED int getLength()
+            {
+                return size();
+            }
+                   
+            // Obsolete: Use operator[] instead
+            DEPRECATED JsonArray getArray(int index)
+            {
+                return operator[](index);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED bool getBool(int index)
+            {
+                return operator[](index);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED double getDouble(int index)
+            {
+                return operator[](index);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED JsonObject getHashTable(int index);
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED long getLong(int index)
+            {
+                return operator[](index);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED char* getString(int index)
+            {
+                return operator[](index);
+            }
+        };
+    }
+}

JsonParser/JsonArrayIterator.h

@@ -0,0 +1,46 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "JsonValue.h"
+#include "JsonToken.h"
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        // An iterator for JsonArray
+        class JsonArrayIterator : JsonToken
+        {
+        public:
+
+            // Create an iterator pointing at the specified JsonToken
+            JsonArrayIterator(JsonToken token)
+                : JsonToken(token)
+            {
+
+            }
+
+            // Move iterator forward
+            void operator++()
+            {
+                *this = JsonArrayIterator(nextSibling());
+            }
+
+            // Get the value pointed by the iterator
+            JsonValue operator*() const
+            {
+                return JsonValue(*this);
+            }
+
+            // Test iterator equality
+            bool operator!= (const JsonArrayIterator& other) const
+            {
+                return JsonToken::operator!=(other);
+            }
+        };
+    }
+}

JsonParser/JsonObject.cpp

@@ -0,0 +1,15 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonArray.h"
+#include "JsonObject.h"
+#include "JsonValue.h"
+
+using namespace ArduinoJson::Parser;
+
+DEPRECATED JsonArray JsonObject::getArray(const char* key)
+{
+    return operator[](key);
+}

JsonParser/JsonObject.h

@@ -0,0 +1,102 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "JsonValue.h"
+#include "JsonObjectIterator.h"
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        class JsonArray;
+
+        // A JSON Object (ie hash-table/dictionary)
+        class JsonObject : JsonValue
+        {
+        public:
+
+            // Create an invalid JsonObject
+            JsonObject()
+            {
+
+            }
+
+            // Convert a JsonValue into a JsonObject
+            JsonObject(JsonValue value)
+                : JsonValue(value)
+            {
+
+            }
+
+            // Tell if the object is valid
+            bool success()
+            {
+                return isObject();
+            }           
+
+            // Get the value associated with the specified key.
+            JsonValue operator[](const char* key)
+            {
+                return JsonValue::operator[](key);
+            }
+
+            // Tell if the specified key exists in the object.
+            bool containsKey(const char* key)
+            {
+                return operator[](key).success();
+            }
+
+            // Get an iterator pointing at the beginning of the object
+            JsonObjectIterator begin()
+            {
+                return isObject() ? firstChild() : null();
+            }
+
+            // Get an iterator pointing at the end of the object
+            JsonObjectIterator end()
+            {
+                return isObject() ? nextSibling() : null();
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED JsonArray getArray(const char* key);
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED bool getBool(const char* key)
+            {
+                return operator[](key);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED double getDouble(const char* key)
+            {
+                return operator[](key);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED JsonObject getHashTable(const char* key)
+            {
+                return operator[](key);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED long getLong(const char* key)
+            {
+                return operator[](key);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED char* getString(const char* key)
+            {
+                return operator[](key);
+            }
+        };
+
+        // Obsolete: Use JsonObject instead
+        DEPRECATED typedef JsonObject JsonHashTable;
+    }
+}

JsonParser/JsonObjectIterator.h

@@ -0,0 +1,58 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "JsonValue.h"
+#include "JsonPair.h"
+#include "JsonToken.h"
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        // An iterator for JsonObject
+        class JsonObjectIterator : JsonToken
+        {
+        public:
+
+            // Create an iterator pointing at the specified token
+            JsonObjectIterator(JsonToken token)
+                : JsonToken(token)
+            {
+            }
+
+            // Move to the next JsonPair
+            void operator++()
+            {
+                *this = JsonObjectIterator(nextSibling().nextSibling());
+            }
+
+            // Get the JsonPair pointed by the iterator
+            JsonPair operator*() const
+            {
+                return JsonPair(*this);
+            }
+
+            // Test iterator equality
+            bool operator!= (const JsonObjectIterator& other) const
+            {
+                return JsonToken::operator!=(other);
+            }
+
+            // Get the key of the JsonPair pointed by the iterator
+            const char* key() const
+            {
+                return operator*().key();
+            }
+
+            // Get the key of the JsonPair pointed by the iterator
+            JsonValue value() const
+            {
+                return operator*().value();
+            }
+        };
+    }
+}

JsonParser/JsonPair.h

@@ -0,0 +1,37 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "JsonValue.h"
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        // A JSON key-value pair, as a part of a JSON object
+        class JsonPair : JsonToken
+        {
+        public:
+            // Convert a JsonToken to a JsonPair
+            JsonPair(JsonToken token)
+                : JsonToken(token)
+            {
+            }
+
+            // Get the key
+            const char* key()
+            {
+                return getText();
+            }
+
+            // Get the value
+            JsonValue value()
+            {
+                return nextSibling();
+            }
+        };
+    }
+}

JsonParser/JsonParser.h

@@ -0,0 +1,35 @@
+/*
+* 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.
+        //
+        // CAUTION: JsonArray, JsonObject and JsonValue 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, JsonObject or JsonValue 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/JsonParser.vcxproj

@@ -0,0 +1,96 @@
+<?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>{C15274DE-2695-4DFE-8520-4424223FE6DA}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>JsonParser</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </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 />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="jsmn.h" />
+    <ClInclude Include="JsonArray.h" />
+    <ClInclude Include="JsonArrayIterator.h" />
+    <ClInclude Include="JsonObject.h" />
+    <ClInclude Include="JsonObjectIterator.h" />
+    <ClInclude Include="JsonPair.h" />
+    <ClInclude Include="JsonParser.h" />
+    <ClInclude Include="JsonParserBase.h" />
+    <ClInclude Include="JsonToken.h" />
+    <ClInclude Include="JsonValue.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="jsmn.cpp" />
+    <ClCompile Include="JsonArray.cpp" />
+    <ClCompile Include="JsonObject.cpp" />
+    <ClCompile Include="JsonParserBase.cpp" />
+    <ClCompile Include="JsonToken.cpp" />
+    <ClCompile Include="JsonValue.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

JsonParser/JsonParser.vcxproj.filters

@@ -0,0 +1,69 @@
+<?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>
+    <ClInclude Include="JsonParserBase.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonToken.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonValue.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonParser.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="jsmn.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonArray.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonArrayIterator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonObject.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonObjectIterator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonPair.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="jsmn.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonArray.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonObject.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonParserBase.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonToken.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonValue.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

JsonParser/JsonParserBase.cpp

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

JsonParser/JsonParserBase.h

@@ -0,0 +1,49 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "JsonArray.h"
+#include "JsonObject.h"
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        // Base class for the JSON parser, in case you want to provide your own buffer
+        class JsonParserBase
+        {
+        public:
+
+            // Create a JSON parser using the provided buffer
+            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            
+            JsonValue parse(char* json);
+
+            // Obsolete: use parse() instead
+            DEPRECATED JsonArray parseArray(char* json)
+            {
+                return parse(json);
+            }
+
+            // Obsolete: use parse() instead
+            DEPRECATED JsonObject parseHashTable(char* json)
+            {
+                return parse(json);
+            }
+
+        private:
+            jsmntok_t* tokens;
+            int maxTokens;
+        };
+    }
+}

JsonParser/JsonToken.cpp

@@ -0,0 +1,71 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonToken.h"
+
+using namespace ArduinoJson::Parser;
+
+char* JsonToken::getText()
+{
+    char* s = json + token->start;
+    json[token->end] = 0;
+
+    unescapeString(s);
+
+    return s;
+}
+
+inline void JsonToken::unescapeString(char* s)
+{
+    char* readPtr = s;
+    char* writePtr = s;
+    char c;
+
+    do
+    {
+        c = *readPtr++;
+
+        if (c == '\\')
+        {
+            c = unescapeChar(*readPtr++);
+        }
+
+        *writePtr++ = c;
+
+    } while (c != 0);
+}
+
+inline char JsonToken::unescapeChar(char c)
+{
+    // Optimized for code size on a 8-bit AVR
+
+    const char* p = "b\bf\fn\nr\rt\t";
+
+    while (true)
+    {
+        if (p[0] == 0) return c;
+        if (p[0] == c) return p[1];
+        p += 2;
+    }
+}
+
+JsonToken JsonToken::nextSibling() const
+{
+    // start with current token
+    jsmntok_t* t = token;
+
+    // count the number of token to skip
+    int yetToVisit = 1;
+    
+    // skip all nested tokens
+    while (yetToVisit)
+    {
+        yetToVisit += t->size - 1;
+        t++;
+    }
+
+    // build a JsonToken at the new location
+    return JsonToken(json, t);
+}

JsonParser/JsonToken.h

@@ -0,0 +1,99 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#pragma once
+
+#include "jsmn.h"
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        // A pointer to a JSON token
+        class JsonToken
+        {
+        public:
+
+            // Create a "null" pointer
+            JsonToken()
+                : token(0)
+            {
+            }
+
+            // Create a pointer to the specified JSON token
+            JsonToken(char* json, jsmntok_t* token)
+                : json(json), token(token)
+            {
+            }
+
+            // Get content of the JSON token
+            char* getText();
+
+            // Get the number of children tokens
+            int childrenCount()
+            {
+                return token->size;
+            }
+
+            // Get a pointer to the first child of the current token
+            JsonToken firstChild() const
+            {
+                return JsonToken(json, token + 1);
+            }
+
+            // Get a pointer to the next sibling token (ie skiping the children tokens)
+            JsonToken nextSibling() const;
+
+            // Test equality
+            bool operator!=(const JsonToken& other) const
+            {
+                return token != other.token;
+            }
+
+            // Tell if the pointer is "null"
+            bool isValid()
+            {
+                return token != 0;
+            }
+
+            // Tell if the JSON token is a JSON object
+            bool isObject()
+            {
+                return token != 0 && token->type == JSMN_OBJECT;
+            }
+
+            // Tell if the JSON token is a JSON array
+            bool isArray()
+            {
+                return token != 0 && token->type == JSMN_ARRAY;
+            }
+
+            // Tell if the JSON token is a primitive
+            bool isPrimitive()
+            {
+                return token != 0 && token->type == JSMN_PRIMITIVE;
+            }
+
+            // Tell if the JSON token is a string
+            bool isString()
+            {
+                return token != 0 && token->type == JSMN_STRING;
+            }
+
+            // Explicit wait to create a "null" JsonToken
+            static JsonToken null()
+            {
+                return JsonToken();
+            }
+
+        private:
+            char* json;
+            jsmntok_t* token;
+            
+            static char unescapeChar(char c);
+            static void unescapeString(char* s);
+        };
+    }
+}

JsonParser/JsonValue.cpp

@@ -0,0 +1,110 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#include <stdlib.h> // for strtol, strtod
+#include <string.h> // for strcmp()
+#include "JsonArray.h"
+#include "JsonObject.h"
+#include "JsonValue.h"
+
+using namespace ArduinoJson::Parser;
+
+// Convert the JsonValue to a bool.
+// Returns false if the JsonValue is not a primitve.
+JsonValue::operator bool()
+{
+    if (!isPrimitive()) return 0;
+
+    char *text = getText();
+
+    // "true"
+    if (text[0] == 't') return true;
+
+    // "false"
+    if (text[0] == 'f') return false;
+
+    // "null"
+    if (text[0] == 'n') return false;
+
+    // number
+    return strtol(text, 0, 0) != 0;
+}
+
+// Convert the JsonValue to a floating point value.
+// Returns false if the JsonValue is not a number.
+JsonValue::operator double()
+{
+    return isPrimitive() ? strtod(getText(), 0) : 0;
+}
+
+// Convert the JsonValue to a floating point value.
+// Returns false if the JsonValue is not a number.
+JsonValue::operator long()
+{
+    return isPrimitive() ? strtol(getText(), 0, 0) : 0;
+}
+
+// Convert the JsonValue to a string.
+// Returns 0 if the JsonValue is not a string.
+JsonValue::operator char*()
+{
+    return isString() || isPrimitive() ? getText() : 0;
+}
+
+// Get the nested value at the specified index.            
+// Returns an invalid JsonValue if the current value is not an array.
+JsonValue JsonValue::operator[](int index)
+{
+    // sanity check
+    if (index < 0 || !isArray() || index >= childrenCount())
+        return null();
+
+    // skip first token, it's the whole object
+    JsonToken runningToken = firstChild();
+
+    // skip all tokens before the specified index
+    for (int i = 0; i < index; i++)
+    {
+        // move forward: current + nested tokens
+        runningToken = runningToken.nextSibling();
+    }
+
+    return runningToken;
+}
+
+// Get the nested value matching the specified index.            
+// Returns an invalid JsonValue if the current value is not an object.
+JsonValue JsonValue::operator[](const char* desiredKey)
+{
+    // sanity check
+    if (desiredKey == 0 || !isObject())
+        return null();
+
+    // skip first token, it's the whole object
+    JsonToken runningToken = firstChild();
+
+    // scan each keys
+    for (int i = 0; i < childrenCount() / 2; i++)
+    {
+        // get 'key' token string
+        char* key = runningToken.getText();
+
+        // move to the 'value' token
+        runningToken = runningToken.nextSibling();
+
+        // compare with desired name
+        if (strcmp(desiredKey, key) == 0)
+        {
+            // return the value token that follows the key token
+            return runningToken;
+        }
+
+        // skip nested tokens
+        runningToken = runningToken.nextSibling();
+    }
+
+    // nothing found, return NULL
+    return null();
+}

JsonParser/JsonValue.h

@@ -0,0 +1,72 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#pragma once
+
+#include "JsonToken.h"
+
+#ifndef ARDUINO_JSON_NO_DEPRECATION_WARNING
+#ifdef __GNUC__
+#define DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#endif
+#else
+#define DEPRECATED
+#endif
+
+namespace ArduinoJson
+{
+    namespace Parser
+    {
+        // A JSON value
+        // Can be converted to string, double, bool, array or object.
+        class JsonValue : protected JsonToken
+        {
+        public:
+
+            // Create a invalid value
+            JsonValue()
+            {
+            }
+
+            // Convert a JsonToken to a JsonValue
+            JsonValue(JsonToken token)
+                : JsonToken(token)
+            {
+            }
+
+            // Tell is the JsonValue is valid
+            bool success()
+            {
+                return isValid();
+            }
+
+            // Convert the JsonValue to a bool.
+            // Returns false if the JsonValue is not a primitve.
+            operator bool();
+
+            // Convert the JsonValue to a floating point value.
+            // Returns false if the JsonValue is not a number.
+            operator double();
+
+            // Convert the JsonValue to a long integer.
+            // Returns 0 if the JsonValue is not a number.
+            operator long();
+
+            // Convert the JsonValue to a string.
+            // Returns 0 if the JsonValue is not a string.
+            operator char*();            
+            
+            // Get the nested value at the specified index.            
+            // Returns an invalid JsonValue if the current value is not an array.
+            JsonValue operator[](int index);
+
+            // Get the nested value matching the specified index.            
+            // Returns an invalid JsonValue if the current value is not an object.
+            JsonValue operator[](const char* key);
+        };
+    }
+}

JsonParser/README.md

@@ -0,0 +1,250 @@
+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
+-------
+
+	JsonParser<32> parser;
+    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";   
+
+    JsonObject root = parser.parse(json);
+
+    char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
+
+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;
+
+> ##### Having a namespace conflict?
+> To be able to use both `ArduinoJson::Generator` and `ArduinoJson::Parser` in the same file, you need to do one of the followings:
+> 
+> * Put the `using` statements into different functions
+> * `using namespace ArduinoJson`, then prefix the type names by `Generator::` or `Parser::`
+> * Create aliases for the namespaces or the types (C++11 only)
+    
+### 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 object 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 an object (like `{"key":"value"}`) or an array (like `[1,2]`). 
+
+The nested objects can be either arrays, booleans, objects, numbers or strings.
+If you need other type, you can get the string value and parse it yourself.
+
+#### Object
+
+Consider we have a `char json[]` containing to the following JSON string:
+
+    {
+        "sensor":"gps",
+		"time":1351824120,
+		"data":[48.756080,2.302038]
+    }
+
+In this case the string contains a JSON object, so you need to extract a `JsonObject`:
+   
+    JsonObject root = parser.parse(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*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
+You can also iterate through the key-value pairs of the object:
+
+    for (JsonObjectIterator i=root.begin(); i!=root.end(); ++i)
+    {
+      Serial.println(i.key());
+      Serial.println((char*)i.value());
+    }
+    
+#### 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.parse(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:
+    
+    double a = root[0][0];
+	double b = root[0][1];
+	double c = root[1][0];
+	double d = root[1][1];
+
+You can also iterate through the key-value pairs of the object:
+
+    for (JsonArrayIterator i=array.begin(); i!=array.end(); ++i)
+    {
+      Serial.println((char*)*i);
+    }
+	
+Common pitfalls
+---------------
+
+### 1. Not enough tokens
+
+By design, the library has no way to tell you why `JsonParser::parse()` 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, `JsonValue`, `JsonArray` and `JsonObject` 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::parse()`, 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.
+
+| Type         | Size in bytes |
+| ------------ | ------------- |
+| `Parser<N>`  | 4 + 8 x N     |
+| `JsonArray`  | 4             |
+| `JsonObject` | 4             |
+| `JsonValue`  | 4             |
+
+Code size
+---------
+
+The sizes have been obtained with Arduino IDE 1.0.5 for a Duemilanove.
+
+### Minimum setup
+
+| Function                             | Size |
+| ------------------------------------ | ---- |
+| `jsmn_parse()`                       | 962  |
+| `JsonValue::operator[](char const*)` | 218  | 
+| `JsonParserBase::parse()`            | 116  | 
+| `JsonValue::operator[](int)`         | 108  |
+| `strcmp()`                           | 18   | 
+
+### Additional space for integers
+
+| Function                     | Size |
+| ---------------------------- | ---- |
+| `strtol()`                   | 606  |
+| `JsonValue::operator long()` | 94   |
+
+### Additional space for floating points
+
+| Function                         | Size  |
+| -------------------------------- | ----- |
+| `strtod()`                       | 1369  |
+| `JsonValue::operator double()`   | 82    |

JsonParserTests/GbathreeBug.cpp

@@ -0,0 +1,244 @@
+/*
+* 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/JsonArrayIteratorTests.cpp

@@ -0,0 +1,67 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "JsonParser.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Parser;
+
+namespace JsonParserTests
+{
+    TEST_CLASS(JsonArrayIteratorTests)
+    {
+    public:
+
+        TEST_METHOD(EmptyJson)
+        {
+            char json[] = "";
+            JsonParser<1> parser;
+
+            JsonArray a = parser.parse(json);
+
+            int loopCount = 0;
+
+            for (long i : a)
+            {
+                loopCount++;
+            }
+
+            Assert::AreEqual(0, loopCount);
+        }
+
+        TEST_METHOD(ThreeIntegers)
+        {
+            char json [] = "[1,2,3]";
+            long expected [] = {1, 2, 3};
+            JsonParser<4> parser;
+
+            JsonArray a = parser.parse(json);
+
+            int index = 0;
+
+            for (long i : a)
+            {
+                Assert::AreEqual(expected[index++], i);
+            }
+        }
+
+        TEST_METHOD(ThreeStrings)
+        {
+            char json[] = "[\"1\",\"2\",\"3\"]";
+            char* expected[] = {"1", "2", "3"};
+            JsonParser<4> parser;
+
+            JsonArray a = parser.parse(json);
+
+            int index = 0;
+
+            for (const char* i : a)
+            {
+                Assert::AreEqual(expected[index++], i);
+            }
+        }
+    };
+}

JsonParserTests/JsonArrayTests.cpp

@@ -0,0 +1,189 @@
+/*
+* 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(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/JsonObjectIteratorTests.cpp

@@ -0,0 +1,71 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "JsonParser.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Parser;
+
+namespace JsonParserTests
+{
+    TEST_CLASS(JsonObjectIteratorTests)
+    {
+    public:
+
+        TEST_METHOD(EmptyObject)
+        {
+            char json [] = "{}";
+            JsonParser<1> parser;
+
+            JsonHashTable a = parser.parse(json);
+
+            int loopCount = 0;
+
+            for (auto i : a)
+            {
+                loopCount++;
+            }
+
+            Assert::AreEqual(0, loopCount);
+        }
+
+        TEST_METHOD(EmptyJson)
+        {
+            char json[] = "";
+            JsonParser<1> parser;
+
+            JsonHashTable a = parser.parse(json);
+
+            int loopCount = 0;
+
+            for (auto i : a)
+            {
+                loopCount++;
+            }
+
+            Assert::AreEqual(0, loopCount);
+        }
+
+        TEST_METHOD(ThreeStrings)
+        {
+            char json[] = "{\"key1\":\"value1\",\"key2\":\"value2\",\"key3\":\"value3\"}";
+            char* expectedKeys[] = {"key1", "key2", "key3"};
+            char* expectedValues[] = {"value1", "value2", "value3"};
+            JsonParser<7> parser;
+
+            JsonHashTable a = parser.parse(json);
+
+            int index = 0;
+
+            for (auto i : a)
+            {
+                Assert::AreEqual(expectedKeys[index], i.key());
+                Assert::AreEqual(expectedValues[index], (const char*) i.value());
+                index++;
+            }
+        }
+    };
+}

JsonParserTests/JsonObjectTests.cpp

@@ -0,0 +1,165 @@
+/*
+* 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(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

@@ -0,0 +1,103 @@
+<?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>ARDUINO_JSON_NO_DEPRECATION_WARNING;_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="JsonObjectIteratorTests.cpp" />
+    <ClCompile Include="JsonArrayTests.cpp" />
+    <ClCompile Include="JsonArrayIteratorTests.cpp" />
+    <ClCompile Include="JsonObjectTests.cpp" />
+    <ClCompile Include="GbathreeBug.cpp" />
+    <ClCompile Include="JsonStringTests.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\JsonParser\JsonParser.vcxproj">
+      <Project>{c15274de-2695-4dfe-8520-4424223fe6da}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

JsonParserTests/JsonParserTests.vcxproj.filters

@@ -0,0 +1,37 @@
+<?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="GbathreeBug.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonObjectTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonArrayIteratorTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonObjectIteratorTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonArrayTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonStringTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

JsonParserTests/JsonStringTests.cpp

@@ -0,0 +1,107 @@
+/*
+* 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(JsonStringTests)
+    {
+        const char* actual;
+        char json[256];
+        JsonParser<32> parser;
+
+    public:
+
+        TEST_METHOD(EmptyString)
+        {
+            whenInputIs("");
+            outputMustBe(0);
+        }
+
+        TEST_METHOD(JustOneQuote)
+        {
+            whenInputIs("\"");
+            outputMustBe(0);
+        }
+
+        TEST_METHOD(SimpleString)
+        {
+            whenInputIs("\"Hi!\"");
+            outputMustBe("Hi!");
+        }
+
+        TEST_METHOD(EscapedQuote)
+        {
+            whenInputIs("\"12\\\"34\"");  // ie 12\"34
+            outputMustBe("12\"34");
+        }
+
+        TEST_METHOD(EscapedReverseSolidus)
+        {
+            whenInputIs("\"12\\\\34\""); // ie 12\\34
+            outputMustBe("12\\34");
+        }
+
+        TEST_METHOD(EscapedSolidus)
+        {
+            whenInputIs("\"12\\/34\"");
+            outputMustBe("12/34");
+        }
+
+        TEST_METHOD(EscapedBackspace)
+        {
+            whenInputIs("\"12\\b34\"");
+            outputMustBe("12\b34");
+        }
+
+        TEST_METHOD(EscapedFormfeed)
+        {
+            whenInputIs("\"12\\f34\"");
+            outputMustBe("12\f34");
+        }
+        
+        TEST_METHOD(EscapedNewline)
+        {
+            whenInputIs("\"12\\n34\""); 
+            outputMustBe("12\n34");
+        }
+
+        TEST_METHOD(EscapedCarriageReturn)
+        {
+            whenInputIs("\"12\\r34\"");
+            outputMustBe("12\r34");
+        }
+
+        TEST_METHOD(EscapedTab)
+        {
+            whenInputIs("\"12\\t34\"");
+            outputMustBe("12\t34");
+        }
+
+        TEST_METHOD(AllEscapedCharsTogether)
+        {
+            whenInputIs("\"1\\\"2\\\\3\\/4\\b5\\f6\\n7\\r8\\t9\"");
+            outputMustBe("1\"2\\3/4\b5\f6\n7\r8\t9");
+        }
+
+    private:       
+
+        void whenInputIs(const char* input)
+        {
+            strcpy(json, input);
+            actual = parser.parse(json);
+        }
+
+        void outputMustBe(const char* expected)
+        {
+            Assert::AreEqual(expected, actual);
+        }
+    };
+}

JsonParserTests/TestHashGenerator.cpp

@@ -0,0 +1,25 @@
+#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,409 +1,58 @@
-An efficient JSON parser for Arduino
-====================================
+Arduino JSON library
+====================
 
-This library is an thin C++ wrapper around the *jsmn* tokenizer: http://zserge.com/jsmn.html
+*An elegant and efficient JSON library 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 on any other C++ project.
+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
 --------
 
-* Based on the well-proven [jsmn](http://zserge.com/jsmn.html) tokenizer
-* Supports nested objects
-* Works with fixed memory allocation : no `malloc()`
-* Low footprint
+* JSON decoding: [see documentation here](/JsonParser/)
+* JSON encoding: [see documentation here](/JsonGenerator/)
+* Elegant API, very easy to use 
+* Fixed memory allocation (no malloc)
+* Small footprint
 * MIT License
 
+Feature comparison
+------------------
 
-Example
--------
+| Library      | Memory allocation | Nested objects | Parser size | Encoder size  |
+| ------------ | ----------------- | -------------- | ----------- | ------------- |
+| Arduino JSON | static            | yes            | 2760 Bytes  | 862 bytes     |
+| json-arduino | dynamic           | no             | 3348 (+21%) | not supported |
+| aJson        | dynamic           | yes            | 5088 (+84%) | 4678 (+540%)  |
 
-    char* json = "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}";
+"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).
 
-    JsonParser<32> parser;
+"Encoder size" was measured with a program generating `{"sensor":"outdoor","value":25.6}`.
+[Source files are here](https://gist.github.com/bblanchon/60224e9dcfeab4ddc7e9).
 
-    JsonHashTable hashTable = parser.parseHashTable(json);
+In each case the target platform was an Arduino Duemilanove and Arduino IDE 1.0.5 was used. 
 
-    if (!hashTable.success())
-    {
-        return;
-    }
+Links: [json-arduino](https://github.com/not404/json-arduino), [aJson](https://github.com/interactive-matter/aJson) 
 
-    char* name = hashTable.getString("Name");
-
-    JsonArray skills = hashTable.getArray("Skills");
-
-    int age = hashTable.getLong("Age");
-
-    bool online = hashTable.getBool("Online");
-
-
-
-How to  use ?
--------------
-
-### 1. Install the library
-
-Download the library and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJsonParser
-
-### 2. Import in your sketch
-
-Just add the following line on the top of your `.ino` file:
-
-    #include <JsonParser.h>
-    
-### 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` pointing 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` pointing 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
+Testimonials
 ------------
 
-Here are the size of the main classes of the library.
+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 have no such problem so far with your library. It is working perfectly with my web services.
 
-This table is for an 8-bit Arduino, types would be bigger on a 32-bit processor.
+From Arduino's Forum user `gbathree`:
+> Thanks so much - this is an awesome library!  If you want to see what we're doing with it - the project is located at www.photosynq.org.
 
-<table>
-    <tr>
-        <th>Type</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>Parser&lt;N&gt;</td>
-        <td>8 x N</td>
-    </tr>
-    <tr>
-        <td>JsonArray</td>
-        <td>4</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable</td>
-        <td>4</td>
-    </tr>
-</table> 
+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.
 
+Related blog posts
+-----
 
-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 if 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>
+* [The project I originally wrote this library for](http://blog.benoitblanchon.fr/rfid-payment-terminal/)
+* [Motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
+* [Release of version 2](http://blog.benoitblanchon.fr/arduino-json-v2-0/)
+* [Release of version 3](http://blog.benoitblanchon.fr/arduino-json-v3-0/)

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -0,0 +1,43 @@
+/*
+ * Arduino JSON library - IndentedPrint example
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#include <JsonGenerator.h>
+
+using namespace ArduinoJson::Generator;
+
+void setup()
+{
+    Serial.begin(9600);
+    
+    JsonObject<1> json;
+    json["key"] = "value";
+    
+    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.println("You can print JSON here, as usual:");
+    serial.println(json);
+    serial.println();
+        
+    serial.println("But you can also prettyPrint JSON here:");
+    json.prettyPrintTo(serial);  
+    serial.println();
+    
+    serial.unindent();
+    serial.unindent();
+    serial.println("This is back at indentation 0");
+}
+
+void loop()
+{
+
+}

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -0,0 +1,32 @@
+/*
+ * Arduino JSON library - Generator example
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#include <JsonGenerator.h>
+
+using namespace ArduinoJson::Generator;
+
+void setup()
+{
+    Serial.begin(9600);
+
+    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<3> root; 
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+    root["data"] = array;
+
+    Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+    Serial.println();
+    root.prettyPrintTo(Serial); // same string indented
+}
+
+void loop()
+{
+
+}

examples/JsonParserExample/JsonParserExample.ino

@@ -1,94 +1,40 @@
 /*
-* malloc-free JSON parser for Arduino
+* Arduino JSON library - Parser Example
 * Benoit Blanchon 2014 - MIT License
 */
 
 #include <JsonParser.h>
 
-void ParseAnObject()
-{
-    char* json = "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}";
-
-    JsonParser<32> parser;
-
-    Serial.print("Parse ");
-    Serial.println(json);
-
-    JsonHashTable hashTable = parser.parseHashTable(json);
-
-    if (!hashTable.success())
-    {
-        Serial.println("JsonParser.parseHashTable() failed");
-        return;
-    }
-
-    char* name = hashTable.getString("Name");
-    Serial.print("name=");
-    Serial.println(name);
-
-    JsonArray skills = hashTable.getArray("Skills");
-    Serial.println("skills:");
-    for (int i = 0; i < skills.getLength(); i++)
-    {
-        char* value = skills.getString(i);
-        Serial.print(i);
-        Serial.print(" ");
-        Serial.println(value);
-    }
-
-    int age = hashTable.getLong("Age");
-    Serial.print("age=");
-    Serial.println(age);
-
-    bool online = hashTable.getBool("Online");
-    Serial.print("online=");
-    Serial.println(online);
-}
-
-void ParseAnArray()
-{
-    char* json = "[[1.2,3.4],[5.6,7.8]]";
-
-    JsonParser<32> parser;
-
-    Serial.print("Parse ");
-    Serial.println(json);
-
-    JsonArray array = parser.parseArray(json);
-
-    if (!array.success())
-    {
-        Serial.println("JsonParser.parseArray() failed");
-        return;
-    }
-
-    for (int i = 0; i < array.getLength(); i++)
-    {
-        Serial.println(i);
-
-        JsonArray innerArray = array.getArray(i);
-
-        for (int j = 0; j < innerArray.getLength(); j++)
-        {
-            double value = innerArray.getDouble(j);
-
-            Serial.print("  ");
-            Serial.print(j);
-            Serial.print("=");
-            Serial.println(value);
-        }
-    }
-}
+using namespace ArduinoJson::Parser;
 
 void setup()
 {
     Serial.begin(9600);
 
-    ParseAnObject();
-    ParseAnArray();
+    char json [] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+
+    JsonParser<16> parser;
+
+    JsonObject root = parser.parse(json);
+
+    if (!root.success())
+    {
+        Serial.println("JsonParser.parse() failed");
+        return;
+    }
+
+    char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
+    Serial.println(sensor);
+    Serial.println(time);
+    Serial.println(latitude, 6);
+    Serial.println(longitude, 6);
 }
 
 void loop()
 {
 
-}
+}

keywords.txt

@@ -1,10 +1,6 @@
 JsonParser	KEYWORD1
 JsonArray	KEYWORD1
-JsonHashTable	KEYWORD1
-getArray	KEYWORD2
-getBool	KEYWORD2
-getDouble	KEYWORD2
-getHashTableKEYWORD2
-getLong	KEYWORD2
-parseArray	KEYWORD2
-parseHashTable	KEYWORD2
+JsonObject	KEYWORD1
+add	KEYWORD2
+parse	KEYWORD2
+success	KEYWORD2