Fixed namespaces

include/ArduinoJson/Internals/CompactJsonWriter.h

@@ -2,42 +2,47 @@
 
 #include "ArduinoJson/Internals/JsonWriter.h"
 
-class CompactJsonWriter : public JsonWriter
+namespace ArduinoJson
 {
-public:
+    namespace Internals
-    explicit CompactJsonWriter(Print* sink)
-        : JsonWriter(sink)
     {
-    }
+        class CompactJsonWriter : public JsonWriter
+        {
+        public:
+            explicit CompactJsonWriter(Print* sink)
+            : JsonWriter(sink)
+            {
+            }
 
-    virtual void beginArray()
+            virtual void beginArray()
-    {
+            {
-        _length += _sink->write('[');
+                _length += _sink->write('[');
-    }
+            }
 
-    virtual void endArray()
+            virtual void endArray()
-    {
+            {
-        _length += _sink->write(']');
+                _length += _sink->write(']');
-    }
+            }
 
-    virtual void writeColon()
+            virtual void writeColon()
-    {
+            {
-        _length += _sink->write(':');
+                _length += _sink->write(':');
-    }
+            }
 
-    virtual void writeComma()
+            virtual void writeComma()
-    {
+            {
-        _length += _sink->write(',');
+                _length += _sink->write(',');
-    }
+            }
 
-    virtual void beginObject()
+            virtual void beginObject()
-    {
+            {
-        _length += _sink->write('{');
+                _length += _sink->write('{');
-    }
+            }
 
-    virtual void endObject()
+            virtual void endObject()
-    {
+            {
-        _length += _sink->write('}');
+                _length += _sink->write('}');
+            }
+        };       
     }
-};
+}
-

include/ArduinoJson/Internals/IndentedPrint.h

