Updated README.md

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

CHANGELOG.md

@@ -1,10 +1,56 @@
-ArduinoJsonParser change log
+Arduino JSON: change log
-============================
+========================
+
+v3.0
+----
+
+* New parser API, see bellow
+* Renamed `JsonHashTable` into `JsonObject`
+* Added iterators for `JsonArray` and `JsonObject`
+
+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 byes are not write protected
+* 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 

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 || 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,12 @@
+/*
+* malloc-free JSON parser for Arduino
+* Benoit Blanchon 2014 - MIT License
+*/
+
+// This file is here to help the Arduino IDE find the .cpp files
+
+#include "JsonGenerator/EscapedString.cpp"
+#include "JsonGenerator/JsonArrayBase.cpp"
+#include "JsonGenerator/JsonObjectBase.cpp"
+#include "JsonGenerator/JsonValue.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,47 @@
+/*
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#include "EscapedString.h"
+
+using namespace ArduinoJson::Internals;
+
+static inline char getSpecialChar(char c)
+{
+    // Optimized for code size on a 8-bit AVR
+
+    const char* p = "\"\"\\\\\bb\ff\nn\rr\tt\0";
+
+    while (p[0] && p[0] != c)
+    {
+        p += 2;
+    }
+
+    return p[1];
+}
+
+static inline size_t printCharTo(char c, Print& p)
+{
+    char specialChar = getSpecialChar(c);
+
+    return specialChar != 0
+        ? p.write('\\') + p.write(specialChar)
+        : p.write(c);
+}
+
+size_t EscapedString::printTo(Print& p) const
+{
+    const char* s = rawString;
+
+    if (!s) return p.print("null");
+    
+    size_t n = p.write('\"');
+
+    while (*s)
+    {
+        n += printCharTo(*s++, p);
+    }
+
+    return n + p.write('\"');
+}

JsonGenerator/EscapedString.h

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

JsonGenerator/JsonArray.h

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

JsonGenerator/JsonGenerator.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>
+  <ItemGroup>
+    <ClInclude Include="EscapedString.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="JsonArrayBase.cpp" />
+    <ClCompile Include="JsonObjectBase.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,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="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>
+  </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>
+  </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,36 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonObjectBase.h"
+
+using namespace ArduinoJson::Generator;
+
+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 += current->key.printTo(p);
+        n += p.write(':');
+        n += current->value.printTo(p);
+
+        current++;
+
+        if (i > 1)
+        {
+            n += p.write(',');
+        }
+    }
+
+    n += p.write('}');
+
+    return n;
+}

JsonGenerator/JsonObjectBase.h

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

JsonGenerator/JsonPrintable.h

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

JsonGenerator/JsonValue.cpp

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

JsonGenerator/JsonValue.h

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

JsonGenerator/Print.cpp

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

JsonGenerator/Print.h

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

JsonGenerator/Printable.h

@@ -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,202 @@
+Arduino JSON library - Generator
+================================
+
+This library is a simple JSON encoder for embedded systems.
+
+It's design to be very lightweight, works without any allocation on the heap (no malloc) and supports nested objects.
+
+It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
+
+
+Features
+--------
+
+* Supports nested objects
+* Elegant API, very easy to use 
+* Fixed memory allocation (no malloc)
+* Small footprint
+* Implements Arduino's `Printable interface
+* MIT License
+
+
+Example
+-------
+
+    JsonArray<2> array;
+    array.add<6>(48.756080);
+    array.add<6>(2.302038);
+
+    JsonObject<3> root;
+    root.add("sensor", "gps");
+    root.add("time", 1351824120);
+    root.add("data", array);
+
+    Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+
+How to  use?
+------------
+
+### 1. Install the library
+
+Download the library and extract it to:
+
+    <your Arduino Sketch folder>/libraries/ArduinoJson
+
+### 2. Import in your sketch
+
+Just add the following lines at the top of your `.ino` file:
+
+    #include <JsonGenerator.h>
+
+    using namespace ArduinoJson::Generator;
+
+> ##### 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 the floating point values:
+
+	array.add<4>(3.1415);  // 4 digits: "3.1415" 
+    array.add(3.14);	   // 2 digits: "3.14"
+
+> ##### About floating point precision
+> The overload of `add()` with 2 parameters allows you to specify the number of decimals to save in the JSON string. 
+> When you use the overload with one parameter, you use the default number of decimals which is two.
+> Note that this behavior is the exact same as Arduino's `Print::print(double,int);` which is implemented by `Serial`. 
+> So you may already be familiar with it. 
+
+Finally you can add nested object to the array:
+
+    JsonArray<8> nestedArray;
+    array.add(nestedArray);
+
+or
+
+    JsonObject<8> nestedObject;
+    array.add(nestedObject);
+
+#### 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.add("key1", "bazinga!");
+    object.add("key2", 42);
+    object.add("key3", true);
+
+As for the arrays, there are two syntaxes for the floating point values:
+
+	array.add<4>("key4", 3.1415);  // 4 digits: "3.1415" 
+    array.add("key5", 3.14);	   // 2 digits: "3.14"
+
+Finally you can add nested objects:
+
+    JsonArray<8> nestedArray;
+    object.add("key6", nestedArray);
+
+or
+
+    JsonObject<8> nestedObject;
+    object.add("key7", nestedObject);
+
+### 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));
+
+#### 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`...
+   
+
+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
+---------
+
+### Minimum setup
+
+| Function                     | Size |
+| ---------------------------- | ---- |
+| `JsonObjectBase::printTo()`  | 222  |
+| `EscapedString::printTo()`   | 202  |
+| `JsonArrayBase::printTo()`   | 164  |
+| `Print::print(char const*)`  | 146  |
+| `JsonValue::printStringTo()` | 6    |
+
+### 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,97 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "CppUnitTest.h"
+#include "EscapedString.h"
+#include "StringBuilder.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Internals;
+
+namespace JsonGeneratorTests
+{
+    TEST_CLASS(EscapedStringTests)
+    {
+        char buffer[1024];
+        size_t returnValue;
+        EscapedString escapedString;
+
+    public:
+
+        TEST_METHOD(Null)
+        {
+            whenInputIs(0);
+            outputMustBe("null");
+        }
+
+        TEST_METHOD(EmptyString)
+        {
+            whenInputIs("");
+            outputMustBe("\"\"");
+        }
+
+        TEST_METHOD(QuotationMark)
+        {
+            whenInputIs("\"");
+            outputMustBe("\"\\\"\"");
+        }
+
+        TEST_METHOD(ReverseSolidus)
+        {
+            whenInputIs("\\");
+            outputMustBe("\"\\\\\"");
+        }
+
+        TEST_METHOD(Solidus)
+        {
+            whenInputIs("/");
+            outputMustBe("\"/\""); // but the JSON format allows \/
+        }
+
+        TEST_METHOD(Backspace)
+        {
+            whenInputIs("\b");
+            outputMustBe("\"\\b\"");
+        }
+
+        TEST_METHOD(Formfeed)
+        {
+            whenInputIs("\f");
+            outputMustBe("\"\\f\"");
+        }
+
+        TEST_METHOD(Newline)
+        {
+            whenInputIs("\n");
+            outputMustBe("\"\\n\"");
+        }
+
+        TEST_METHOD(CarriageReturn)
+        {
+            whenInputIs("\r");
+            outputMustBe("\"\\r\"");
+        }
+
+        TEST_METHOD(HorizontalTab)
+        {
+            whenInputIs("\t");
+            outputMustBe("\"\\t\"");
+        }
+
+    private:
+        void whenInputIs(const char* input)
+        {
+            StringBuilder sb(buffer, sizeof(buffer));            
+            escapedString.set(input);
+            returnValue = escapedString.printTo(sb);
+        }
+
+        void outputMustBe(const char* expected)
+        {
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), returnValue);
+        }
+    };
+}

JsonGeneratorTests/JsonArrayTests.cpp

@@ -0,0 +1,173 @@
+/*
+* 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> arr;
+        char buffer[256];
+
+    public:
+        
+        TEST_METHOD(Empty)
+        {
+            outputMustBe("[]");
+        }
+
+        TEST_METHOD(Null)
+        {
+            add((char*)0);
+
+            outputMustBe("[null]");
+        }
+
+        TEST_METHOD(OneString)
+        {
+            add("hello");
+
+            outputMustBe("[\"hello\"]");
+        }
+
+        TEST_METHOD(TwoStrings)
+        {
+            add("hello");
+            add("world");
+
+            outputMustBe("[\"hello\",\"world\"]");
+        }
+
+        TEST_METHOD(OneStringOverCapacity)
+        {
+            add("hello");
+            add("world");
+            add("lost");
+
+            outputMustBe("[\"hello\",\"world\"]");
+        }
+
+        TEST_METHOD(OneDoubleDefaultDigits)
+        {
+            add(3.14159265358979323846);
+            outputMustBe("[3.14]");
+        }
+
+        TEST_METHOD(OneDoubleFourDigits)
+        {
+            add<4>(3.14159265358979323846);
+            outputMustBe("[3.1416]");
+        }
+
+        TEST_METHOD(OneInteger)
+        {
+            add(1);
+
+            outputMustBe("[1]");
+        }
+
+        TEST_METHOD(TwoIntegers)
+        {
+            add(1);
+            add(2);
+
+            outputMustBe("[1,2]");
+        }
+
+        TEST_METHOD(OneIntegerOverCapacity)
+        {
+            add(1);
+            add(2);
+            add(3);
+
+            outputMustBe("[1,2]");
+        }
+
+        TEST_METHOD(OneTrue)
+        {
+            add(true);
+
+            outputMustBe("[true]");
+        }
+
+        TEST_METHOD(OneFalse)
+        {
+            add(false);
+
+            outputMustBe("[false]");
+        }
+
+        TEST_METHOD(TwoBooleans)
+        {
+            add(false);
+            add(true);
+
+            outputMustBe("[false,true]");
+        }
+
+        TEST_METHOD(OneBooleanOverCapacity)
+        {
+            add(false);
+            add(true);
+            add(false);
+
+            outputMustBe("[false,true]");
+        }
+
+        TEST_METHOD(OneEmptyNestedArray)
+        {
+           addNested(JsonArray<1>());
+            outputMustBe("[[]]");
+        }
+
+        TEST_METHOD(OneEmptyNestedHash)
+        {
+            addNested(JsonHashTable<1>());
+            outputMustBe("[{}]");
+        }
+
+        TEST_METHOD(OneNestedArrayWithOneInteger)
+        {
+            JsonArray<1> nestedArray;
+            nestedArray.add(1);
+
+            addNested(nestedArray);
+
+            outputMustBe("[[1]]");
+        }
+
+    private:
+
+        void addNested(Printable& value)
+        {
+            arr.add<Printable&>(value);
+        }
+
+        template<typename T>
+        void add(T value)
+        {
+            arr.add(value);
+        }
+
+        template<int DIGITS>
+        void add(double value)
+        {
+            arr.add<DIGITS>(value);
+        }
+
+        void outputMustBe(const char* expected)
+        {      
+            size_t n = arr.printTo(buffer, sizeof(buffer));
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), n);
+        }
+    };
+}

JsonGeneratorTests/JsonGeneratorTests.vcxproj

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

JsonGeneratorTests/JsonHashTableTests.cpp

@@ -0,0 +1,124 @@
+/*
+* 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(JsonHashTableTests)
+    {
+        JsonHashTable<2> hash;
+        char buffer[256];
+
+    public:
+        
+        TEST_METHOD(Empty)
+        {
+            outputMustBe("{}");
+        }
+
+        TEST_METHOD(OneString)
+        {
+            add("key", "value");
+            outputMustBe("{\"key\":\"value\"}");
+        }
+
+        TEST_METHOD(TwoStrings)
+        {
+            add("key1", "value1");
+            add("key2", "value2");
+
+            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+        }
+
+        TEST_METHOD(OneStringOverCapacity)
+        {
+            add("key1", "value1");
+            add("key2", "value2");
+            add("key3", "value3");
+
+            outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+        }
+
+        TEST_METHOD(OneInteger)
+        {
+            add("key", 1);
+            outputMustBe("{\"key\":1}");
+        }
+
+        TEST_METHOD(OneDoubleFourDigits)
+        {
+            add<4>("key", 3.14159265358979323846);
+            outputMustBe("{\"key\":3.1416}");
+        }
+
+        TEST_METHOD(OneDoubleDefaultDigits)
+        {
+            add("key", 3.14159265358979323846);
+            outputMustBe("{\"key\":3.14}");
+        }
+
+        TEST_METHOD(OneNull)
+        {
+            add("key", (char*) 0);
+            outputMustBe("{\"key\":null}");
+        }
+
+        TEST_METHOD(OneTrue)
+        {
+            add("key", true);
+            outputMustBe("{\"key\":true}");
+        }
+
+        TEST_METHOD(OneFalse)
+        {
+            add("key", false);
+            outputMustBe("{\"key\":false}");
+        }
+
+        TEST_METHOD(OneEmptyNestedArray)
+        {
+            addNested("key", JsonArray<1>());
+            outputMustBe("{\"key\":[]}");
+        }
+
+        TEST_METHOD(OneEmptyNestedHash)
+        {
+            addNested("key", JsonHashTable<1>());
+            outputMustBe("{\"key\":{}}");
+        }
+
+    private:
+        
+        void addNested(const char* key, Printable& value)
+        {
+            hash.add<Printable&>(key, value);
+        }
+
+        template<typename T>
+        void add(const char* key, T value)
+        {
+            hash.add(key, value);
+        }
+
+        template<int DIGITS>
+        void add(const char* key, double value)
+        {
+            hash.add<DIGITS>(key, value);
+        }
+
+        void outputMustBe(const char* expected)
+        {            
+            size_t actual = hash.printTo(buffer, sizeof(buffer));
+            Assert::AreEqual(expected, buffer);
+            Assert::AreEqual(strlen(expected), actual);
+        }
+    };
+}

JsonGeneratorTests/JsonValueTests.cpp

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

JsonGeneratorTests/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 || 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,67 +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 end = token->end;
-	int count = 0;	
-
-	token++;
-
-	while (token->start < end)
-	{
-		token++;
-		count++;
-	}
-
-	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
+#include "JsonParser/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
-

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

@@ -15,45 +15,54 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="..\JsonArray.h">
+    <ClInclude Include="JsonParserBase.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\JsonHashTable.h">
+    <ClInclude Include="JsonToken.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\JsonObjectBase.h">
+    <ClInclude Include="JsonValue.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\JsonParser.h">
+    <ClInclude Include="JsonParser.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\utility\jsmn.h">
+    <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="..\JsonArray.cpp">
+    <ClCompile Include="jsmn.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\JsonHashTable.cpp">
+    <ClCompile Include="JsonArray.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\JsonObjectBase.cpp">
+    <ClCompile Include="JsonObject.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\utility\jsmn.cpp">
+    <ClCompile Include="JsonParserBase.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="TestHashTableExample.cpp">
+    <ClCompile Include="JsonToken.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="TestArrayExample.cpp">
+    <ClCompile Include="JsonValue.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="TestGbathreeStrings.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="TestArrays.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>

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,27 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonToken.h"
+
+using namespace ArduinoJson::Parser;
+
+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,100 @@
+/*
+* 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()
+            {
+                json[token->end] = 0;
+                return json + token->start;
+            }
+
+            // 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;
+        };
+    }
+}

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

@@ -1,13 +1,19 @@
+/*
+* 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(TestGbathreeSample1)
+	TEST_CLASS(GbathreeBug)
 	{
 		char json[1024];
 		JsonParser<200> parser;

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

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

JsonParserTests/JsonParserTests.vcxproj

@@ -14,6 +14,7 @@
     <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">
@@ -55,7 +56,7 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>ARDUINO_JSON_NO_DEPRECATION_WARNING;_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
     </ClCompile>
     <Link>
@@ -84,21 +85,16 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="..\JsonArray.h" />
+    <ClCompile Include="JsonObjectIteratorTests.cpp" />
-    <ClInclude Include="..\JsonHashTable.h" />
+    <ClCompile Include="JsonArrayTests.cpp" />
-    <ClInclude Include="..\JsonObjectBase.h" />
+    <ClCompile Include="JsonArrayIteratorTests.cpp" />
-    <ClInclude Include="..\JsonParser.h" />
+    <ClCompile Include="JsonObjectTests.cpp" />
-    <ClInclude Include="..\utility\jsmn.h" />
+    <ClCompile Include="GbathreeBug.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\JsonArray.cpp" />
+    <ProjectReference Include="..\JsonParser\JsonParser.vcxproj">
-    <ClCompile Include="..\JsonHashTable.cpp" />
+      <Project>{c15274de-2695-4dfe-8520-4424223fe6da}</Project>
-    <ClCompile Include="..\JsonObjectBase.cpp" />
+    </ProjectReference>
-    <ClCompile Include="..\utility\jsmn.cpp" />
-    <ClCompile Include="TestArrayExample.cpp" />
-    <ClCompile Include="TestArrays.cpp" />
-    <ClCompile Include="TestHashTableExample.cpp" />
-    <ClCompile Include="TestGbathreeStrings.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

JsonParserTests/JsonParserTests.vcxproj.filters

@@ -0,0 +1,34 @@
+<?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="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>
+  </ItemGroup>
+</Project>

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);
+		}
+
+	};
+}

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's design to be very lightweight, 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 on any other C++ project.
 
+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
+* JSON decoding: [more details here](/JsonParser/)
-* Supports nested objects
+* JSON encoding: [more details here](/JsonGenerator/)
-* Works with fixed memory allocation : no `malloc()`
+* Elegant API, very easy to use 
-* Low footprint
+* 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            | 2642 Bytes  | 628 bytes     |
+| json-arduino | dynamic           | no             | 3348 (+27%) | not supported |
+| aJson        | dynamic           | yes            | 5088 (+93%) | 4678 (+640%)  |
 
-    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())
+Links: [json-arduino](https://github.com/not404/json-arduino), [aJson](https://github.com/interactive-matter/aJson) 
-    {
-        return;
-    }
 
-    char* name = hashTable.getString("Name");
+Testimonials
-
-    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[]` containing to the following JSON string:
-
-    {
-        "Name":"Blanchon",
-        "Skills":[
-            "C",
-            "C++",
-            "C#"],
-        "Age":32,
-        "Online":true
-    }
-
-In this case the root object of the JSON string is a hash-table, so you need to extract a `JsonHashTable`:
-   
-    JsonHashTable root = parser.parseHashTable(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the member you need:
-    
-    char* name = hashTable.getString("Name");
-
-    JsonArray skills = hashTable.getArray("Skills");
-
-    int age = hashTable.getLong("Age");
-
-    bool online = hashTable.getBool("Online");
-    
-#### Array
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    [
-        [ 1.2, 3.4 ],
-        [ 5.6, 7.8 ]               
-    ]
-
-In this case the root object of the JSON string is an array, so you need to extract a `JsonArray`:
-   
-    JsonArray root = parser.parseArray(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the content by its index in the array:
-    
-    JsonArray row0 = root.getArray(0);
-    double a = row0.getDouble(0);
-    
-or simply:
-
-    double a = root.getArray(0).getDouble(0);
-
-
-Common pitfalls
----------------
-
-### 1. Not enough tokens
-
-By design, the library has no way to tell you why `JsonParser::parseArray()` or `JsonParser::parseHashTable()` failed.
-
-There are basically two reasons why they may fail:
-
-1. the JSON string is invalid
-2. the JSON string contains more tokens that the parser can store
-
-So, if you are sure the JSON string is correct and you still can't parse it, you should slightly increase the number of token of the parser.
-
-### 2. Not enough memory
-
-You may go into unpredictable trouble if you allocate more memory than your processor really has.
-It's a very common issue in embedded development. 
-
-To diagnose this, look at every big objects in you code and sum their size to check that they fit in RAM.
-
-For example, don't do this:
-
-    char json[1024];        // 1 KB
-    JsonParser<64> parser;    // 512 B
-
-because it may be too big for a processor with only 2 KB: you need free memory to store other variables and the call stack.
-
-That is why an 8-bit processor is not able to parse long and complex JSON strings.
-
-### 3. JsonParser not in memory
-
-To reduce the memory consumption, `JsonArray` and `JsonHashTable` contains pointer to the token that are inside the `JsonParser`. This can only work if the `JsonParser` is still in memory.
-
-For example, don't do this:
-
-    JsonArray getArray(char* json)
-    {
-        JsonParser<16> parser;
-        return parser.parseArray(parser); 
-    }
-
-because the local variable `parser` will be *removed* from memory when the function `getArray()` returns, and the pointer inside `JsonArray` will point to an invalid location.
-
-### 4. JSON string is altered
-
-This will probably never be an issue, but you need to be aware of this feature.
-
-When you pass a `char[]` to `JsonParser::parseArray()` or `JsonParser::parseHashTable()`, the content of the string will be altered to add `\0` at the end of the tokens.
-
-This is because we want functions like `JsonArray::getString()` to return a null-terminating string without any memory allocation.
-   
-
-Memory usage
 ------------
 
-Here are the size of the main classes of the library.
+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>
+From StackOverflow user `thegreendroid`:
-    <tr>
+> 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.
-        <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> 
 
+Related blog posts
+-----
 
-Code size
+* [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/)
-Theses tables has been created by analyzing the map file generated by AVR-GCC after adding `-Wl,-Map,foo.map` to the command line.
+* [Release of version 3](http://blog.benoitblanchon.fr/arduino-json-v3-0/)
-
-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>

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -0,0 +1,29 @@
+/*
+ * 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.add("sensor", "gps");
+    root.add("time", 1351824120);
+    root.add("data", array);
+
+    Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+}
+
+void loop()
+{
+
+}

examples/JsonParserExample/JsonParserExample.ino

@@ -1,91 +1,37 @@
 /*
-* malloc-free JSON parser for Arduino
+* Arduino JSON library - Parser Example
 * Benoit Blanchon 2014 - MIT License
 */
 
 #include <JsonParser.h>
 
