Updated README.md

Added code size
2014-07-23 20:18:59 +02:00 · 2014-07-23 13:45:07 +02:00 · 2014-07-23 13:29:56 +02:00 · 2014-07-23 12:56:42 +02:00 · 2014-07-23 12:56:29 +02:00 · 2014-07-23 12:14:59 +02:00
51 changed files with 1578 additions and 959 deletions
--- a/ArduinoJson.sln
+++ b/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
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,6 +1,31 @@
 Arduino JSON: change log
 ========================

+v3.0
+----
+
+* New parser API, see bellow
+* Renamed `JsonHashTable` into `JsonObject`
+* Added iterators for `JsonArray` and `JsonObject`
+
+Old parser API:
+
+    JsonHashTable root = parser.parseHashTable(json);
+
+	char*  sensor    = root.getString("sensor");
+	long   time      = root.getLong("time");
+	double latitude  = root.getArray("data").getDouble(0);
+    double longitude = root.getArray("data").getDouble(1);
+
+New parser API:
+
+	JsonObject root = parser.parse(json);
+
+	char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
 v2.1
 ----

--- a/JsonGenerator.cpp
+++ b/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"
--- a/JsonGenerator.h
+++ b/JsonGenerator.h
@ -4,4 +4,4 @@
 */

 #include "JsonGenerator/JsonArray.h"
-#include "JsonGenerator/JsonHashTable.h"
+#include "JsonGenerator/JsonObject.h"
--- a/JsonGenerator/JsonArrayBase.h
+++ b/JsonGenerator/JsonArrayBase.h
@ -5,13 +5,13 @@

 #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)
@ -39,7 +39,7 @@ namespace ArduinoJson

            virtual size_t printTo(Print& p) const;

-            using JsonObjectBase::printTo;
+            using JsonPrintable::printTo;

        private:
            Internals::JsonValue* items;
--- a/JsonGenerator/JsonGenerator.vcxproj
+++ b/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>
--- a/JsonGenerator/JsonGenerator.vcxproj.filters
+++ b/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>
--- a/JsonGenerator/JsonHashTable.h
+++ b/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];     
-        };
-    }
-}
--- a/JsonGenerator/JsonHashTableBase.h
+++ b/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;
-        };
-    }
-}
--- a/JsonGenerator/JsonObject.h
+++ b/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>
+        {            
+        };
+    }
+}
--- a/JsonGenerator/JsonHashTableBase.cpp
+++ b/JsonGenerator/JsonHashTableBase.cpp
@ -3,11 +3,11 @@
 * Benoit Blanchon 2014 - MIT License
 */

-#include "JsonHashTable.h"
+#include "JsonObjectBase.h"

 using namespace ArduinoJson::Generator;