@@ -9,7 +9,7 @@
 
 namespace ArduinoJson
 {
-    namespace Generator
+    namespace Internals
     {
         // Decorator on top of Print to allow indented output.
         // This class is used by JsonPrintable::prettyPrintTo() but can also be used

include/ArduinoJson/Internals/JsonNode.h

@@ -1,181 +1,188 @@
 #pragma once
 
-class JsonBuffer;
+namespace ArduinoJson
-class JsonWriter;
-class JsonNodeIterator;
-
-class JsonNode
 {
-    friend class JsonNodeIterator;
+    class JsonBuffer;
-
-    enum JsonNodeType
-    {
-        JSON_UNDEFINED,
-        JSON_NULL,
-        JSON_ARRAY,
-        JSON_OBJECT,
-        JSON_KEY_VALUE,
-        JSON_BOOLEAN,
-        JSON_STRING,
-        JSON_LONG,
-        JSON_PROXY,
-        JSON_DOUBLE_0_DECIMALS,
-        JSON_DOUBLE_1_DECIMAL,
-        JSON_DOUBLE_2_DECIMALS,
-        // etc.
-    };
-
-    union JsonNodeContent
-    {
-        bool asBoolean;
-        double asDouble;
-        long asInteger;
-        const char* asString;
-
-        struct
-        {
-            const char* key;
-            JsonNode* value;
-        } asKey;
-
-        struct
-        {
-            JsonNode* child;
-            JsonBuffer* buffer;
-        } asContainer;
-
-        struct
-        {
-            JsonNode* target;
-        } asProxy;
-
-    };
-
-public:
-    JsonNode()
-        : type(JSON_UNDEFINED), next(0)
-    {
-        
-    }
     
-    void writeTo(JsonWriter&); // TODO: <- move in JsonNodeSerializer
+    namespace Internals
-
-    void setAsArray(JsonBuffer* buffer)
     {
-        type = JSON_ARRAY;
+        class JsonWriter;
-        content.asContainer.child = 0;
+        class JsonNodeIterator;
-        content.asContainer.buffer = buffer;
+
+        class JsonNode
+        {
+            friend class JsonNodeIterator;
+
+            enum JsonNodeType
+            {
+                JSON_UNDEFINED,
+                JSON_NULL,
+                JSON_ARRAY,
+                JSON_OBJECT,
+                JSON_KEY_VALUE,
+                JSON_BOOLEAN,
+                JSON_STRING,
+                JSON_LONG,
+                JSON_PROXY,
+                JSON_DOUBLE_0_DECIMALS,
+                JSON_DOUBLE_1_DECIMAL,
+                JSON_DOUBLE_2_DECIMALS,
+                // etc.
+            };
+
+            union JsonNodeContent
+            {
+                bool asBoolean;
+                double asDouble;
+                long asInteger;
+                const char* asString;
+
+                struct
+                {
+                    const char* key;
+                    JsonNode* value;
+                } asKey;
+
+                struct
+                {
+                    JsonNode* child;
+                    JsonBuffer* buffer;
+                } asContainer;
+
+                struct
+                {
+                    JsonNode* target;
+                } asProxy;
+
+            };
+
+        public:
+            JsonNode()
+            : type(JSON_UNDEFINED), next(0)
+            {
+
+            }
+
+            void writeTo(JsonWriter&); // TODO: <- move in JsonNodeSerializer
+
+            void setAsArray(JsonBuffer* buffer)
+            {
+                type = JSON_ARRAY;
+                content.asContainer.child = 0;
+                content.asContainer.buffer = buffer;
+            }
+
+            void setAsBoolean(bool value)
+            {
+                type = JSON_BOOLEAN;
+                content.asBoolean = value;
+            }
+
+            void setAsLong(int value)
+            {
+                type = JSON_LONG;
+                content.asInteger = value;
+            }
+
+            void setAsString(char const* value)
+            {
+                type = JSON_STRING;
+                content.asString = value;
+            }
+
+            void setAsDouble(double value, int decimals)
+            {
+                type = static_cast<JsonNodeType>(JSON_DOUBLE_0_DECIMALS + decimals);
+                content.asDouble = value;
+            }
+
+            void setAsObject(JsonBuffer* buffer)
+            {
+                type = JSON_OBJECT;
+                content.asContainer.child = 0;
+                content.asContainer.buffer = buffer;
+            }
+
+            void setAsObjectKeyValue(const char* key, JsonNode* value)
+            {
+                type = JSON_KEY_VALUE;
+                content.asKey.key = key;
+                content.asKey.value = value;
+            }
+
+            bool getAsBoolean()
+            {
+                return type == JSON_BOOLEAN ? content.asBoolean : false;
+            }
+
+            double getAsDouble()
+            {
+                return type >= JSON_DOUBLE_0_DECIMALS ? content.asDouble : 0;
+            }
+
+            long getAsInteger()
+            {
+                return type == JSON_LONG ? content.asInteger : 0;
+            }
+
+            const char* getAsString()
+            {
+                return type == JSON_STRING ? content.asString : 0;
+            }
+
+            JsonBuffer* getContainerBuffer()
+            {
+                if (type == JSON_PROXY) return content.asProxy.target->getContainerBuffer();
+                return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.buffer : 0;
+            }
+
+            JsonNode* getContainerChild()
+            {
+                if (type == JSON_PROXY) return content.asProxy.target->getContainerChild();
+                return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.child : 0;
+            }
+
+            const char* getAsObjectKey()
+            {
+                return type == JSON_KEY_VALUE ? content.asKey.key : 0;
+            }
+
+            JsonNode* getAsObjectValue()
+            {
+                return type == JSON_KEY_VALUE ? content.asKey.value : 0;
+            }
+
+            JsonNode* getProxyTarget()
+            {        
+                return type == JSON_PROXY ? content.asProxy.target : this;
+            }
+
+            bool isArray()
+            {
+                return type == JSON_ARRAY;
+            }
+
+            void addChild(JsonNode* childToAdd);
+
+            void removeChild(JsonNode* childToRemove);
+
+            void duplicate(JsonNode* other);
+
+        private:
+            JsonNodeType type;
+            JsonNode* next;
+            JsonNodeContent content;
+
+            inline void writeArrayTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
+            inline void writeObjectTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
+
+            void setAsProxyOfSelf();
+
+            void setAsProxyOf(JsonNode* target)
+            {
+                type = JSON_PROXY;
+                content.asProxy.target = target;
+            }
+        };
     }
-
+}
-    void setAsBoolean(bool value)
-    {
-        type = JSON_BOOLEAN;
-        content.asBoolean = value;
-    }
-
-    void setAsLong(int value)
-    {
-        type = JSON_LONG;
-        content.asInteger = value;
-    }
-
-    void setAsString(char const* value)
-    {
-        type = JSON_STRING;
-        content.asString = value;
-    }
-
-    void setAsDouble(double value, int decimals)
-    {
-        type = static_cast<JsonNodeType>(JSON_DOUBLE_0_DECIMALS + decimals);
-        content.asDouble = value;
-    }
-
-    void setAsObject(JsonBuffer* buffer)
-    {
-        type = JSON_OBJECT;
-        content.asContainer.child = 0;
-        content.asContainer.buffer = buffer;
-    }
-
-    void setAsObjectKeyValue(const char* key, JsonNode* value)
-    {
-        type = JSON_KEY_VALUE;
-        content.asKey.key = key;
-        content.asKey.value = value;
-    }
-
-    bool getAsBoolean()
-    {
-        return type == JSON_BOOLEAN ? content.asBoolean : false;
-    }
-
-    double getAsDouble()
-    {
-        return type >= JSON_DOUBLE_0_DECIMALS ? content.asDouble : 0;
-    }
-
-    long getAsInteger()
-    {
-        return type == JSON_LONG ? content.asInteger : 0;
-    }
-
-    const char* getAsString()
-    {
-        return type == JSON_STRING ? content.asString : 0;
-    }
-
-    JsonBuffer* getContainerBuffer()
-    {
-        if (type == JSON_PROXY) return content.asProxy.target->getContainerBuffer();
-        return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.buffer : 0;
-    }
-
-    JsonNode* getContainerChild()
-    {
-        if (type == JSON_PROXY) return content.asProxy.target->getContainerChild();
-        return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.child : 0;
-    }
-
-    const char* getAsObjectKey()
-    {
-        return type == JSON_KEY_VALUE ? content.asKey.key : 0;
-    }
-
-    JsonNode* getAsObjectValue()
-    {
-        return type == JSON_KEY_VALUE ? content.asKey.value : 0;
-    }
-
-    JsonNode* getProxyTarget()
-    {        
-        return type == JSON_PROXY ? content.asProxy.target : this;
-    }
-
-    bool isArray()
-    {
-        return type == JSON_ARRAY;
-    }
-
-    void addChild(JsonNode* childToAdd);
-
-    void removeChild(JsonNode* childToRemove);
-
-    void duplicate(JsonNode* other);
-
-private:
-    JsonNodeType type;
-    JsonNode* next;
-    JsonNodeContent content;
-
-    inline void writeArrayTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
-    inline void writeObjectTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
-
-    void setAsProxyOfSelf();
-
-    void setAsProxyOf(JsonNode* target)
-    {
-        type = JSON_PROXY;
-        content.asProxy.target = target;
-    }
-};

include/ArduinoJson/Internals/JsonNodeIterator.h

@@ -2,36 +2,41 @@
 
 #include "JsonNode.h"
 
-class JsonNodeIterator
+namespace ArduinoJson
 {
-public:
+    namespace Internals
-
-    explicit JsonNodeIterator(JsonNode* node)
-        : node(node)
     {
+        class JsonNodeIterator
+        {
+        public:
+
+            explicit JsonNodeIterator(JsonNode* node)
+            : node(node)
+            {
+            }
+
+            bool operator!= (const JsonNodeIterator& other) const
+            {
+                return node != other.node;
+            }
+
+            void operator++()
+            {
+                node = node->next;
+            }
+
+            JsonNode* operator*() const
+            {
+                return node;
+            }
+
+            JsonNode* operator->() const
+            {
+                return node;
+            }
+
+        private:
+            JsonNode* node;
+        };
     }
-
+}
-    bool operator!= (const JsonNodeIterator& other) const
-    {
-        return node != other.node;
-    }
-
-    void operator++()
-    {
-        node = node->next;
-    }
-
-    JsonNode* operator*() const
-    {
-        return node;
-    }
-
-    JsonNode* operator->() const
-    {
-        return node;
-    }
-
-private:
-    JsonNode* node;
-};
-