-void ParseAnObject()
+using namespace ArduinoJson::Parser;
-{
-    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);
-        }
-    }
-}
 
 void setup()
 {
     Serial.begin(9600);
 
-    ParseAnObject();
+    char json [] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-    ParseAnArray();
+
+    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
+JsonObject	KEYWORD1
-getArray	KEYWORD2
+add	KEYWORD2
-getBool	KEYWORD2
+parse	KEYWORD2
-getDouble	KEYWORD2
+success	KEYWORD2
-getHashTableKEYWORD2
-getLong	KEYWORD2
-parseArray	KEYWORD2
-parseHashTable	KEYWORD2

tests/.gitignore

@@ -1,5 +0,0 @@
-/*.sdf
-/*.user
-/*.suo
-/Debug
-/ipch

tests/ArduinoJsonParserTests.sln

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

tests/TestArrayExample.cpp

@@ -1,50 +0,0 @@
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(TestArrayExample)
-	{
-		char json[128];
-		JsonParser<32> parser;
-		JsonArray array;
-
-	public:
-
-		TEST_METHOD_INITIALIZE(Initialize)
-		{
-			strcpy(json, "[[1.2,3.4],[5.6,7.8]]");
-			array = parser.parseArray(json);
-		}
-		
-		TEST_METHOD(Array_Success_ReturnsTrue)
-		{
-			Assert::IsTrue(array.success());
-		}
-
-		TEST_METHOD(Array_GetLength_Returns2)
-		{
-			Assert::AreEqual(2, array.getLength());
-		}
-
-		TEST_METHOD(Array_GetArray0_ReturnsInnerArray0)
-		{
-			JsonArray innerArray = array.getArray(0);
-
-			Assert::AreEqual(2, innerArray.getLength());
-			Assert::AreEqual(1.2, innerArray.getDouble(0));
-			Assert::AreEqual(3.4, innerArray.getDouble(1));
-		}
-
-		TEST_METHOD(Array_GetArray1_ReturnsInnerArray1)
-		{
-			JsonArray innerArray = array.getArray(1);
-
-			Assert::AreEqual(2, innerArray.getLength());
-			Assert::AreEqual(5.6, innerArray.getDouble(0));
-			Assert::AreEqual(7.8, innerArray.getDouble(1));
-		}
-	};
-}

tests/TestArrays.cpp

@@ -1,141 +0,0 @@
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace ArduinoJsonParserTests
-{
-	TEST_CLASS(TestArrays)
-	{
-		JsonParser<32> parser;
-
-	public:
-		
-		TEST_METHOD(EmptyString)
-		{
-			char json[] = "";
-
-			JsonArray array = parser.parseArray(json);
-			Assert::IsFalse(array.success());
-		}
-
-		TEST_METHOD(EmptyArray)
-		{
-			char json[] = "[]";
-
-			JsonArray array = parser.parseArray(json);
-			Assert::IsTrue(array.success());
-		}
-
-		TEST_METHOD(TooFewClosingBrackets)
-		{
-			char json[] = "[[]";
-
-			JsonArray array = parser.parseArray(json);
-			Assert::IsFalse(array.success());
-		}
-
-		TEST_METHOD(TooManyClosingBrackets)
-		{
-			char json[] = "[]]";
-
-			JsonArray array = parser.parseArray(json);
-			Assert::IsFalse(array.success());
-		}
-		
-		TEST_METHOD(OneDimensionArray)
-		{
-			char json [] = "[0,0]";
-
-			JsonArray array = parser.parseArray(json);
-			Assert::IsTrue(array.success());
-			Assert::AreEqual(2, array.getLength());
-
-			for (int i = 0; i < 2; i++)
-			{
-				Assert::AreEqual(0L, array.getLong(i));
-			}
-		}
-
-		TEST_METHOD(TwoDimensionsArray)
-		{
-			char json[] = "[[0,0],[0,0]]";
-
-			JsonArray array1 = parser.parseArray(json);
-			Assert::IsTrue(array1.success());
-			Assert::AreEqual(2, array1.getLength());
-
-			for (int i = 0; i < 2; i++)
-			{
-				JsonArray array2 = array1.getArray(i);
-
-				Assert::AreEqual(2, array2.getLength());
-
-				for (int j = 0; j < 2; j++)
-				{
-					Assert::AreEqual(0L, array2.getLong(j));
-				}
-			}
-		}
-
-		TEST_METHOD(TreeDimensionsArray)
-		{
-			char json[] = "[[[0,0],[0,0]],[[0,0],[0,0]]]";
-
-			JsonArray array1 = parser.parseArray(json);
-			Assert::IsTrue(array1.success());
-			Assert::AreEqual(2, array1.getLength());
-
-			for (int i = 0; i < 2; i++)
-			{
-				JsonArray array2 = array1.getArray(i);
-
-				Assert::AreEqual(2, array2.getLength());
-
-				for (int j = 0; j < 2; j++)
-				{
-					JsonArray array3 = array2.getArray(j);
-
-					Assert::AreEqual(2, array3.getLength());
-
-					for (int k = 0; k < 2; k++)
-					{
-						Assert::AreEqual(0L, array3.getLong(k));
-					}
-				}
-			}
-		}
-
-		TEST_METHOD(OneDimensionArrayInHashTable)
-		{
-			char json[] = "{a:[0,0],b:[0,0]}";
-
-			JsonHashTable root = parser.parseHashTable(json);
-			Assert::IsTrue(root.success());
-
-			JsonArray arrayA = root.getArray("a");
-			Assert::IsTrue(arrayA.success());
-			Assert::AreEqual(2, arrayA.getLength());
-
-			JsonArray arrayB = root.getArray("b");
-			Assert::IsTrue(arrayB.success());
-			Assert::AreEqual(2, arrayB.getLength());
-		}
-
-		TEST_METHOD(TwoDimensionsArrayInHashTable)
-		{
-			char json[] = "{a:[[0],[0]],b:[[0],[0]]}";
-
-			JsonHashTable root = parser.parseHashTable(json);
-			Assert::IsTrue(root.success());
-
-			JsonArray arrayA = root.getArray("a");
-			Assert::IsTrue(arrayA.success());
-			Assert::AreEqual(2, arrayA.getLength());
-
-			JsonArray arrayB = root.getArray("b");
-			Assert::IsTrue(arrayB.success());
-			Assert::AreEqual(2, arrayB.getLength());
-		}
-	};
-}

tests/TestHashTableExample.cpp

@@ -1,61 +0,0 @@
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-#include <string>
-
-using namespace std;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-
-namespace ArduinoJsonParserTests
-{		
-	TEST_CLASS(TestHashTableExample)
-	{
-		char json[128];
-		JsonParser<32> parser;
-		JsonHashTable hashTable;
-
-	public:
-
-		TEST_METHOD_INITIALIZE(Initialize)
-		{
-			strcpy(json, "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}");
-			hashTable = parser.parseHashTable(json);
-		}
-						
-		TEST_METHOD(HashTable_Success_ReturnsTrue)
-		{
-			Assert::IsTrue(hashTable.success());
-		}			
-
-		TEST_METHOD(HashTable_GetString_ReturnsExpectedValue)
-		{
-			string name = hashTable.getString("Name");
-			Assert::AreEqual(name, string("Blanchon"));
-		}
-
-		TEST_METHOD(HashTable_GetArray_ReturnsExpectedValue)
-		{
-			JsonArray skills = hashTable.getArray("Skills");
-
-			string skill0 = skills.getString(0);
-			Assert::AreEqual(skill0, string("C"));
-
-			string skill1 = skills.getString(1);
-			Assert::AreEqual(skill1, string("C++"));
-
-			string skill2 = skills.getString(2);
-			Assert::AreEqual(skill2, string("C#"));
-		}
-
-		TEST_METHOD(HashTable_GetLong_ReturnsExpectedValue)
-		{
-			int age = hashTable.getLong("Age");
-			Assert::AreEqual(32, age);
-		}
-
-		TEST_METHOD(HashTable_GetBool_ReturnsExpectedValue)
-		{
-			bool online = hashTable.getBool("Online");
-			Assert::AreEqual(true, online);
-		}
-	};
-}