-size_t JsonHashTableBase::printTo(Print& p) const
+size_t JsonObjectBase::printTo(Print& p) const
 {
    size_t n = 0;

--- a/JsonGenerator/JsonObjectBase.h
+++ b/JsonGenerator/JsonObjectBase.h
@ -1,31 +1,61 @@
 /*
- * Arduino JSON library
- * Benoit Blanchon 2014 - MIT License
- */
+* Arduino JSON library
+* Benoit Blanchon 2014 - MIT License
+*/

 #pragma once

-#include "JsonValue.h"
-#include "Print.h"
-#include "Printable.h"
+#include "JsonPrintable.h"
+#include "EscapedString.h"

 namespace ArduinoJson
 {
    namespace Generator
    {
-        class JsonObjectBase : public Printable
+        class JsonObjectBase : public JsonPrintable
        {
        public:

-            size_t printTo(char* buffer, size_t bufferSize)
+            template<typename T>
+            void add(const char* key, T value)
            {
-                using namespace Internals;
+                if (count >= capacity) return;

-                StringBuilder sb(buffer, bufferSize);
-                return printTo(sb);
+                items[count].key.set(key);
+                items[count].value.set(value);
+                count++;
            }

-            virtual size_t printTo(Print& p) const = 0;
+            template<int DIGITS>
+            void add(const char* key, double value)
+            {
+                if (count >= capacity) return;
+
+                items[count].key.set(key);
+                items[count].value.set<DIGITS>(value);
+                count++;
+            }
+
+            using JsonPrintable::printTo;
+
+            virtual size_t printTo(Print& p) const;
+
+        protected:
+
+            struct KeyValuePair
+            {
+                Internals::EscapedString  key;
+                Internals::JsonValue      value;
+            };
+
+            JsonObjectBase(KeyValuePair* items, int capacity)
+                : items(items), capacity(capacity), count(0)
+            {
+            }
+
+        private:
+            KeyValuePair* items;
+            int capacity, count;
        };
    }
 }
--- a/JsonGenerator/JsonPrintable.h
+++ b/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;
+        };
+    }
+}
--- a/JsonGenerator/JsonValue.h
+++ b/JsonGenerator/JsonValue.h
@ -16,14 +16,14 @@ namespace ArduinoJson
        class JsonValue
        {
        public:
-            
+
            void set(bool value)
            {
                printToImpl = &printBoolTo;
                content.asBool = value;
            }

-            void set(long value)               
+            void set(long value)
            {
                printToImpl = &printLongTo;
                content.asLong = value;
@ -52,7 +52,7 @@ namespace ArduinoJson
                set<2>(value);
            }

-            template<int DIGITS>
+            template <int DIGITS>
            void set(double value)
            {
                printToImpl = &printDoubleTo<DIGITS>;
@ -68,23 +68,23 @@ namespace ArduinoJson
        private:
            union Content
            {
-                bool          asBool;
-                long          asLong;
-                Printable*    asPrintable;
+                bool asBool;
+                long asLong;
+                Printable* asPrintable;
                EscapedString asString;
-                double        asDouble;
+                double asDouble;
            };

            Content content;

-            size_t(*printToImpl)(const Content&, Print&);
+            size_t(* printToImpl)(const Content&, Print&);

            static size_t printBoolTo(const Content&, Print&);
            static size_t printLongTo(const Content&, Print&);
            static size_t printPrintableTo(const Content&, Print&);
            static size_t printStringTo(const Content&, Print&);

-            template<int DIGITS>
+            template <int DIGITS>
            static size_t printDoubleTo(const Content& c, Print& p)
            {
                return p.print(c.asDouble, DIGITS);
--- a/JsonGeneratorTests/Print.cpp
+++ b/JsonGeneratorTests/Print.cpp
--- a/JsonGenerator/README.md
+++ b/JsonGenerator/README.md
@ -15,7 +15,7 @@ Features
 * Elegant API, very easy to use 
 * Fixed memory allocation (no malloc)
 * Small footprint
-* Implements Arduino's Printable interface
+* Implements Arduino's `Printable interface
 * MIT License


@ -26,7 +26,7 @@ Example
    array.add<6>(48.756080);
    array.add<6>(2.302038);

-    JsonHashTable<3> root;
+    JsonObject<3> root;
    root.add("sensor", "gps");
    root.add("time", 1351824120);
    root.add("data", array);
@ -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:

@ -91,22 +98,22 @@ Finally you can add nested object to the array:

 or

-    JsonHashTable<8> nestedHash;
-    array.add(nestedHash);
+    JsonObject<8> nestedObject;
+    array.add(nestedObject);

-#### Hash-table
+#### JSON Object

-You create a hash-table with the following line:
+You create a JSON object (ie hash-table/dictionary) with the following line:

-    JsonHashTable<8> hash;
+    JsonObject<8> object;

-Like with the array class, there is a template parameter that gives the capacity of the hash-table.
+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!");
-    hash.add("key2", 42);
-    hash.add("key3", true);
+    object.add("key1", "bazinga!");
+    object.add("key2", 42);
+    object.add("key3", true);

 As for the arrays, there are two syntaxes for the floating point values:

@ -116,12 +123,12 @@ As for the arrays, there are two syntaxes for the floating point values:
 Finally you can add nested objects:

    JsonArray<8> nestedArray;
-    hash.add("key6", nestedArray);
+    object.add("key6", nestedArray);

 or

-    JsonHashTable<8> nestedHash;
-    hash.add("key7", nestedHash);
+    JsonObject<8> nestedObject;
+    object.add("key7", nestedObject);

 ### 4. Get the JSON string

@ -133,7 +140,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 +156,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 +168,35 @@ Here are the size of the main classes of the library.

 This table is for an 8-bit Arduino, types would be bigger on a 32-bit processor.

-| Type                   | Size in bytes |
-| ---------------------- | ------------- |
-| JsonArray&lt;N&gt;     | 8 + 6 x N     |
-| JsonHashTable&lt;N&gt; | 8 + 8 x N     |
+| Type                | Size in bytes |
+| --------------------| ------------- |
+| JsonArray&lt;N&gt;  | 8 + 6 x N     |
+| JsonObject&lt;N&gt; | 8 + 8 x N     |
+
+
+Code size
+---------
+
+### Minimum setup
+
+| Function                     | Size |
+| ---------------------------- | ---- |
+| `JsonObjectBase::printTo()`  | 222  |
+| `EscapedString::printTo()`   | 202  |
+| `JsonArrayBase::printTo()`   | 164  |
+| `Print::print(char const*)`  | 146  |
+| `JsonValue::printStringTo()` | 6    |
+
+### Additional space for integers
+
+| Function                     | Size |
+| ---------------------------- | ---- |
+| `Print::print(long, int)`    | 328  |
+| `JsonValue::printLongTo()`   | 22   |
+
+### Additional space for floating point
+
+| Function                       | Size |
+| ------------------------------ | ---- |
+| `Print::print(double, int)`    | 1548 |
+| `JsonValue::printDouleTo<2>()` | 22   |
--- a/JsonGeneratorTests/JsonArrayTests.cpp
+++ b/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;
@ -146,9 +146,9 @@ namespace JsonGeneratorTests

    private:

-        void addNested(JsonObjectBase& value)
+        void addNested(Printable& value)
        {
-            arr.add<JsonObjectBase&>(value);
+            arr.add<Printable&>(value);
        }

        template<typename T>
--- a/JsonGeneratorTests/JsonGeneratorTests.vcxproj
+++ b/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,16 @@
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
-    <ClCompile Include="..\JsonGenerator\EscapedString.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonArrayBase.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonHashTableBase.cpp" />
-    <ClCompile Include="..\JsonGenerator\JsonValue.cpp" />
-    <ClCompile Include="..\JsonGenerator\StringBuilder.cpp" />
    <ClCompile Include="EscapedStringTests.cpp" />
    <ClCompile Include="JsonArrayTests.cpp" />
    <ClCompile Include="JsonHashTableTests.cpp" />
    <ClCompile Include="JsonValueTests.cpp" />
-    <ClCompile Include="Print.cpp" />
    <ClCompile Include="StringBuilderTests.cpp" />
  </ItemGroup>
  <ItemGroup>
-    <ClInclude Include="..\JsonGenerator\EscapedString.h" />
-    <ClInclude Include="..\JsonGenerator\JsonArray.h" />
-    <ClInclude Include="..\JsonGenerator\JsonArrayBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonHashTable.h" />
-    <ClInclude Include="..\JsonGenerator\JsonHashTableBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonObjectBase.h" />
-    <ClInclude Include="..\JsonGenerator\JsonValue.h" />
-    <ClInclude Include="..\JsonGenerator\Print.h" />
-    <ClInclude Include="..\JsonGenerator\Printable.h" />
-    <ClInclude Include="..\JsonGenerator\StringBuilder.h" />
+    <ProjectReference Include="..\JsonGenerator\JsonGenerator.vcxproj">
+      <Project>{c6536d27-738d-4ceb-a2bc-e13c8897d894}</Project>
+    </ProjectReference>
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
--- a/JsonGeneratorTests/JsonGeneratorTests.vcxproj.filters
+++ b/JsonGeneratorTests/JsonGeneratorTests.vcxproj.filters
@ -24,61 +24,11 @@
    <ClCompile Include="JsonValueTests.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonValue.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\StringBuilder.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="StringBuilderTests.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="Print.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\EscapedString.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonHashTableBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\JsonGenerator\JsonArrayBase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="EscapedStringTests.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\JsonGenerator\JsonArray.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonHashTable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonObjectBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonValue.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\Print.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\Printable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\StringBuilder.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\EscapedString.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonHashTableBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\JsonGenerator\JsonArrayBase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
 </Project>
--- a/JsonGeneratorTests/JsonHashTableTests.cpp
+++ b/JsonGeneratorTests/JsonHashTableTests.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;
@ -97,9 +97,9 @@ namespace JsonGeneratorTests

    private:
        
-        void addNested(const char* key, JsonObjectBase& value)
+        void addNested(const char* key, Printable& value)
        {
-            hash.add<JsonObjectBase&>(key, value);
+            hash.add<Printable&>(key, value);
        }

        template<typename T>
--- a/JsonParser.cpp
+++ b/JsonParser.cpp
@ -1,12 +1,13 @@
 /*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
+ * Arduino JSON library
+ * Benoit Blanchon 2014 - MIT License
+ */

 // This file is here to help the Arduino IDE find the .cpp files

 #include "JsonParser/JsonArray.cpp"
-#include "JsonParser/JsonHashTable.cpp"
-#include "JsonParser/JsonObjectBase.cpp"
+#include "JsonParser/JsonObject.cpp"
 #include "JsonParser/JsonParserBase.cpp"
+#include "JsonParser/JsonValue.cpp"
+#include "JsonParser/JsonToken.cpp"
 #include "JsonParser/jsmn.cpp"
--- a/JsonParser/JsonArray.cpp
+++ b/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)
-: JsonObjectBase(json, tokens)
+DEPRECATED JsonObject JsonArray::getHashTable(int index)
 {
-	if (tokens == 0 || tokens[0].type != JSMN_ARRAY)
-		makeInvalid();
-}
-
-
-/*
-* Returns the token for the value at the specified index
-*/
-jsmntok_t* JsonArray::getToken(int index)
-{
-	// sanity check
-	if (json == 0 || tokens == 0 || index < 0 || index >= tokens[0].size)
-		return 0;
-
-	// skip first token, it's the whole object
-	jsmntok_t* currentToken = tokens + 1;
-
-	// skip all tokens before the specified index
-	for (int i = 0; i < index; i++)
-	{
-		// move forward: current + nested tokens
-		currentToken += 1 + getNestedTokenCount(currentToken);
-	}
-
-	return currentToken;
-}
-
-JsonArray JsonArray::getArray(int index)
-{
-	return JsonArray(json, getToken(index));
-}
-
-bool JsonArray::getBool(int index)
-{
-	return getBoolFromToken(getToken(index));
-}
-
-double JsonArray::getDouble(int index)
-{
-	return getDoubleFromToken(getToken(index));
-}
-
-JsonHashTable JsonArray::getHashTable(int index)
-{
-	return JsonHashTable(json, getToken(index));
-}
-
-long JsonArray::getLong(int index)
-{
-	return getLongFromToken(getToken(index));
-}
-
-char* JsonArray::getString(int index)
-{
-	return getStringFromToken(getToken(index));
+    return operator[](index);
 }
--- a/JsonParser/JsonArray.h
+++ b/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 JsonArray : public JsonObjectBase
-        {
-            friend class JsonParserBase;
-            friend class JsonHashTable;
-
+        class JsonObject;
+                
+        // A JSON array
+        class JsonArray : JsonValue
+        {          
        public:

-            JsonArray()	{}
-
-            int getLength()
+            // Create an invalid array
+            JsonArray() 
+            {            
+            }
+
+            // 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);
-            bool getBool(int index);
-            double getDouble(int index);
-            JsonHashTable getHashTable(int index);
-            long getLong(int index);
-            char* getString(int index);
+            // Obsolete: Use operator[] instead
+            DEPRECATED bool getBool(int index)
+            {
+                return operator[](index);
+            }

-        private:
+            // Obsolete: Use operator[] instead
+            DEPRECATED double getDouble(int index)
+            {
+                return operator[](index);
+            }

-            JsonArray(char* json, jsmntok_t* tokens);
-            jsmntok_t* getToken(int index);
+            // Obsolete: Use operator[] instead
+            DEPRECATED JsonObject getHashTable(int index);
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED long getLong(int index)
+            {
+                return operator[](index);
+            }
+
+            // Obsolete: Use operator[] instead
+            DEPRECATED char* getString(int index)
+            {
+                return operator[](index);
+            }
        };
    }
 }
--- a/JsonParser/JsonArrayIterator.h
+++ b/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);
+            }
+        };
+    }
+}
--- a/JsonParser/JsonHashTable.cpp
+++ b/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));
-}
--- a/JsonParser/JsonHashTable.h
+++ b/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);
-        };
-    }
-}
--- a/JsonParser/JsonObject.cpp
+++ b/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);
+}
--- a/JsonParser/JsonObject.h
+++ b/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;
+    }
+}
--- a/JsonParser/JsonObjectBase.cpp
+++ b/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;
-}
--- a/JsonParser/JsonObjectBase.h
+++ b/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;
-        };
-    }
-}
--- a/JsonParser/JsonObjectIterator.h
+++ b/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();
+            }
+        };
+    }
+}
--- a/JsonParser/JsonPair.h
+++ b/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();
+            }
+        };
+    }
+}
--- a/JsonParser/JsonParser.h
+++ b/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.
-        *
-        * You need to specifiy the number of token to be allocated for that parser.
-        * Values from 16 to 32 are recommended.
-        * The parser size will be MAX_TOKEN*8 bytes.
-        * Don't forget that the memory size of standard Arduino board is only 2KB
-        *
-        * CAUTION: JsonArray and JsonHashTable contain pointers to tokens of the
-        * JsonParser, so they need the JsonParser to be in memory to work.
-        * As a result, you must not create JsonArray and JsonHashTable that have a
-        * longer life that the JsonParser.
-        */
+        // The JSON parser.
+        //
+        // You need to specifiy the number of token to be allocated for that parser.
+        //
+        // CAUTION: JsonArray, JsonObject and JsonValue contain pointers to tokens of the
+        // JsonParser, so they need the JsonParser to be in memory to work.
+        // As a result, you must not create JsonArray, JsonObject or JsonValue that have a
+        // longer life that the JsonParser.
        template <int MAX_TOKENS>
        class JsonParser : public JsonParserBase
        {
--- a/JsonParser/JsonParser.vcxproj
+++ b/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>
--- a/JsonParser/JsonParser.vcxproj.filters
+++ b/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>
--- a/JsonParser/JsonParserBase.cpp
+++ b/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);
 }
