Added a note to avoid issue #10

Added subscript operator on JsonArray and JsonHashTable

ArduinoJson.sln

@@ -7,6 +7,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JsonGeneratorTests", "JsonG
 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
@@ -21,6 +25,14 @@ Global
 		{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

BuildArduinoPackage.sh

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

CHANGELOG.md

@@ -1,6 +1,57 @@
 Arduino JSON: change log
 ========================
 
+v3.2
+----
+
+* Fixed a bug when adding nested object in `JsonArray` (bug introduced in v3.1).
+
+v3.1
+----
+
+* Calling `Generator::JsonObject::add()` twice with the same `key` now replaces the `value`
+* Added `Generator::JsonObject::operator[]`, see bellow the new API
+* Added `Generator::JsonObject::remove()`
+
+Old generator API:
+
+	JsonObject<3> root; 
+    root.add("sensor", "gps");
+    root.add("time", 1351824120);
+    root.add("data", array);
+
+New generator API:
+
+	JsonObject<3> root; 
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+    root["data"] = array;
+
+v3.0
+----
+
+* New parser API, see bellow
+* Renamed `JsonHashTable` into `JsonObject`
+* Added iterators for `JsonArray` and `JsonObject`
+
+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
 ----
 

JsonGenerator.cpp

@@ -7,6 +7,6 @@
 
 #include "JsonGenerator/EscapedString.cpp"
 #include "JsonGenerator/JsonArrayBase.cpp"
+#include "JsonGenerator/JsonObjectBase.cpp"
 #include "JsonGenerator/JsonValue.cpp"
-#include "JsonGenerator/JsonHashTableBase.cpp"
 #include "JsonGenerator/StringBuilder.cpp"

JsonGenerator.h

@@ -4,4 +4,4 @@
 */
 
 #include "JsonGenerator/JsonArray.h"
-#include "JsonGenerator/JsonHashTable.h"
+#include "JsonGenerator/JsonObject.h"

JsonGenerator/EscapedString.cpp

@@ -30,10 +30,8 @@ static inline size_t printCharTo(char c, Print& p)
         : p.write(c);
 }
 
-size_t EscapedString::printTo(Print& p) const
+size_t EscapedString::printTo(const char* s, Print& p)
 {
-    const char* s = rawString;
-
     if (!s) return p.print("null");
     
     size_t n = p.write('\"');

JsonGenerator/EscapedString.h

@@ -14,16 +14,7 @@ namespace ArduinoJson
         class EscapedString
         {
         public:
-
+            static size_t printTo(const char*, Print&);
-            void set(const char* s)
-            {
-                rawString = s;
-            }
-
-            size_t printTo(Print&) const;
-
-        private:
-            const char* rawString;
         };
     }
 }

JsonGenerator/JsonArray.h

@@ -22,7 +22,7 @@ namespace ArduinoJson
             }         
 
         private:
-            Internals::JsonValue items[N];
+            JsonValue items[N];
         };
     }
 }

JsonGenerator/JsonArrayBase.h

@@ -5,27 +5,49 @@
 
 #pragma once
 
-#include "JsonObjectBase.h"
+#include "JsonPrintable.h"
 
 namespace ArduinoJson
 {
     namespace Generator
     {
-        class JsonArrayBase : public JsonObjectBase
+        class JsonArrayBase : public JsonPrintable
         {
         public:
-            JsonArrayBase(Internals::JsonValue* items, int capacity)
+            JsonArrayBase(JsonValue* items, int capacity)
                 : items(items), capacity(capacity), count(0)
             {
 
             }
 
-            template<typename T>
+            void add(const Printable& value)
-            void add(T value)
             {
-                if (count >= capacity) return;
+                addIfPossible<const Printable&>(value);
+            }
 
-                items[count++].set(value);
+            void add(bool value)
+            {
+                addIfPossible<bool>(value);
+            }
+
+            void add(int value)
+            {
+                addIfPossible<long>(value);
+            }
+
+            void add(long value)
+            {
+                addIfPossible<long>(value);
+            }
+
+            void add(double value)
+            {
+                addIfPossible<double>(value);
+            }
+
+            void add(const char* value)
+            {
+                addIfPossible<const char*>(value);
             }
 
             template<int DIGITS>
@@ -33,17 +55,24 @@ namespace ArduinoJson
             {
                 if (count >= capacity) return;
 
-                Internals::JsonValue& v = items[count++];
+                JsonValue& v = items[count++];
                 v.set<DIGITS>(value);
             }
 
             virtual size_t printTo(Print& p) const;
 
-            using JsonObjectBase::printTo;
+            using JsonPrintable::printTo;
 
         private:
-            Internals::JsonValue* items;
+            JsonValue* items;
             int capacity, count;
+
+            template<typename T>
+            void addIfPossible(T value)
+            {
+                if (count < capacity)
+                    items[count++] = value;
+            }
         };
     }
 }

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/JsonHashTable.h

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

JsonGenerator/JsonHashTableBase.cpp

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

JsonGenerator/JsonHashTableBase.h

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

JsonGenerator/JsonObject.h

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

JsonGenerator/JsonObjectBase.cpp