include/ArduinoJson/Internals/JsonNodeWrapper.h

@@ -1,37 +1,43 @@
 #pragma once
 
 #include "JsonNode.h"
-class JsonValue;
 
-class JsonNodeWrapper
+namespace ArduinoJson
 {
-    friend class JsonValue;
+    class JsonValue ;
-
+    
-public:
+    namespace Internals
-    JsonNodeWrapper()
-        : _node(0)
     {
-    }
+        class JsonNodeWrapper
-
-    explicit JsonNodeWrapper(JsonNode* node)
-        : _node(node)
-    {
-    }
-
-protected:
-
-    void duplicate(const JsonNodeWrapper& other)
-    {
-        if (!_node)
         {
-            _node = other._node;
+            friend class JsonValue;
-        }
+
-        else
+        public:
-        {
+            JsonNodeWrapper()
-            _node->duplicate(other._node);
+            : _node(0)
-        }
+            {
+            }
+
+            explicit JsonNodeWrapper(JsonNode* node)
+            : _node(node)
+            {
+            }
+
+        protected:
+
+            void duplicate(const JsonNodeWrapper& other)
+            {
+                if (!_node)
+                {
+                    _node = other._node;
+                }
+                else
+                {
+                    _node->duplicate(other._node);
+                }
+            }
+
+            JsonNode* _node;
+        };
     }
-
+}
-    JsonNode* _node;
-};
-

include/ArduinoJson/Internals/JsonParser.h

@@ -1,43 +1,50 @@
-#include "JsonNode.h"
-
 #pragma once
 
-class JsonNode;
+#include "JsonNode.h"
-class JsonBuffer;
 