--- a/JsonParser/JsonParserBase.h
+++ b/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.
-            *
-            * The content of the string may be altered to add '\0' at the
-            * end of string tokens
-            */
-            JsonArray parseArray(char* json)
+            // Parse the JSON string and return a array
+            //
+            // The content of the string may be altered to add '\0' at the
+            // end of string tokens            
+            JsonValue parse(char* json);
+
+            // Obsolete: use parse() instead
+            DEPRECATED JsonArray parseArray(char* json)
            {
-                return JsonArray(json, parse(json));
+                return parse(json);
            }

-            /*
-            * Parse the JSON string and return a array.
-            *
-            * The content of the string may be altered to add '\0' at the
-            * end of string tokens
-            */
-            JsonHashTable parseHashTable(char* json)
+            // Obsolete: use parse() instead
+            DEPRECATED JsonObject parseHashTable(char* json)
            {
-                return JsonHashTable(json, parse(json));
+                return parse(json);
            }

        private:
            jsmntok_t* tokens;
            int maxTokens;
-
-            jsmntok_t* parse(char* json);
        };
    }
 }
--- a/JsonParser/JsonToken.cpp
+++ b/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);
+}
--- a/JsonParser/JsonToken.h
+++ b/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;
+        };
+    }
+}
--- a/JsonParser/JsonValue.cpp
+++ b/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();
+}
--- a/JsonParser/JsonValue.h
+++ b/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);
+        };
+    }
+}
--- a/JsonParser/README.md
+++ b/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.getString("sensor");
-
-    long time = root.getLong("time");
-    
-    JsonArray coords = root.getArray("data");
+    char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];


 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",