@@ -0,0 +1,92 @@
+/*
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/
+
+#include "JsonObjectBase.h"
+#include <string.h> // for strcmp
+
+using namespace ArduinoJson::Generator;
+using namespace ArduinoJson::Internals;
+
+JsonValue JsonObjectBase::nullValue;
+
+size_t JsonObjectBase::printTo(Print& p) const
+{
+    size_t n = 0;
+
+    n += p.write('{');
+
+    // NB: the code has been optimized for a small size on a 8-bit AVR
+
+    const KeyValuePair* current = items;
+    for (int i = count; i > 0; i--)
+    {       
+        n += EscapedString::printTo(current->key, p);
+        n += p.write(':');
+        n += current->value.printTo(p);
+
+        current++;
+
+        if (i > 1)
+        {
+            n += p.write(',');
+        }
+    }
+
+    n += p.write('}');
+
+    return n;
+}
+
+JsonObjectBase::KeyValuePair* JsonObjectBase::getMatchingPair(JsonKey key) const
+{
+    KeyValuePair* p = items;
+
+    for (int i = count; i > 0; --i)
+    {
+        if (!strcmp(p->key, key))
+            return p;
+
+        p++;
+    }
+
+    return 0;
+}
+
+JsonValue& JsonObjectBase::operator[](JsonKey key)
+{
+    KeyValuePair* match = getMatchingPair(key);
+
+    if (match)
+        return match->value;
+
+    JsonValue* value;
+
+    if (count < capacity)
+    {
+        items[count].key = key;
+        value = &items[count].value;
+        count++;
+    }
+    else
+    {
+        value = &nullValue;
+    }
+
+    value->reset();
+    return *value;
+}
+
+bool JsonObjectBase::containsKey(JsonKey key) const
+{
+    return getMatchingPair(key) != 0;
+}
+
+void JsonObjectBase::remove(JsonKey key)
+{
+    KeyValuePair* match = getMatchingPair(key);    
+    if (match == 0) return;
+
+    *match = items[--count];
+}

JsonGenerator/JsonObjectBase.h

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

JsonGenerator/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

@@ -6,6 +6,7 @@
 #include "EscapedString.h"
 #include "JsonValue.h"
 
+using namespace ArduinoJson::Generator;
 using namespace ArduinoJson::Internals;
 
 size_t JsonValue::printBoolTo(const Content& c, Print& p)
@@ -28,5 +29,5 @@ size_t JsonValue::printPrintableTo(const Content& c, Print& p)
 
 size_t JsonValue::printStringTo(const Content& c, Print& p)
 {
-    return c.asString.printTo(p);
+    return EscapedString::printTo(c.asString, p);
 }

JsonGenerator/JsonValue.h

@@ -11,68 +11,109 @@
 
 namespace ArduinoJson
 {
-    namespace Internals
+    namespace Generator
     {
         class JsonValue
         {
         public:
-            
+
-            void set(bool value)
+            void operator=(bool value)
             {
                 printToImpl = &printBoolTo;
                 content.asBool = value;
             }
 
-            void set(long value)               
+            void operator=(long value)
             {
                 printToImpl = &printLongTo;
                 content.asLong = value;
             }
 
-            void set(int value)
+            void operator=(int value)
             {
                 printToImpl = &printLongTo;
                 content.asLong = value;
             }
 
-            void set(Printable& value)
+            void operator=(const Printable& value)
             {
                 printToImpl = &printPrintableTo;
                 content.asPrintable = &value;
             }
 
-            void set(const char* value)
+            void operator=(const char* value)
             {
                 printToImpl = &printStringTo;
-                content.asString.set(value);
+                content.asString = value;
             }
 
-            void set(double value)
+            void operator=(double value)
             {
                 set<2>(value);
             }
 
-            template<int DIGITS>
+            template <int DIGITS>
             void set(double value)
             {
-                printToImpl = &printDoubleTo<DIGITS>;
+                printToImpl = &printDoubleTo < DIGITS > ;
                 content.asDouble = value;
             }
 
+            operator bool()
+            {
+                return content.asBool;
+            }
+
+            operator const char*()
+            {
+                return content.asString;
+            }
+
+            operator double()
+            {
+                return content.asDouble;
+            }
+
+            operator float()
+            {
+                return (float)content.asDouble;
+            }
+
+            operator int()
+            {
+                return content.asLong;
+            }
+
+            operator long()
+            {
+                return content.asLong;
+            }
+
+            operator const Printable&()
+            {
+                return *content.asPrintable;
+            }
+
             size_t printTo(Print& p) const
             {
                 // handmade polymorphism
                 return printToImpl(content, p);
             }
 
+            void reset()
+            {
+                content.asDouble = 0;
+                printToImpl = printStringTo;
+            }
+
         private:
             union Content
             {
-                bool          asBool;
+                bool                asBool;
-                long          asLong;
+                double              asDouble;
-                Printable*    asPrintable;
+                long                asLong;
-                EscapedString asString;
+                const Printable*    asPrintable;
-                double        asDouble;
+                const char*         asString;
             };
 
             Content content;
@@ -84,7 +125,7 @@ namespace ArduinoJson
             static size_t printPrintableTo(const Content&, Print&);
             static size_t printStringTo(const Content&, Print&);
 
-            template<int DIGITS>
+            template <int DIGITS>
             static size_t printDoubleTo(const Content& c, Print& p)
             {
                 return p.print(c.asDouble, DIGITS);

JsonGenerator/README.md

@@ -1,9 +1,9 @@
 Arduino JSON library - Generator
 ================================
 
-This library is a simple JSON encoder for embedded systems.
+*An elegant and efficient 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's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
 
 It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
 
@@ -11,11 +11,11 @@ It has been written with Arduino in mind, but it isn't linked to Arduino librari
 Features
 --------
 
-* Supports nested objects
 * Elegant API, very easy to use 
 * Fixed memory allocation (no malloc)
 * Small footprint
-* Implements Arduino's Printable interface
+* Supports nested objects
+* Implements Arduino's `Printable interface
 * MIT License
 
 
@@ -23,13 +23,13 @@ Example
 -------
 
     JsonArray<2> array;
-    array.add<6>(48.756080);
+    array.add<6>(48.756080);  // <6> specifies the number of digits in the output
-    array.add<6>(2.302038);
+    array.add<6>(2.302038);   // (the default is 2)
 
-    JsonHashTable<3> root;
+    JsonObject<3> root;
-    root.add("sensor", "gps");
+    root["sensor"] = "gps";
-    root.add("time", 1351824120);
+    root["time"] = 1351824120;
-    root.add("data", array);
+    root["data"] = array;
 
     Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 
@@ -50,12 +50,19 @@ 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 an array or an hash-table.
+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.
 
-#### Array
+#### JSON Array
 
 You create an array with the following line:
 
@@ -73,7 +80,7 @@ Then you can add strings, integer, booleans, etc:
     array.add(42);
     array.add(true);
 
-There are two syntaxes for the floating point values:
+There are two syntaxes for floating point values:
 
 	array.add<4>(3.1415);  // 4 digits: "3.1415" 
     array.add(3.14);	   // 2 digits: "3.14"
@@ -91,37 +98,69 @@ Finally you can add nested object to the array:
 
 or
 
-    JsonHashTable<8> nestedHash;
+    JsonObject<8> nestedObject;
-    array.add(nestedHash);
+    array.add(nestedObject);
 
-#### Hash-table
+> ##### CAUTION! Nested objects must be in memory
+> Calling `add()` makes the `JsonArray` store a pointer to the nested object.
+> This is designed to avoid memory duplication.
+> But it can only work if the object is in memory when `printTo()` is executed.
+> For instance, don't do this:
+> 
+>     void addNestedObject()
+>     {
+>         JsonObject<2> nestedObject;
+>         // ...
+>         array.add(nestedObject); // <- DON'T !!
+>         
+>         // array now contains a pointer to a local variable that will be
+>         // discarded as soon as the function exits 
+>     } 
+>     
+> For the same reason, don't do this either:
+> 
+>     for( int i=0; i<100; i++)
+>     {
+>         JsonObject<2> nestedObject;
+>         // ...
+>         array.add(nestedObject); // <- DON'T !!
+>     }  
+>     // array now contains 100 pointers to the same a local variable
+>     // that is out of the scope anyway
 
-You create a hash-table with the following line:
+#### JSON Object
 
-    JsonHashTable<8> hash;
+You create a JSON object (ie hash-table/dictionary) with the following line:
 
-Like with the array class, there is a template parameter that gives the capacity of the hash-table.
+    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: 
 
-    hash.add("key1", "bazinga!");
+    object["key1"] = "bazinga!";
-    hash.add("key2", 42);
+    object["key2"] = 42;
-    hash.add("key3", true);
+    object["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" 
+	object["key4"].set<4>(3.1415);  // 4 digits "3.1415" 
-    array.add("key5", 3.14);	   // 2 digits: "3.14"
+    object["key5"] = 3.1415;	    // default: 2 digits "3.14"
 
 Finally you can add nested objects:
 
     JsonArray<8> nestedArray;
-    hash.add("key6", nestedArray);
+    object["key6"] = nestedArray;
 
 or
 
-    JsonHashTable<8> nestedHash;
+    JsonObject<8> nestedObject;
-    hash.add("key7", nestedHash);
+    object["key7"] = nestedObject;
+
+> ##### Other JsonObject functions
+> * `object.add(key, value)` is a synonym for `object[key] = value`
+> * `object.containsKey(key)` returns `true` is the `key` is present in `object`
+> * `object.remove(key)` removes the `value` associated with `key`
 
 ### 4. Get the JSON string
 
@@ -133,7 +172,7 @@ Both ways are the easy way :-)
 
 #### Use a classic `char[]`
 
-Whether you have a `JsonArray` or a `JsonHashTable`, simply call `printTo()` with the destination buffer, like so:
+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));
@@ -149,7 +188,7 @@ or
     array.printTo(Serial);
 
 > ##### About the Printable interface
-> `JsonArray` and `JsonHashTable` implement Arduino's `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`...
    
@@ -161,7 +200,40 @@ 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 |
+| Type                | Size in bytes |
-| ---------------------- | ------------- |
+| --------------------| ------------- |
-| JsonArray&lt;N&gt;     | 8 + 6 x N     |
+| JsonArray&lt;N&gt;  | 8 + 6 x N     |
-| JsonHashTable&lt;N&gt; | 8 + 8 x N     |
+| JsonObject&lt;N&gt; | 8 + 8 x N     |
+
+
+Code size
+---------
+
+The following values has been obtained with Arduino IDE 1.0.5, targeting an Arduino Duelmilanove with an ATmega 328.
+
+### Minimum setup
+
+| Function                            | Size |
+| ----------------------------------- | ---- |
+| `JsonObjectBase::printTo()`         | 234  |
+| `EscapedString::printTo()`          | 196  |
+| `JsonArrayBase::printTo()`          | 164  |
+| `Print::print(char const*)`         | 146  |
+| `JsonObjectBase::operator[]`        | 114  |
+| `JsonObjectBase::getMatchingPair()` | 72   |
+| `JsonValue::printPrintableTo()`     | 40   |
+| `JsonValue::printStringTo()`        | 12   |
+
+### Additional space for integers
+
+| Function                     | Size |
+| ---------------------------- | ---- |
+| `Print::print(long, int)`    | 328  |
+| `JsonValue::printLongTo()`   | 22   |
+
+### Additional space for floating point
+
+| Function                       | Size |
+| ------------------------------ | ---- |
+| `Print::print(double, int)`    | 1548 |
+| `JsonValue::printDouleTo<2>()` | 22   |

JsonGeneratorTests/EscapedStringTests.cpp

@@ -16,8 +16,7 @@ namespace JsonGeneratorTests
     {
         char buffer[1024];
         size_t returnValue;
-        EscapedString escapedString;
+        
-
     public:
 
         TEST_METHOD(Null)
@@ -83,9 +82,8 @@ namespace JsonGeneratorTests
     private:
         void whenInputIs(const char* input)
         {
-            StringBuilder sb(buffer, sizeof(buffer));            
+            StringBuilder sb(buffer, sizeof(buffer));  
-            escapedString.set(input);
+            returnValue = EscapedString::printTo(input, sb);
-            returnValue = escapedString.printTo(sb);
         }
 
         void outputMustBe(const char* expected)

JsonGeneratorTests/Issue10.cpp

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

JsonGeneratorTests/JsonArrayTests.cpp

@@ -5,7 +5,7 @@
 
 #include "CppUnitTest.h"
 #include "JsonArray.h"
-#include "JsonHashTable.h"
+#include "JsonObject.h"
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 using namespace ArduinoJson::Generator;
@@ -14,7 +14,7 @@ namespace JsonGeneratorTests
 {		
     TEST_CLASS(JsonArrayTests)
     {
-        JsonArray<2> arr;
+        JsonArray<2> array;
         char buffer[256];
 
     public:
@@ -26,111 +26,117 @@ namespace JsonGeneratorTests
 
         TEST_METHOD(Null)
         {
-            add((char*)0);
+            array.add((char*) 0);
 
             outputMustBe("[null]");
         }
 
         TEST_METHOD(OneString)
         {
-            add("hello");
+            array.add("hello");
 
             outputMustBe("[\"hello\"]");
         }
 
         TEST_METHOD(TwoStrings)
         {
-            add("hello");
+            array.add("hello");
-            add("world");
+            array.add("world");
 
             outputMustBe("[\"hello\",\"world\"]");
         }
 
         TEST_METHOD(OneStringOverCapacity)
         {
-            add("hello");
+            array.add("hello");
-            add("world");
+            array.add("world");
-            add("lost");
+            array.add("lost");
 
             outputMustBe("[\"hello\",\"world\"]");
         }
 
         TEST_METHOD(OneDoubleDefaultDigits)
         {
-            add(3.14159265358979323846);
+            array.add(3.14159265358979323846);
             outputMustBe("[3.14]");
         }
 
         TEST_METHOD(OneDoubleFourDigits)
         {
-            add<4>(3.14159265358979323846);
+            array.add<4>(3.14159265358979323846);
             outputMustBe("[3.1416]");
         }
 
         TEST_METHOD(OneInteger)
         {
-            add(1);
+            array.add(1);
 
             outputMustBe("[1]");
         }
 
         TEST_METHOD(TwoIntegers)
         {
-            add(1);
+            array.add(1);
-            add(2);
+            array.add(2);
 
             outputMustBe("[1,2]");
         }
 
         TEST_METHOD(OneIntegerOverCapacity)
         {
-            add(1);
+            array.add(1);
-            add(2);
+            array.add(2);
-            add(3);
+            array.add(3);
 
             outputMustBe("[1,2]");
         }
 
         TEST_METHOD(OneTrue)
         {
-            add(true);
+            array.add(true);
 
             outputMustBe("[true]");
         }
 
         TEST_METHOD(OneFalse)
         {
-            add(false);
+            array.add(false);
 
             outputMustBe("[false]");
         }
 
         TEST_METHOD(TwoBooleans)
         {
-            add(false);
+            array.add(false);
-            add(true);
+            array.add(true);
 
             outputMustBe("[false,true]");
         }
 
         TEST_METHOD(OneBooleanOverCapacity)
         {
-            add(false);
+            array.add(false);
-            add(true);
+            array.add(true);
-            add(false);
+            array.add(false);
 
             outputMustBe("[false,true]");
         }
 
         TEST_METHOD(OneEmptyNestedArray)
         {
-           addNested(JsonArray<1>());
+            JsonArray<1> nestedArray;
+            
+            array.add(nestedArray);
+
             outputMustBe("[[]]");
         }
 
         TEST_METHOD(OneEmptyNestedHash)
         {
-            addNested(JsonHashTable<1>());
+            JsonObject<1> nestedObject;
+
+            array.add(nestedObject);
+
             outputMustBe("[{}]");
         }
 
@@ -139,33 +145,16 @@ namespace JsonGeneratorTests
             JsonArray<1> nestedArray;
             nestedArray.add(1);
 
-            addNested(nestedArray);
+            array.add(nestedArray);
 
             outputMustBe("[[1]]");
         }
 
     private:
 
-        void addNested(JsonObjectBase& value)
-        {
-            arr.add<JsonObjectBase&>(value);
-        }
-
-        template<typename T>
-        void add(T value)
-        {
-            arr.add(value);
-        }
-
-        template<int DIGITS>
-        void add(double value)
-        {
-            arr.add<DIGITS>(value);
-        }
-
         void outputMustBe(const char* expected)
         {      
-            size_t n = arr.printTo(buffer, sizeof(buffer));
+            size_t n = array.printTo(buffer, sizeof(buffer));
             Assert::AreEqual(expected, buffer);
             Assert::AreEqual(strlen(expected), n);
         }

JsonGeneratorTests/JsonGeneratorTests.vcxproj

@@ -55,7 +55,7 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>ARDUINO_JSON_NO_DEPRECATION_WARNING;_DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
     </ClCompile>
     <Link>
@@ -84,29 +84,19 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="..\JsonGenerator\EscapedString.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonArrayBase.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonHashTableBase.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonValue.cpp" />
-    <ClCompile Include="..\JsonGenerator\StringBuilder.cpp" />
     <ClCompile Include="EscapedStringTests.cpp" />
+    <ClCompile Include="Issue10.cpp" />
     <ClCompile Include="JsonArrayTests.cpp" />
-    <ClCompile Include="JsonHashTableTests.cpp" />
+    <ClCompile Include="JsonObject_Indexer_Tests.cpp" />
-    <ClCompile Include="JsonValueTests.cpp" />
+    <ClCompile Include="JsonObject_PrintTo_Tests.cpp" />
-    <ClCompile Include="Print.cpp" />
+    <ClCompile Include="JsonValue_Cast_Tests.cpp" />
+    <ClCompile Include="JsonValue_PrintTo_Tests.cpp" />
     <ClCompile Include="StringBuilderTests.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="..\JsonGenerator\EscapedString.h" />
+    <ProjectReference Include="..\JsonGenerator\JsonGenerator.vcxproj">
-    <ClInclude Include="..\JsonGenerator\JsonArray.h" />
+      <Project>{c6536d27-738d-4ceb-a2bc-e13c8897d894}</Project>
-    <ClInclude Include="..\JsonGenerator\JsonArrayBase.h" />
+    </ProjectReference>
-    <ClInclude Include="..\JsonGenerator\JsonHashTable.h" />
-    <ClInclude Include="..\JsonGenerator\JsonHashTableBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonObjectBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonValue.h" />
-    <ClInclude Include="..\JsonGenerator\Print.h" />
-    <ClInclude Include="..\JsonGenerator\Printable.h" />
-    <ClInclude Include="..\JsonGenerator\StringBuilder.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

JsonGeneratorTests/JsonGeneratorTests.vcxproj.filters

@@ -18,67 +18,26 @@
     <ClCompile Include="JsonArrayTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="JsonHashTableTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="JsonValueTests.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonValue.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\StringBuilder.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="StringBuilderTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Print.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\EscapedString.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonHashTableBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonArrayBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="EscapedStringTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-  </ItemGroup>
+    <ClCompile Include="JsonObject_PrintTo_Tests.cpp">
-  <ItemGroup>
+      <Filter>Source Files</Filter>
-    <ClInclude Include="..\JsonGenerator\JsonArray.h">
+    </ClCompile>
-      <Filter>Header Files</Filter>
+    <ClCompile Include="JsonObject_Indexer_Tests.cpp">
-    </ClInclude>
+      <Filter>Source Files</Filter>
-    <ClInclude Include="..\JsonGenerator\JsonHashTable.h">
+    </ClCompile>
-      <Filter>Header Files</Filter>
+    <ClCompile Include="JsonValue_PrintTo_Tests.cpp">
-    </ClInclude>
+      <Filter>Source Files</Filter>
-    <ClInclude Include="..\JsonGenerator\JsonObjectBase.h">
+    </ClCompile>
-      <Filter>Header Files</Filter>
+    <ClCompile Include="JsonValue_Cast_Tests.cpp">
-    </ClInclude>
+      <Filter>Source Files</Filter>
-    <ClInclude Include="..\JsonGenerator\JsonValue.h">
+    </ClCompile>
-      <Filter>Header Files</Filter>
+    <ClCompile Include="Issue10.cpp">
-    </ClInclude>
+      <Filter>Source Files</Filter>
-    <ClInclude Include="..\JsonGenerator\Print.h">
+    </ClCompile>
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\Printable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\StringBuilder.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\EscapedString.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonHashTableBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonArrayBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>

JsonGeneratorTests/JsonHashTableTests.cpp

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

JsonGeneratorTests/JsonObject_Indexer_Tests.cpp

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

JsonGeneratorTests/JsonObject_PrintTo_Tests.cpp

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

JsonGeneratorTests/JsonValue_Cast_Tests.cpp

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

JsonGeneratorTests/JsonValue_PrintTo_Tests.cpp

@@ -8,11 +8,12 @@
 #include "JsonValue.h"
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Generator;
 using namespace ArduinoJson::Internals;
 
 namespace JsonGeneratorTests
 {
-    TEST_CLASS(JsonValueTests)
+    TEST_CLASS(JsonValue_PrintTo_Tests)
     {
         char buffer[1024];
         size_t returnValue;
@@ -21,62 +22,62 @@ namespace JsonGeneratorTests
 
         TEST_METHOD(String)
         {
-            whenInputIs("hello");
+            setValueTo("hello");
             outputMustBe("\"hello\"");
         }
 
         TEST_METHOD(Float)
         {
-            whenInputIs(3.1415f);
+            setValueTo(3.1415f);
             outputMustBe("3.14");
         }
 
         TEST_METHOD(DoubleZeroDigits)
         {
-            whenInputIs<0>(3.14159265358979323846);
+            setValueTo<0>(3.14159265358979323846);
             outputMustBe("3");
         }
 
         TEST_METHOD(DoubleOneDigit)
         {
-            whenInputIs<1>(3.14159265358979323846);
+            setValueTo<1>(3.14159265358979323846);
             outputMustBe("3.1");
         }
 
         TEST_METHOD(DoubleTwoDigits)
         {
-            whenInputIs<2>(3.14159265358979323846);
+            setValueTo<2>(3.14159265358979323846);
             outputMustBe("3.14");
         }
         
         TEST_METHOD(Integer)
         {
-            whenInputIs(314);
+            setValueTo(314);
             outputMustBe("314");
         }
 
         TEST_METHOD(Char)
         {
-            whenInputIs('A');
+            setValueTo('A');
             outputMustBe("65");
         }
 
         TEST_METHOD(Short)
         {
-            whenInputIs((short)314);
+            setValueTo((short)314);
             outputMustBe("314");
         }
 
         TEST_METHOD(Long)
         {
-            whenInputIs(314159265L);
+            setValueTo(314159265L);
             outputMustBe("314159265");
         }
 
     private:
 
         template<int DIGITS>
-        void whenInputIs(double value)
+        void setValueTo(double value)
         {
             StringBuilder sb(buffer, sizeof(buffer));
             JsonValue jsonValue;
@@ -85,11 +86,11 @@ namespace JsonGeneratorTests
         }
 
         template<typename T>
-        void whenInputIs(T value)
+        void setValueTo(T value)
         {
             StringBuilder sb(buffer, sizeof(buffer));
             JsonValue jsonValue;
-            jsonValue.set(value);
+            jsonValue = value;
             returnValue = jsonValue.printTo(sb);
         }
 

JsonParser.cpp

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

JsonParser/JsonArray.cpp

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

JsonParser/JsonArray.h

@@ -5,39 +5,99 @@
 
 #pragma once
 
-#include "JsonObjectBase.h"
+#include "JsonValue.h"
+#include "JsonArrayIterator.h"
 
 namespace ArduinoJson
 {
     namespace Parser
     {
-        class JsonHashTable;
+        class JsonObject;
-
+                
-        class JsonArray : public JsonObjectBase
+        // A JSON array
-        {
+        class JsonArray : JsonValue
-            friend class JsonParserBase;
+        {          
-            friend class JsonHashTable;
-
         public:
 
-            JsonArray()	{}
+            // Create an invalid array
-
+            JsonArray() 
-            int getLength()
+            {            
+            }
+
+            // Convert a JsonValue into a JsonArray
+            JsonArray(JsonValue value)
+                : JsonValue(value)
             {
-                return tokens != 0 ? tokens[0].size : 0;
+            }
+
+            // 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);
             }
 
-            JsonArray getArray(int index);
+            // Obsolete: Use operator[] instead
-            bool getBool(int index);
+            DEPRECATED bool getBool(int index)
-            double getDouble(int index);
+            {
-            JsonHashTable getHashTable(int index);
+                return operator[](index);
-            long getLong(int index);
+            }
-            char* getString(int index);
 
-        private:
+            // Obsolete: Use operator[] instead
+            DEPRECATED double getDouble(int index)
+            {
+                return operator[](index);
+            }
 
-            JsonArray(char* json, jsmntok_t* tokens);
+            // Obsolete: Use operator[] instead
-            jsmntok_t* getToken(int index);
+            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/JsonHashTable.cpp

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

JsonParser/JsonHashTable.h

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

JsonParser/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/JsonObjectBase.cpp

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

JsonParser/JsonObjectBase.h

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

JsonParser/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

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

JsonParser/JsonParser.vcxproj

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C15274DE-2695-4DFE-8520-4424223FE6DA}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>JsonParser</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="jsmn.h" />
+    <ClInclude Include="JsonArray.h" />
+    <ClInclude Include="JsonArrayIterator.h" />
+    <ClInclude Include="JsonObject.h" />
+    <ClInclude Include="JsonObjectIterator.h" />
+    <ClInclude Include="JsonPair.h" />
+    <ClInclude Include="JsonParser.h" />
+    <ClInclude Include="JsonParserBase.h" />
+    <ClInclude Include="JsonToken.h" />
+    <ClInclude Include="JsonValue.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="jsmn.cpp" />
+    <ClCompile Include="JsonArray.cpp" />
+    <ClCompile Include="JsonObject.cpp" />
+    <ClCompile Include="JsonParserBase.cpp" />
+    <ClCompile Include="JsonToken.cpp" />
+    <ClCompile Include="JsonValue.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

JsonParser/JsonParser.vcxproj.filters

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

JsonParser/JsonParserBase.cpp

@@ -4,16 +4,17 @@
 */
 
 #include "JsonParserBase.h"