-class JsonParser
+namespace ArduinoJson
 {
-public:
+    class JsonBuffer;
-    JsonParser(JsonBuffer* buffer, char* json)
+
-        : _buffer(buffer), _ptr(json)
+    namespace Internals
     {
+        class JsonNode;
 
+        class JsonParser
+        {
+        public:
+            JsonParser(JsonBuffer* buffer, char* json)
+            : _buffer(buffer), _ptr(json)
+            {
+
+            }
+
+            JsonNode* parseAnything();
+
+        private:
+            JsonBuffer* _buffer;
+            char* _ptr;
+
+            inline bool isArrayStart();
+            inline bool isArrayStop();
+            inline bool isBoolean();
+            inline bool isComma();
+            inline bool isDouble();
+            inline bool isEnd();
+            inline bool isLong();
+            inline bool isNull();
+            inline bool isSpace();
+
+            inline void skipOneChar();
+            inline void skipSpaces();
+
+            inline JsonNode* parseArray();
+            inline JsonNode* parseBoolean();
+            inline JsonNode* parseLong();
+            inline JsonNode* parseNull();
+            inline JsonNode* parseString();
+
+            JsonNode *parseDouble();
+        };
     }
-
+}
-    JsonNode* parseAnything();
-
-private:
-    JsonBuffer* _buffer;
-    char* _ptr;
-
-    inline bool isArrayStart();
-    inline bool isArrayStop();
-    inline bool isBoolean();
-    inline bool isComma();
-    inline bool isDouble();
-    inline bool isEnd();
-    inline bool isLong();
-    inline bool isNull();
-    inline bool isSpace();
-
-    inline void skipOneChar();
-    inline void skipSpaces();
-
-    inline JsonNode* parseArray();
-    inline JsonNode* parseBoolean();
-    inline JsonNode* parseLong();
-    inline JsonNode* parseNull();
-    inline JsonNode* parseString();
-
-    JsonNode *parseDouble();
-};

include/ArduinoJson/Internals/JsonWriter.h

@@ -2,48 +2,53 @@
 
 #include "../Arduino/Print.h"
 
-class JsonWriter
+namespace ArduinoJson
 {
-public:
+    namespace Internals
-    explicit JsonWriter(Print* sink)
-        : _sink(sink), _length(0)
     {
+        class JsonWriter
+        {
+        public:
+            explicit JsonWriter(Print* sink)
+            : _sink(sink), _length(0)
+            {
+            }
+
+            size_t bytesWritten()
+            {
+                return _length;
+            }
+
+            virtual void beginArray() = 0;
+
+            virtual void endArray() = 0;
+
+            virtual void beginObject() = 0;
+
+            virtual void endObject() = 0;
+
+            void writeString(const char* value);
+            void writeInteger(long value);
+            void writeBoolean(bool value);
+            void writeDouble(double value, int decimals);
+
+            virtual void writeColon() = 0;
+
+            virtual void writeComma() = 0;
+
+            void writeEmptyArray()
+            {
+                _length += _sink->print("[]");
+            }
+
+            void writeEmptyObject()
+            {
+                _length += _sink->print("{}");
+            }
+
+        protected:
+            Print* _sink;
+            size_t _length;
+        };
     }
-
+}
-    size_t bytesWritten()
-    {
-        return _length;
-    }
-
-    virtual void beginArray() = 0;
-
-    virtual void endArray() = 0;
-
-    virtual void beginObject() = 0;
-
-    virtual void endObject() = 0;
-
-    void writeString(const char* value);
-    void writeInteger(long value);
-    void writeBoolean(bool value);
-    void writeDouble(double value, int decimals);
-
-    virtual void writeColon() = 0;
-
-    virtual void writeComma() = 0;
-
-    void writeEmptyArray()
-    {
-        _length += _sink->print("[]");
-    }
-
-    void writeEmptyObject()
-    {
-        _length += _sink->print("{}");
-    }
-
-protected:
-    Print* _sink;
-    size_t _length;
-};
-

include/ArduinoJson/Internals/PrettyJsonWriter.h

@@ -3,63 +3,67 @@
 #include "JsonWriter.h"
 #include "IndentedPrint.h"
 