-        "Skills":[
-            "C",
-            "C++",
-            "C#"],
-        "Age":32,
-        "Online":true
+        "sensor":"gps",
+		"time":1351824120,
+		"data":[48.756080,2.302038]
    }

-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");
-
-    bool online = hashTable.getBool("Online");
+    for (JsonObjectIterator i=root.begin(); i!=root.end(); ++i)
+    {
+      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 = row0.getDouble(0);
-    
-or simply:
-
-    double a = root.getArray(0).getDouble(0);
+    double a = root[0][0];
+	double b = root[0][1];
+	double c = root[1][0];
+	double d = root[1][1];

+You can also iterate through the key-value pairs of the object:

+    for (JsonArrayIterator i=array.begin(); i!=array.end(); ++i)
+    {
+      Serial.println((char*)*i);
+    }
+	
 Common pitfalls
 ---------------

 ### 1. Not enough tokens

-By design, the library has no way to tell you why `JsonParser::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>
-    <tr>
-        <th>Type</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>Parser&lt;N&gt;</td>
-        <td>4 + 8 x N</td>
-    </tr>
-    <tr>
-        <td>JsonArray</td>
-        <td>4</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable</td>
-        <td>4</td>
-    </tr>
-</table> 
-
+| Type         | Size in bytes |
+| ------------ | ------------- |
+| `Parser<N>`  | 4 + 8 x N     |
+| `JsonArray`  | 4             |
+| `JsonObject` | 4             |
+| `JsonValue`  | 4             |

 Code size
 ---------

-Theses tables has been created by analyzing the map file generated by AVR-GCC after adding `-Wl,-Map,foo.map` to the command line.
-
-As you'll see the code size is between 1680 and 3528 bytes, depending on the features you use.
+The sizes have been obtained with Arduino IDE 1.0.5 for a Duemilanove.

 ### Minimum setup

-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strcmp(char*,char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>jsmn_init(jsmn_parser*)</td>
-        <td>20</td>
-    </tr>
-    <tr>
-        <td>jsmn_parse(jsmn_parser*, char const*, jsmntok_t*, unsigned int)</td>
-        <td>960</td>
-    </tr>
-    <tr>
-        <td>JsonParser::parse(char*)</td>
-        <td>106</td>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getNestedTokenCount(jsmntok_t*)</td>
-        <td>84</td>        
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getStringFromToken(jsmntok_t*)</td>
-        <td>68</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::JsonArray(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getToken(int)</td>
-        <td>112</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getString(int)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::JsonHashTable(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getToken(char*)</td>
-        <td>180</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getString(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>1680</td>
-    </tr>
-</table>
+| Function                             | Size |
+| ------------------------------------ | ---- |
+| `jsmn_parse()`                       | 962  |
+| `JsonValue::operator[](char const*)` | 218  | 
+| `JsonParserBase::parse()`            | 116  | 
+| `JsonValue::operator[](int)`         | 108  |
+| `strcmp()`                           | 18   | 

-### Additional space to parse nested  objects
+### Additional space for integers

-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonArray::getArray(int)</td>
-        <td>42</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getHashTable(int)</td>
-        <td>64</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getArray(char*)</td>
-        <td>64</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::getHashTable(char*)</td>
-        <td>42</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>212</td>
-    </tr>
-</table>
+| Function                     | Size |
+| ---------------------------- | ---- |
+| `strtol()`                   | 606  |
+| `JsonValue::operator long()` | 94   |

-### Additional space to parse `bool` values
+### Additional space for floating points

-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getBoolFromToken(jsmntok_t*)</td>
-        <td>82</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getBool(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getBool(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>130</td>
-    </tr>
-</table>
-
-### Additional space to parse `double` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtod(char*,int)</td>
-        <td>704</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getDoubleFromToken(jsmntok_t*)</td>
-        <td>44</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getDouble(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getDouble(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>796</td>
-    </tr>
-</table>
-
-### Additional space to parse `long` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtol(char*,char**,int)</td>
-        <td>606</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getLongFromToken(jsmntok_t*)</td>
-        <td>56</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getLong(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getLong(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>710</td>
-    </tr>
-</table>
+| Function                         | Size  |
+| -------------------------------- | ----- |
+| `strtod()`                       | 1369  |
+| `JsonValue::operator double()`   | 82    |
--- a/JsonParserTests/JsonArrayIteratorTests.cpp
+++ b/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);
+            }
+        }
+    };
+}
--- a/JsonParserTests/JsonObjectIteratorTests.cpp
+++ b/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++;
+            }
+        }
+    };
+}
--- a/JsonParserTests/JsonHashTableTests.cpp
+++ b/JsonParserTests/JsonHashTableTests.cpp
@ -1,40 +1,40 @@
 /*
 * Arduino JSON library
 * Benoit Blanchon 2014 - MIT License
-*/
-
-#include "CppUnitTest.h"
-#include "JsonParser.h"
-#include <string>
-
-using namespace std;
-using namespace Microsoft::VisualStudio::CppUnitTestFramework;
-using namespace ArduinoJson::Parser;
-
-namespace ArduinoJsonParserTests
-{		
-    TEST_CLASS(JsonHashTableTests)
-	{
-		JsonHashTable hashTable;
-        JsonArray nestedArray;
-		char json[256];
-        jsmntok_t tokens[32];
-        JsonParserBase parser = JsonParserBase(tokens, 32);
-
-	public:
-
+*/
+
+#include "CppUnitTest.h"
+#include "JsonParser.h"
+#include <string>
+
+using namespace std;
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ArduinoJson::Parser;
+
+namespace ArduinoJsonParserTests
+{
+    TEST_CLASS(JsonHashTableTests)
+    {
+        JsonHashTable hashTable;
+        JsonArray nestedArray;
+        char json[256];
+        jsmntok_t tokens[32];
+        JsonParserBase parser = JsonParserBase(tokens, 32);
+
+    public:
+
        TEST_METHOD(EmptyString)
        {
            whenInputIs("");
            parseMustFail();
-        }
-
+        }
+
        TEST_METHOD(EmptyHashTable)
        {
            whenInputIs("{}");
            parseMustSucceed();
-        }
-
+        }
+
        TEST_METHOD(NotEnoughTokens)
        {
            setTokenCountTo(2);
@ -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:
-
-        void setTokenCountTo(int n)
-        {
-            parser = JsonParserBase(tokens, n);
-        }
-
+        }
+
+    private:
+
+        void setTokenCountTo(int 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)
-        {
-            Assert::IsFalse(hashTable.containsKey(key));
-            Assert::IsFalse(hashTable.getHashTable(key).success());
-            Assert::IsFalse(hashTable.getArray(key).success());
-            Assert::IsFalse(hashTable.getBool(key));
-            Assert::AreEqual(0.0, hashTable.getDouble(key));
-            Assert::AreEqual(0L,  hashTable.getLong(key));
-            Assert::IsNull(hashTable.getString(key));
-        }
-
-        void itemMustBeAnArray(const char* key)
-        {
-            nestedArray = hashTable.getArray(key);
-            Assert::IsTrue(nestedArray.success());
-        }
-
-        void arrayLengthMustBe(int expected)
-        {
-            Assert::AreEqual(expected, nestedArray.getLength());
-        }
-
-        void arrayItemMustBe(int index, long expected)
-        {
-            Assert::AreEqual(expected, nestedArray.getLong(index));
-        }
-	};
+        }
+
+        void itemMustNotExist(const char* key)
+        {
+            Assert::IsFalse(hashTable.containsKey(key));
+            Assert::IsFalse(hashTable.getHashTable(key).success());
+            Assert::IsFalse(hashTable.getArray(key).success());
+            Assert::IsFalse(hashTable.getBool(key));
+            Assert::AreEqual(0.0, hashTable.getDouble(key));
+            Assert::AreEqual(0L, hashTable.getLong(key));
+            Assert::IsNull(hashTable.getString(key));
+        }
+
+        void itemMustBeAnArray(const char* key)
+        {
+            nestedArray = hashTable.getArray(key);
+            Assert::IsTrue(nestedArray.success());
+        }
+
+        void arrayLengthMustBe(int expected)
+        {
+            Assert::AreEqual(expected, nestedArray.getLength());
+        }
+
+        void arrayItemMustBe(int index, long expected)
+        {
+            Assert::AreEqual(expected, nestedArray.getLong(index));
+        }
+    };
 }
--- a/JsonParserTests/JsonParserTests.vcxproj
+++ b/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="..\JsonParser\JsonArray.cpp" />
-    <ClCompile Include="..\JsonParser\JsonHashTable.cpp" />
-    <ClCompile Include="..\JsonParser\JsonObjectBase.cpp" />
-    <ClCompile Include="..\JsonParser\JsonParserBase.cpp" />
+    <ClCompile Include="JsonObjectIteratorTests.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" />
-    <ClInclude Include="..\JsonParser\JsonArray.h" />
-    <ClInclude Include="..\JsonParser\JsonHashTable.h" />
-    <ClInclude Include="..\JsonParser\JsonObjectBase.h" />
-    <ClInclude Include="..\JsonParser\JsonParser.h" />
-    <ClInclude Include="..\JsonParser\JsonParserBase.h" />
+    <ProjectReference Include="..\JsonParser\JsonParser.vcxproj">
+      <Project>{c15274de-2695-4dfe-8520-4424223fe6da}</Project>
+    </ProjectReference>
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
--- a/JsonParserTests/JsonParserTests.vcxproj.filters
+++ b/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>
--- a/README.md
+++ b/README.md
@ -1,7 +1,7 @@
 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).

@ -22,9 +22,9 @@ Feature comparison

 | Library      | Memory allocation | Nested objects | Parser size | Encoder size  |
 | ------------ | ----------------- | -------------- | ----------- | ------------- |
-| Arduino JSON | static            | yes            | 2616 Bytes  | 628 bytes     |
-| json-arduino | dynamic           | no             | 3348 (+28%) | not supported |
-| aJson        | dynamic           | yes            | 5088 (+94%) | 4678 (+640%)  |
+| Arduino JSON | static            | yes            | 2642 Bytes  | 628 bytes     |
+| json-arduino | dynamic           | no             | 3348 (+27%) | not supported |
+| aJson        | dynamic           | yes            | 5088 (+93%) | 4678 (+640%)  |

 "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/)
-* [Blog post on the motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
+* [The project I originally wrote this library for](http://blog.benoitblanchon.fr/rfid-payment-terminal/)
+* [Motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
+* [Release of version 2](http://blog.benoitblanchon.fr/arduino-json-v2-0/)
+* [Release of version 3](http://blog.benoitblanchon.fr/arduino-json-v3-0/)
--- a/examples/JsonGeneratorExample/JsonGeneratorExample.ino
+++ b/examples/JsonGeneratorExample/JsonGeneratorExample.ino
@ -15,7 +15,7 @@ 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.add("time", 1351824120);
    root.add("data", array);
--- a/examples/JsonParserExample/JsonParserExample.ino
+++ b/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");
-    Serial.println(sensor);
+    char*  sensor    = root["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);
-    
-    JsonArray coords = root.getArray("data");
-    
-    for (int i = 0; i < coords.getLength(); i++)
-    {
-        double value = coords.getDouble(i);
-        Serial.println(value, 6);
-    }
+    Serial.println(latitude, 6);
+    Serial.println(longitude, 6);
 }

 void loop()
--- a/keywords.txt
+++ b/keywords.txt
@ -1,10 +1,6 @@
 JsonParser	KEYWORD1
 JsonArray	KEYWORD1
-JsonHashTable	KEYWORD1
-getArray	KEYWORD2
-getBool	KEYWORD2
-getDouble	KEYWORD2
-getHashTableKEYWORD2
-getLong	KEYWORD2
-parseArray	KEYWORD2
-parseHashTable	KEYWORD2
+JsonObject	KEYWORD1
+add	KEYWORD2
+parse	KEYWORD2
+success	KEYWORD2
Author	SHA1	Message	Date
Benoit Blanchon	68a2ca905e	Updated README.md	2014-07-23 20:18:59 +02:00
Benoît Blanchon	7e4ab9f31c	Added code size	2014-07-23 13:45:07 +02:00
Benoît Blanchon	44e5549456	Added code size	2014-07-23 13:29:56 +02:00
Benoît Blanchon	3e36831cdc	Updated README.md	2014-07-23 12:56:42 +02:00
Benoît Blanchon	5129f3400c	Added key() and value() shortcuts	2014-07-23 12:56:29 +02:00
Benoît Blanchon	0449ee4fd3	Updated README.md	2014-07-23 12:14:59 +02:00
Benoit Blanchon	6e4eb45210	Renamed JsonHashTable into JsonObject	2014-07-22 21:02:16 +02:00
Benoit Blanchon	abef85218e	Renamed ARDUINO_JSON_NO_DEPRECATED_WARNING into ARDUINO_JSON_NO_DEPRECATION_WARNING	2014-07-22 20:33:17 +02:00
Benoit Blanchon	649f292ea7	Added comments	2014-07-22 20:28:59 +02:00
Benoit Blanchon	805c0741e6	Added comments	2014-07-22 20:14:25 +02:00
Benoit Blanchon	0fc54ba54c	Added comments	2014-07-21 20:38:08 +02:00
Benoit Blanchon	df72419f09	Added comments	2014-07-21 15:20:02 +02:00
Benoit Blanchon	d3d0da2d7f	Added comments	2014-07-21 14:17:27 +02:00
Benoit Blanchon	407d536e06	Added comments	2014-07-21 14:14:31 +02:00
Benoit Blanchon	c22473cf37	Removed unused stuff	2014-07-21 11:08:39 +02:00
Benoit Blanchon	3e8861b1a0	Moved implemntation of operator[] into JsonObject	2014-07-21 10:52:35 +02:00
Benoit Blanchon	f565a9b1b7	Created a Visual Studio project for JsonGenerator	2014-07-21 09:59:47 +02:00
Benoit Blanchon	06026cc7d4	Created a Visual Studio project for JsonParser	2014-07-21 09:54:26 +02:00
Benoit Blanchon	04f52733c2	Added a test with 3 strings	2014-07-19 16:15:57 +02:00
Benoit Blanchon	c06f42659a	Updated README.md	2014-07-19 16:05:42 +02:00
Benoit Blanchon	e619b8f5bd	Updated README.md	2014-07-19 15:57:03 +02:00
Benoit Blanchon	1e28217393	Merged parse() and parseToken()	2014-07-19 15:36:01 +02:00
Benoit Blanchon	a1e8c8800a	Removed uneeded cast operators	2014-07-19 15:34:44 +02:00
Benoit Blanchon	00ad540f4e	Updated CHANGELOG.md	2014-07-19 15:23:40 +02:00
Benoit Blanchon	cd7a7b1533	Fixed bug in JsonArray::begin() and end()	2014-07-19 14:55:16 +02:00
Benoit Blanchon	0fe77176e1	Fixed bug in JsonObject::begin() and end()	2014-07-19 14:49:59 +02:00
Benoit Blanchon	e94575b4b8	Replaced public inheritance by protected and private	2014-07-19 14:41:29 +02:00
Benoit Blanchon	b278d7711b	Replaced composition by inheritance	2014-07-19 12:44:27 +02:00
Benoit Blanchon	851d21e08c	Added JsonObjectIterator	2014-07-18 22:40:50 +02:00
Benoit Blanchon	b75d32e980	Renamed JsonHashTable into JsonObject	2014-07-18 16:46:01 +02:00
Benoit Blanchon	daa62b3737	Simplified nextSibling()	2014-07-18 16:22:09 +02:00
Benoit Blanchon	ed497df9d6	Added JsonToken.cpp	2014-07-18 16:19:14 +02:00
Benoit Blanchon	79953730fc	Merged nestedTokenCount() and nextSibling()	2014-07-18 16:18:03 +02:00
Benoit Blanchon	5d2ffc49fd	Fixed JsonArrayIterator unit test	2014-07-18 16:11:21 +02:00
Benoit Blanchon	714a37bd59	Replaced JsonToken operators by meaningful methods	2014-07-18 15:54:49 +02:00
Benoit Blanchon	4a1d8483cc	Added class JsonToken	2014-07-18 15:43:20 +02:00
Benoît Blanchon	0d4d77a7cd	Updated example	2014-07-17 14:02:51 +02:00
Benoît Blanchon	c329572d24	Added JsonArrayIterator (tests are failing)	2014-07-17 13:58:30 +02:00
Benoît Blanchon	ca01ecfb49	Added a flag to ignore deprecation warnings	2014-07-17 13:27:40 +02:00
Benoît Blanchon	78249a0ada	Updated example	2014-07-17 13:23:32 +02:00
Benoît Blanchon	45c9ba1191	Renamed JsonObjectBase into JsonPrintable	2014-07-17 13:16:14 +02:00
Benoît Blanchon	5e1697f47b	JsonArray is now a simple wrapper on top of JsonValue	2014-07-17 13:12:12 +02:00
Benoît Blanchon	f2579397d6	JsonHashTable is now a wrapper on to of JsonValue	2014-07-17 12:59:26 +02:00
Benoît Blanchon	b6e3a37ad9	Added JsonParserBase::parse() that returns a JsonValue	2014-07-17 12:37:35 +02:00
Benoit Blanchon	73eda08dd4	Updated example	2014-07-16 21:10:18 +02:00
Benoît Blanchon	6164328892	Renamed JsonArray::getLength() into size() to match std::vector	2014-07-16 14:01:04 +02:00
Benoît Blanchon	7487b8cbb7	Defined the DEPRECATED macro	2014-07-16 13:53:56 +02:00
Benoît Blanchon	6a868e46bd	Made JsonValue inherit from JsonObjectBase	2014-07-16 13:42:36 +02:00
Benoît Blanchon	d189bd7140	Added class JsonValue. Added subscript operator on JsonArray and JsonHashTable	2014-07-16 13:26:11 +02:00