+#include "JsonToken.h"
 
 using namespace ArduinoJson::Parser;
 
-jsmntok_t* JsonParserBase::parse(char* json)
+JsonValue JsonParserBase::parse(char* json)
 {
     jsmn_parser parser;
     jsmn_init(&parser);
 
     if (JSMN_SUCCESS != jsmn_parse(&parser, json, tokens, maxTokens))
-        return 0;
+        return JsonToken::null();
 
-    return tokens;
+    return JsonToken(json, tokens);
 }

JsonParser/JsonParserBase.h

@@ -1,53 +1,49 @@
 /*
 * Arduino JSON library
 * Benoit Blanchon 2014 - MIT License
-*/
+*/
 
 #pragma once
 
-#include "JsonHashTable.h"
 #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
-            * Parse the JSON string and return a array.
+            //
-            *
+            // The content of the string may be altered to add '\0' at the
-            * The content of the string may be altered to add '\0' at the
+            // end of string tokens            
-            * end of string tokens
+            JsonValue parse(char* json);
-            */
+
-            JsonArray parseArray(char* json)
+            // Obsolete: use parse() instead
+            DEPRECATED JsonArray parseArray(char* json)
             {
-                return JsonArray(json, parse(json));
+                return parse(json);
             }
 
-            /*
+            // Obsolete: use parse() instead
-            * Parse the JSON string and return a array.
+            DEPRECATED JsonObject parseHashTable(char* json)
-            *
-            * 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));
+                return parse(json);
             }
 
         private:
             jsmntok_t* tokens;
             int maxTokens;
-
-            jsmntok_t* parse(char* json);
         };
     }
 }

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

@@ -22,17 +22,15 @@ Features
 Example
 -------
 
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+	JsonParser<32> parser;
+    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";   
 
-    JsonParser<32> parser;
+    JsonObject root = parser.parse(json);
 
-    JsonHashTable root = parser.parseHashTable(json);
+    char*  sensor    = root["sensor"];
-
+    long   time      = root["time"];
-    char* sensor = root.getString("sensor");
+    double latitude  = root["data"][0];
-
+    double longitude = root["data"][1];
-    long time = root.getLong("time");
-    
-    JsonArray coords = root.getArray("data");
 
 
 How to  use ?
@@ -51,6 +49,13 @@ 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
 
@@ -60,7 +65,7 @@ To extract data from the JSON string, you need to create a `JsonParser`, and spe
     
 > #### 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.
+> 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.
@@ -73,28 +78,24 @@ To extract data from the JSON string, you need to create a `JsonParser`, and spe
 
 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 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, hash-tables, numbers or strings.
+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.
 
-#### Hash-table
+#### Object
 
 Consider we have a `char json[]` containing to the following JSON string:
 
     {
-        "Name":"Blanchon",
+        "sensor":"gps",
-        "Skills":[
+		"time":1351824120,
-            "C",
+		"data":[48.756080,2.302038]
-            "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`:
+In this case the string contains a JSON object, so you need to extract a `JsonObject`:
    
-    JsonHashTable root = parser.parseHashTable(json);
+    JsonObject root = parser.parse(json);
     
 To check if the parsing was successful, you must check:
 
@@ -105,13 +106,18 @@ To check if the parsing was successful, you must check:
     
 And then extract the member you need:
     
-    char* name = hashTable.getString("Name");
+    char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
 
-    JsonArray skills = hashTable.getArray("Skills");
+You can also iterate through the key-value pairs of the object:
 
-    int age = hashTable.getLong("Age");
+    for (JsonObjectIterator i=root.begin(); i!=root.end(); ++i)
-
+    {
-    bool online = hashTable.getBool("Online");
+      Serial.println(i.key());
+      Serial.println((char*)i.value());
+    }
     
 #### Array
 
@@ -124,7 +130,7 @@ Consider we have a `char json[]` containing to the following JSON string:
 
 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);
+    JsonArray root = parser.parse(json);
     
 To check if the parsing was successful, you must check:
 
@@ -135,20 +141,24 @@ To check if the parsing was successful, you must check:
     
 And then extract the content by its index in the array:
     
-    JsonArray row0 = root.getArray(0);
+    double a = root[0][0];
-    double a = row0.getDouble(0);
+	double b = root[0][1];
-    
+	double c = root[1][0];
-or simply:
+	double d = root[1][1];
-
-    double a = root.getArray(0).getDouble(0);
 
+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::parseArray()` or `JsonParser::parseHashTable()` failed.
+By design, the library has no way to tell you why `JsonParser::parse()` failed.
 
 There are basically two reasons why they may fail:
 
@@ -175,7 +185,7 @@ That is why an 8-bit processor is not able to parse long and complex JSON string
 
 ### 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.
+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:
 
@@ -191,7 +201,7 @@ because the local variable `parser` will be *removed* from memory when the funct
 
 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.
+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.
    
@@ -203,202 +213,38 @@ Here are the size of the main classes of the library.
 
 This table is for an 8-bit Arduino, types would be bigger on a 32-bit processor.
 
-<table>
+| Type         | Size in bytes |
-    <tr>
+| ------------ | ------------- |
-        <th>Type</th>
+| `Parser<N>`  | 4 + 8 x N     |
-        <th>Size in bytes</th>
+| `JsonArray`  | 4             |
-    </tr>
+| `JsonObject` | 4             |
-    <tr>
+| `JsonValue`  | 4             |
-        <td>Parser&lt;N&gt;</td>
-        <td>4 + 8 x N</td>
-    </tr>
-    <tr>
-        <td>JsonArray</td>
-        <td>4</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable</td>
-        <td>4</td>
-    </tr>
-</table> 
-
 
 Code size
 ---------
 
-Theses tables has been created by analyzing the map file generated by AVR-GCC after adding `-Wl,-Map,foo.map` to the command line.
+The sizes have been obtained with Arduino IDE 1.0.5 for a Duemilanove.
-
-As you'll see the code size is between 1680 and 3528 bytes, depending on the features you use.
 
 ### Minimum setup
 
-<table>
+| Function                             | Size |
-    <tr>
+| ------------------------------------ | ---- |
-        <th>Function</th>
+| `jsmn_parse()`                       | 962  |
-        <th>Size in bytes</th>
+| `JsonValue::operator[](char const*)` | 218  | 
-    </tr>
+| `JsonParserBase::parse()`            | 116  | 
-    <tr>
+| `JsonValue::operator[](int)`         | 108  |
-        <td>strcmp(char*,char*)</td>
+| `strcmp()`                           | 18   | 
-        <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
+### Additional space for integers
 
-<table>
+| Function                     | Size |
-    <tr>
+| ---------------------------- | ---- |
-        <th>Function</th>
+| `strtol()`                   | 606  |
-        <th>Size in bytes</th>
+| `JsonValue::operator long()` | 94   |
-    </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
+### Additional space for floating points
 
-<table>
+| Function                         | Size  |
-    <tr>
+| -------------------------------- | ----- |
-        <th>Function</th>
+| `strtod()`                       | 1369  |
-        <th>Size in bytes</th>
+| `JsonValue::operator double()`   | 82    |
-    </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>

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/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

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

JsonParserTests/JsonParserTests.vcxproj

@@ -56,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>
@@ -85,22 +85,16 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="..\JsonParser\jsmn.cpp" />
+    <ClCompile Include="JsonObjectIteratorTests.cpp" />
-    <ClCompile Include="..\JsonParser\JsonArray.cpp" />
-    <ClCompile Include="..\JsonParser\JsonHashTable.cpp" />
-    <ClCompile Include="..\JsonParser\JsonObjectBase.cpp" />
-    <ClCompile Include="..\JsonParser\JsonParserBase.cpp" />
     <ClCompile Include="JsonArrayTests.cpp" />
-    <ClCompile Include="JsonHashTableTests.cpp" />
+    <ClCompile Include="JsonArrayIteratorTests.cpp" />
+    <ClCompile Include="JsonObjectTests.cpp" />
     <ClCompile Include="GbathreeBug.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="..\JsonParser\jsmn.h" />
+    <ProjectReference Include="..\JsonParser\JsonParser.vcxproj">
-    <ClInclude Include="..\JsonParser\JsonArray.h" />
+      <Project>{c15274de-2695-4dfe-8520-4424223fe6da}</Project>
-    <ClInclude Include="..\JsonParser\JsonHashTable.h" />
+    </ProjectReference>
-    <ClInclude Include="..\JsonParser\JsonObjectBase.h" />
-    <ClInclude Include="..\JsonParser\JsonParser.h" />
-    <ClInclude Include="..\JsonParser\JsonParserBase.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

JsonParserTests/JsonParserTests.vcxproj.filters

@@ -15,49 +15,20 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\JsonParser\jsmn.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonArray.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonHashTable.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonObjectBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="JsonArrayTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="GbathreeBug.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="JsonHashTableTests.cpp">
+    <ClCompile Include="JsonObjectTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\JsonParser\JsonParserBase.cpp">
+    <ClCompile Include="JsonArrayIteratorTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonObjectIteratorTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\JsonParser\jsmn.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonHashTable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonObjectBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonParser.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonParser\JsonParserBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>

README.md

@@ -1,9 +1,9 @@
 Arduino JSON library
 ====================
 
-*A simple and efficient JSON library for embedded systems.*
+*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).
+It's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
 
 It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
 
@@ -22,9 +22,9 @@ Feature comparison
 
 | Library      | Memory allocation | Nested objects | Parser size | Encoder size  |
 | ------------ | ----------------- | -------------- | ----------- | ------------- |
-| Arduino JSON | static            | yes            | 2616 Bytes  | 628 bytes     |
+| Arduino JSON | static            | yes            | 2642 Bytes  | 862 bytes     |
-| json-arduino | dynamic           | no             | 3348 (+28%) | not supported |
+| json-arduino | dynamic           | no             | 3348 (+27%) | not supported |
-| aJson        | dynamic           | yes            | 5088 (+94%) | 4678 (+640%)  |
+| aJson        | dynamic           | yes            | 5088 (+93%) | 4678 (+540%)  |
 
 "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).
@@ -49,8 +49,10 @@ From Arduino's Forum user `gbathree`:
 From StackOverflow user `thegreendroid`:
 > It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
 
-Links
+Related blog posts
 -----
 
-* [The project for which I made me this library](http://blog.benoitblanchon.fr/rfid-payment-terminal/)
+* [The project I originally wrote this library for](http://blog.benoitblanchon.fr/rfid-payment-terminal/)
-* [Blog post on the motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
+* [Motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
+* [Release of version 2](http://blog.benoitblanchon.fr/arduino-json-v2-0/)
+* [Release of version 3](http://blog.benoitblanchon.fr/arduino-json-v3-0/)

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -15,10 +15,10 @@ void setup()
     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
 
-    JsonHashTable<3> root; 
+    JsonObject<3> root; 
-    root.add("sensor", "gps");
+    root["sensor"] = "gps";
-    root.add("time", 1351824120);
+    root["time"] = 1351824120;
-    root.add("data", array);
+    root["data"] = array;
 
     Serial.print(root); // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 }

examples/JsonParserExample/JsonParserExample.ino

@@ -11,31 +11,27 @@ void setup()
 {
     Serial.begin(9600);
 
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+    char json [] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
     JsonParser<16> parser;
 
-    JsonHashTable root = parser.parseHashTable(json);
+    JsonObject root = parser.parse(json);
 
     if (!root.success())
     {
-        Serial.println("JsonParser.parseHashTable() failed");
+        Serial.println("JsonParser.parse() failed");
         return;
     }
 
-    char* sensor = root.getString("sensor");
+    char*  sensor    = root["sensor"];
-    Serial.println(sensor);
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
 
-    long time = root.getLong("time");
+    Serial.println(sensor);
     Serial.println(time);
-    
+    Serial.println(latitude, 6);
-    JsonArray coords = root.getArray("data");
+    Serial.println(longitude, 6);
-    
-    for (int i = 0; i < coords.getLength(); i++)
-    {
-        double value = coords.getDouble(i);
-        Serial.println(value, 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