-using namespace ArduinoJson::Generator;
+namespace ArduinoJson
-
-class PrettyJsonWriter : public JsonWriter
 {
-public:
+    namespace Internals
-    explicit PrettyJsonWriter(IndentedPrint* sink)
-        : JsonWriter(sink), _indenter(sink)
     {
-    }
+        class PrettyJsonWriter : public JsonWriter
+        {
+        public:
+            explicit PrettyJsonWriter(IndentedPrint* sink)
+            : JsonWriter(sink), _indenter(sink)
+            {
+            }
 
-    virtual void beginArray()
+            virtual void beginArray()
-    {
+            {
-        _length += _sink->write('[');
+                _length += _sink->write('[');
-        indent();
+                indent();
-    }
+            }
 
-    virtual void endArray()
+            virtual void endArray()
-    {
+            {
-        unindent();
+                unindent();
-        _length += _sink->write(']');
+                _length += _sink->write(']');
-    }
+            }
 
-    virtual void writeColon()
+            virtual void writeColon()
-    {
+            {
-        _length += _sink->print(": ");
+                _length += _sink->print(": ");
-    }
+            }
 
-    virtual void writeComma()
+            virtual void writeComma()
-    {
+            {
-        _length += _sink->write(',');
+                _length += _sink->write(',');
-        _length += _indenter->println();
+                _length += _indenter->println();
-    }
+            }
 
-    virtual void beginObject()
+            virtual void beginObject()
-    {
+            {
-        _length += _sink->write('{');
+                _length += _sink->write('{');
-        indent();
+                indent();
-    }
+            }
 
-    virtual void endObject()
+            virtual void endObject()
-    {
+            {
-        unindent();
+                unindent();
-        _length += _sink->write('}');
+                _length += _sink->write('}');
-    }
+            }
 
-private:
+        private:
-    IndentedPrint* _indenter;
+            IndentedPrint* _indenter;
 
-    void indent()
+            void indent()
-    {
+            {
-        _indenter->indent();
+                _indenter->indent();
-        _length += _indenter->println();
+                _length += _indenter->println();
-    }
+            }
 
-    void unindent()
+            void unindent()
-    {
+            {
-        _length += _indenter->println();
+                _length += _indenter->println();
-        _indenter->unindent();
+                _indenter->unindent();
+            }
+        };
     }
-};
+}

include/ArduinoJson/JsonArray.h

@@ -2,33 +2,35 @@
 
 #include "JsonContainer.h"
 
-class JsonArray : public JsonContainer
+namespace ArduinoJson
 {
-public:
+    class JsonArray : public JsonContainer
-    JsonArray()
     {
-    }
+    public:
+        JsonArray()
+        {
+        }
 
-    explicit JsonArray(JsonNode* node)
+        explicit JsonArray(Internals::JsonNode* node)
-        : JsonContainer(node)
+            : JsonContainer(node)
-    {
+        {
-    }
+        }
 
-    JsonValue operator[](int index) const;
+        JsonValue operator[](int index) const;
 
-    void add(bool value);
+        void add(bool value);
-    void add(const char* value);
+        void add(const char* value);
-    void add(double value, int decimals=2);
+        void add(double value, int decimals=2);
-    void add(int value) { add((long) value); }
+        void add(int value) { add((long) value); }
-    void add(long value);
+        void add(long value);
-    void add(JsonContainer nestedArray); // TODO: should allow JsonValue too
+        void add(JsonContainer nestedArray); // TODO: should allow JsonValue too
 
-    JsonArray createNestedArray();
+        JsonArray createNestedArray();
-    JsonObject createNestedObject();
+        JsonObject createNestedObject();
-
-    bool success()
-    {
-        return _node && _node->isArray();
-    }
-};
 
+        bool success()
+        {
+            return _node && _node->isArray();
+        }
+    };
+}

include/ArduinoJson/JsonBuffer.h

@@ -3,43 +3,49 @@
 #include "JsonArray.h"
 #include "JsonObject.h"
 
-class JsonParser;
+namespace ArduinoJson
-
-class JsonBuffer
 {
-    friend class JsonContainer;
+    namespace Internals
-    friend class JsonNode;
-    friend class JsonParser;
-
-public:
-    virtual ~JsonBuffer() {};
-
-    JsonArray createArray()
     {
-        return JsonArray(createArrayNode());
+        class JsonParser;
     }
 
-    JsonObject createObject()
+    class JsonBuffer
     {
-        return JsonObject(createObjectNode());
+        friend class JsonContainer;
-    }
+        friend class Internals::JsonNode;
+        friend class Internals::JsonParser;
 
-    JsonValue createValue();
+    public:
+        virtual ~JsonBuffer() {};
 
-    JsonArray parseArray(char* json);
+        JsonArray createArray()
+        {
+            return JsonArray(createArrayNode());
+        }
 
-    JsonValue parseValue(char* json);
+        JsonObject createObject()
+        {
+            return JsonObject(createObjectNode());
+        }
 
-protected:
+        JsonValue createValue();
-    virtual void* allocateNode() = 0;
 
-private:
+        JsonArray parseArray(char* json);
-    JsonNode* createNode();
 
-    JsonNode* createArrayNode();
+        JsonValue parseValue(char* json);
-    JsonNode* createBoolNode(bool value);
+
-    JsonNode* createDoubleNode(double value, int decimals);
+    protected:
-    JsonNode* createLongNode(long value);
+        virtual void* allocateNode() = 0;
-    JsonNode* createObjectNode();
+
-    JsonNode* createStringNode(const char* value);
+    private:
-};
+        Internals::JsonNode* createNode();
+
+        Internals::JsonNode* createArrayNode();
+        Internals::JsonNode* createBoolNode(bool value);
+        Internals::JsonNode* createDoubleNode(double value, int decimals);
+        Internals::JsonNode* createLongNode(long value);
+        Internals::JsonNode* createObjectNode();
+        Internals::JsonNode* createStringNode(const char* value);
+    };
+}

include/ArduinoJson/JsonContainer.h

@@ -1,55 +1,54 @@
 #pragma once
 
-#include "ArduinoJson/Arduino/Printable.h"
+#include "Arduino/Printable.h"
-#include "ArduinoJson/Internals/JsonNodeIterator.h"
+#include "Internals/JsonNodeIterator.h"
-#include "ArduinoJson/Internals/JsonNode.h"
+#include "Internals/JsonNode.h"
-#include "ArduinoJson/Internals/IndentedPrint.h"
+#include "Internals/IndentedPrint.h"
-#include "ArduinoJson/Internals/JsonNodeWrapper.h"
+#include "Internals/JsonNodeWrapper.h"
 
-class JsonArray;
+namespace ArduinoJson
-class JsonObject;
-class JsonValue;
-
-class JsonContainer : public Printable, public JsonNodeWrapper
 {
-  // friend JsonValue;
+    class JsonArray;
-    friend class JsonArray;
+    class JsonObject;
+    class JsonValue;
 
-public:
+    class JsonContainer : public Printable, public Internals::JsonNodeWrapper
+    {
+        friend class JsonArray;
 
+    public:
+        JsonContainer() {}
 
-    JsonContainer() {}
+        explicit JsonContainer(Internals::JsonNode* node)
-
-    explicit JsonContainer(JsonNode* node)
         : JsonNodeWrapper(node)
-    {
+        {
-    }
+        }
 
-    size_t size() const;
+        size_t size() const;
-    
-    bool operator==(JsonContainer const& other) const;
 
-    size_t printTo(char* buffer, size_t bufferSize) const;
+        bool operator==(JsonContainer const& other) const;
-    virtual size_t printTo(Print& print) const;
 
-    size_t prettyPrintTo(char* buffer, size_t bufferSize) const;
+        size_t printTo(char* buffer, size_t bufferSize) const;
-    size_t prettyPrintTo(ArduinoJson::Generator::IndentedPrint& print) const;
+        virtual size_t printTo(Print& print) const;
-    size_t prettyPrintTo(Print& print) const;
 
-protected:
+        size_t prettyPrintTo(char* buffer, size_t bufferSize) const;
+        size_t prettyPrintTo(ArduinoJson::Internals::IndentedPrint& print) const;
+        size_t prettyPrintTo(Print& print) const;
 
-    JsonNodeIterator beginChildren() const
+    protected:
-    {
-        return JsonNodeIterator(_node ? _node->getContainerChild() : 0);
-    }
 
-    JsonNodeIterator endChildren() const
+        Internals::JsonNodeIterator beginChildren() const
-    {
+        {
-        return JsonNodeIterator(0);
+            return Internals::JsonNodeIterator(_node ? _node->getContainerChild() : 0);
-    }
+        }
 
-    void addChild(JsonNode*);
+        Internals::JsonNodeIterator endChildren() const
-    void removeChild(JsonNode*);
+        {
-    JsonNode* createNode();
+            return Internals::JsonNodeIterator(0);
-};
+        }
 
+        void addChild(Internals::JsonNode*);
+        void removeChild(Internals::JsonNode*);
+        Internals::JsonNode* createNode();
+    };
+}

include/ArduinoJson/JsonObject.h

@@ -2,25 +2,28 @@
 
 #include "JsonContainer.h"
 
-class JsonObject : public JsonContainer
+namespace ArduinoJson
 {
-public:
+    class JsonObject : public JsonContainer
-
-    JsonObject()
     {
-    }
+    public:
 
-    explicit JsonObject(JsonNode* node)
+        JsonObject()
-        : JsonContainer(node)
+        {
-    {
+        }
-    }
 
-    JsonValue operator[](const char* key);
+        explicit JsonObject(Internals::JsonNode* node)
-    void remove(const char* key);
+            : JsonContainer(node)
+        {
+        }
 
-    JsonArray createNestedArray(const char* key);
+        JsonValue operator[](const char* key);
-    JsonObject createNestedObject(const char* key);
+        void remove(const char* key);
 
-private:
+        JsonArray createNestedArray(const char* key);
-    JsonNode* getOrCreateNodeAt(const char* key);
+        JsonObject createNestedObject(const char* key);
-};
+
+    private:
+        Internals::JsonNode* getOrCreateNodeAt(const char* key);
+    };
+}

include/ArduinoJson/JsonValue.h

@@ -2,35 +2,38 @@
 
 #include "Internals/JsonNodeWrapper.h"
 
-class JsonArray;
+namespace ArduinoJson
-class JsonContainer;
-class JsonObject;
-
-class JsonValue : public JsonNodeWrapper
 {
-public:
+    class JsonArray;
+    class JsonContainer;
+    class JsonObject;
 
-    JsonValue() {}
+    class JsonValue : public Internals::JsonNodeWrapper
-
-    explicit JsonValue(JsonNode* node)
-        : JsonNodeWrapper(node)
     {
-    }
+    public:
 
-    void operator=(bool);
+        JsonValue() {}
-    void operator=(const char*);
+
-    void operator=(double x) { set(x, 2); }
+        explicit JsonValue(Internals::JsonNode* node)
-    void operator=(int);
+        : JsonNodeWrapper(node)
-    void operator=(const JsonValue& value) { duplicate(value); }
+        {
-    void operator=(const JsonNodeWrapper& object) { duplicate(object); }
+        }
+
+        void operator=(bool);
+        void operator=(const char*);
+        void operator=(double x) { set(x, 2); }
+        void operator=(int);
+        void operator=(const JsonValue& value) { duplicate(value); }
+        void operator=(const Internals::JsonNodeWrapper& object) { duplicate(object); }
         
-    operator bool() const;
+        operator bool() const;
-    operator const char*() const;
+        operator const char*() const;
-    operator double() const;
+        operator double() const;
-    operator long() const;
+        operator long() const;
-    operator int() const { return operator long(); }
+        operator int() const { return operator long(); }
-    operator JsonArray() const;
+        operator JsonArray() const;
-    operator JsonObject() const;
+        operator JsonObject() const;
 
-    void set(double value, int decimals);
+        void set(double value, int decimals);
-};
+    };
+}

include/ArduinoJson/StaticJsonBuffer.h

@@ -3,40 +3,42 @@
 #include "JsonBuffer.h"
 #include "JsonObject.h"
 
-template<int CAPACITY>
+namespace ArduinoJson
-class StaticJsonBuffer : public JsonBuffer
 {
-    friend class JsonObject;
+    template<int CAPACITY>
+    class StaticJsonBuffer : public JsonBuffer
+    {
+        friend class JsonObject;
 
-public:
+    public:
-    
+
-    explicit StaticJsonBuffer()
+        explicit StaticJsonBuffer()
         : _size(0)
-    {
+        {
-    }
+        }
 
-    virtual ~StaticJsonBuffer() {}
+        virtual ~StaticJsonBuffer() {}
 
-    int capacity()
+        int capacity()
-    {
+        {
-        return CAPACITY;
+            return CAPACITY;
-    }
+        }
 
-    int size()
+        int size()
-    {
+        {
-        return _size;
+            return _size;
-    }
+        }
 
-protected:
+    protected:
-    virtual void* allocateNode()
+        virtual void* allocateNode()
-    {
+        {
-        if (_size >= CAPACITY) return 0;
+            if (_size >= CAPACITY) return 0;
 
-        return &_buffer[_size++];
+            return &_buffer[_size++];
-    }
+        }
-
-private:
-    JsonNode _buffer[CAPACITY];
-    int _size;
-};
 
+    private:
+        Internals::JsonNode _buffer[CAPACITY];
+        int _size;
+    };
+}

src/Internals/IndentedPrint.cpp

@@ -1,6 +1,6 @@
 #include "ArduinoJson/Internals/IndentedPrint.h"
 
-using namespace ArduinoJson::Generator;
+using namespace ArduinoJson::Internals;
 
 void IndentedPrint::indent()
 {

src/Internals/JsonNode.cpp

@@ -5,6 +5,8 @@
 #include "ArduinoJson/JsonObject.h"
 #include "ArduinoJson/JsonBuffer.h"
 
+using namespace ArduinoJson::Internals;
+
 void JsonNode::writeTo(JsonWriter& writer)
 {
     switch (type)

src/JsonArray.cpp

@@ -2,6 +2,9 @@
 #include "ArduinoJson/JsonObject.h"
 #include "ArduinoJson/JsonValue.h"
 
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
 JsonValue JsonArray::operator[](int index) const
 {
     for (JsonNodeIterator it = beginChildren(); it != endChildren(); ++it)

src/JsonBuffer.cpp

@@ -6,6 +6,9 @@
 #include "ArduinoJson/Internals/JsonParser.h"
 #include "ArduinoJson/Internals/JsonNode.h"
 
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
 JsonValue JsonBuffer::createValue()
 {
     return JsonValue(createNode());

src/JsonContainer.cpp

@@ -5,6 +5,7 @@
 #include "ArduinoJson/Internals/CompactJsonWriter.h"
 #include "ArduinoJson/Internals/PrettyJsonWriter.h"
 
+using namespace ArduinoJson;
 using namespace ArduinoJson::Internals;
 
 size_t JsonContainer::printTo(char* buffer, size_t bufferSize) const

src/JsonObject.cpp

@@ -7,6 +7,7 @@
 #include "ArduinoJson/Internals/JsonNode.h"
 #include "ArduinoJson/Internals/StringBuilder.h"
 
+using namespace ArduinoJson;
 using namespace ArduinoJson::Internals;
 
 JsonValue JsonObject::operator[](char const* key)

src/JsonValue.cpp

@@ -4,6 +4,8 @@
 #include "ArduinoJson/JsonObject.h"
 #include "ArduinoJson/Internals/JsonNode.h"
 
+using namespace ArduinoJson;
+
 void JsonValue::operator=(bool value)
 {
     if (_node)

test/Issue10.cpp

@@ -4,7 +4,7 @@
 #include <ArduinoJson/JsonValue.h>
 #include <ArduinoJson/StaticJsonBuffer.h>
 
-using namespace ArduinoJson::Generator;
+using namespace ArduinoJson;
 
 struct Person 
 {

test/JsonArray_Container_Tests.cpp

@@ -2,6 +2,8 @@
 #include <ArduinoJson/StaticJsonBuffer.h>
 #include <ArduinoJson/JsonValue.h>
 
+using namespace ArduinoJson;
+
 class JsonArray_Container_Tests : public ::testing::Test
 {
 protected:

test/JsonArray_PrettyPrintTo_Tests.cpp

@@ -9,6 +9,8 @@
 #include <ArduinoJson/JsonValue.h>
 #include <ArduinoJson/StaticJsonBuffer.h>
 
+using namespace ArduinoJson;
+
 class JsonArray_PrettyPrintTo_Tests : public testing::Test
 {
 protected:

test/JsonArray_PrintTo_Tests.cpp

@@ -8,6 +8,8 @@
 #include <ArduinoJson/JsonObject.h>
 #include <ArduinoJson/StaticJsonBuffer.h>
 
+using namespace ArduinoJson;
+
 class JsonArray_PrintTo_Tests : public testing::Test 
 {
 protected:

test/JsonObject_Container_Tests.cpp

@@ -2,6 +2,8 @@
 #include <ArduinoJson/StaticJsonBuffer.h>
 #include <ArduinoJson/JsonValue.h>
 
+using namespace ArduinoJson;
+
 class JsonObject_Container_Tests : public ::testing::Test
 {
 protected:

test/JsonObject_PrettyPrintTo_Tests.cpp

@@ -8,6 +8,8 @@
 #include <ArduinoJson/JsonValue.h>
 #include <ArduinoJson/StaticJsonBuffer.h>
 
+using namespace ArduinoJson;
+
 class JsonObject_PrettyPrintTo_Tests : public testing::Test
 {
 protected:

test/JsonObject_Serialization_Tests.cpp

@@ -4,6 +4,8 @@
 #include <ArduinoJson/JsonValue.h>
 #include <ArduinoJson/StaticJsonBuffer.h>
 
+using namespace ArduinoJson;
+
 class JsonObject_Serialization_Tests : public testing::Test
 {
 protected:

test/JsonParser_Array_Tests.cpp

@@ -2,6 +2,8 @@
 #include <ArduinoJson/StaticJsonBuffer.h>
 #include <ArduinoJson/JsonValue.h>
 
+using namespace ArduinoJson;
+
 class JsonParser_Array_Tests : public testing::Test
 {
 protected:

test/JsonValueTests.cpp

@@ -2,6 +2,8 @@
 #include <ArduinoJson/StaticJsonBuffer.h>
 #include <ArduinoJson/JsonValue.h>
 
+using namespace ArduinoJson;
+
 class JsonValueTests : public ::testing::Test
 {
 protected:

test/StaticJsonBufferTests.cpp

@@ -2,6 +2,8 @@
 #include <ArduinoJson/StaticJsonBuffer.h>
 #include <ArduinoJson/JsonValue.h>
 
+using namespace ArduinoJson;
+
 TEST(StaticJsonBuffer, CapacityMatchTemplateParameter)
 {
     StaticJsonBuffer<42> json;