--- a/C++/modules/Json/Json.cpp	Fri Nov 06 15:09:00 2015 +0100
+++ b/C++/modules/Json/Json.cpp	Mon Nov 09 16:52:38 2015 +0100
@@ -45,14 +45,14 @@
 		return Value{json_boolean_value(v)};
 	}
 	if (json_is_object(v)) {
-		Object object;
+		Value object{Type::Object};
 
 		readObject(object, v);
 
 		return object;
 	}
 	if (json_is_array(v)) {
-		Array array;
+		Value array{Type::Array};
 
 		readArray(array, v);
 
@@ -68,7 +68,7 @@
 	json_t *value;
 
 	json_object_foreach(object, key, value) {
-		static_cast<Object &>(parent).insert(key, readValue(value));
+		parent.insert(key, readValue(value));
 	}
 }
 
@@ -78,7 +78,7 @@
 	json_t *value;
 
 	json_array_foreach(array, index, value) {
-		static_cast<Array &>(parent).append(readValue(value));
+		parent.append(readValue(value));
 	}
 }
 
@@ -95,10 +95,10 @@
 	Value value;
 
 	if (json_is_object(json)) {
-		value = Object{};
+		value = Value{Type::Object};
 		readObject(value, json);
 	} else {
-		value = Array{};
+		value = Value{Type::Array};
 		readArray(value, json);
 	}
 
@@ -109,6 +109,109 @@
 
 } // !namespace
 
+void Value::copy(const Value &other)
+{
+	switch (other.m_type) {
+	case Type::String:
+		new (&m_string) std::string();
+		m_string = std::move(other.m_string);
+		break;
+	case Type::Real:
+		m_number = other.m_number;
+		break;
+	case Type::Int:
+		m_integer = other.m_integer;
+		break;
+	case Type::Boolean:
+		m_boolean = other.m_boolean;
+		break;
+	case Type::Object:
+		new (&m_object) std::map<std::string, Value>();
+		m_object = std::move(other.m_object);
+		break;
+	case Type::Array:
+		new (&m_array) std::deque<Value>();
+		m_array = std::move(other.m_array);
+		break;
+	default:
+		break;
+	}
+
+	m_type = other.m_type;
+}
+
+void Value::move(Value &&other)
+{
+	switch (other.m_type) {
+	case Type::String:
+		new (&m_string) std::string(std::move(other.m_string));
+		break;
+	case Type::Real:
+		m_number = other.m_number;
+		break;
+	case Type::Int:
+		m_integer = other.m_integer;
+		break;
+	case Type::Boolean:
+		m_boolean = other.m_boolean;
+		break;
+	case Type::Object:
+		new (&m_object) std::map<std::string, Value>(std::move(other.m_object));
+		break;
+	case Type::Array:
+		new (&m_array) std::deque<Value>(std::move(other.m_array));
+		break;
+	default:
+		break;
+	}
+
+	m_type = other.m_type;
+}
+
+Value::Value(Type type)
+	: m_type{type}
+{
+	switch (type) {
+	case Type::String:
+		new (&m_string) std::string();
+		break;
+	case Type::Array:
+		new (&m_array) std::deque<Value>();
+		break;
+	case Type::Object:
+		new (&m_object) std::map<std::string, Value>();
+		break;
+	case Type::Real:
+		m_number = 0;
+		break;
+	case Type::Int:
+		m_integer = 0;
+		break;
+	case Type::Boolean:
+		m_boolean = false;
+		break;
+	default:
+		break;
+	}
+}
+
+Value::~Value()
+{
+	switch (m_type) {
+	case Type::String:
+		m_string.~basic_string();
+		break;
+	case Type::Object:
+		m_object.~map<std::string, Value>();
+		break;
+	case Type::Array:
+		m_array.~deque<Value>();
+		break;
+	default:
+		break;
+	}
+}
+
 bool Value::toBool() const noexcept
 {
 	if (m_type != Type::Boolean) {
@@ -145,32 +248,14 @@
 	return m_string;
 }
 
-Object Value::toObject() const noexcept
+Value::Value(const Buffer &buffer)
 {
-	if (m_type != Type::Object) {
-		return Object{};
-	}
-
-	return Object(*this);
+	*this = convert(json_loads, buffer.text.c_str(), 0);
 }
 
-Array Value::toArray() const noexcept
+Value::Value(const File &file)
 {
-	if (m_type != Type::Array) {
-		return Array{};
-	}
-
-	return Array(*this);
-}
-
-Document::Document(Buffer buffer)
-{
-	m_value = convert(json_loads, buffer.text.c_str(), 0);
-}
-
-Document::Document(File file)
-{
-	m_value = convert(json_load_file, file.path.c_str(), 0);
+	*this = convert(json_load_file, file.path.c_str(), 0);
 }
 
 std::string escape(const std::string &value)

--- a/C++/modules/Json/Json.h	Fri Nov 06 15:09:00 2015 +0100
+++ b/C++/modules/Json/Json.h	Mon Nov 09 16:52:38 2015 +0100
@@ -28,6 +28,7 @@
  * you get real copies, thus when you read big documents it can has a performance cost.
  */
 
+#include <cassert>
 #include <exception>
 #include <initializer_list>
 #include <map>
@@ -146,42 +147,229 @@
 	}
 };
 
-class Array;
-class Object;
+/**
+ * @class Buffer
+ * @brief Open JSON document from text.
+ */
+class Buffer {
+public:
+	std::string text;	//!< The JSON text
+};
+
+/**
+ * @class File
+ * @brief Open JSON document from a file.
+ */
+class File {
+public:
+	std::string path;	//!< The path to the file
+};
 
 /**
  * @class Value
  * @brief Generic JSON value wrapper.
  */
 class Value {
-protected:
-	/**
-	 * Type of value.
-	 */
-	Type m_type;
+private:
+	Type m_type{Type::Null};
 
-	/**
-	 * Union of values.
-	 */
 	union {
 		double m_number;
 		bool m_boolean;
 		int m_integer;
 		std::string m_string;
 		std::deque<Value> m_array;
-		std::map<std::string, Value> m_map;
+		std::map<std::string, Value> m_object;
 	};
 
+	void copy(const Value &);
+	void move(Value &&);
+
+	template <typename ValueType, typename ArrayIteratorType, typename ObjectIteratorType>
+	class BaseIterator {
+	private:
+		ValueType &m_value;
+		ArrayIteratorType m_ita;
+		ObjectIteratorType m_itm;
+
+		inline void increment()
+		{
+			if (m_value.isObject()) {
+				m_itm++;
+			} else {
+				m_ita++;
+			}
+		}
+
+	public:
+		explicit BaseIterator(ValueType &value, bool end = false)
+			: m_value(value)
+		{
+			if (m_value.isObject()) {
+				m_itm = (end) ? m_value.m_object.end() : m_value.m_object.begin();
+			} else {
+				m_ita = (end) ? m_value.m_array.end() : m_value.m_array.begin();
+			}
+		}
+
+		/**
+		 * Get the iterator key (for objects).
+		 *
+		 * @pre iterator must be dereferenceable
+		 * @pre iterator must come from object
+		 * @return the key
+		 */
+		inline const std::string &key() const noexcept
+		{
+			assert(m_value.isObject());
+			assert(m_itm != m_value.m_object.end());
+
+			return m_itm->first;
+		}
+
+		/**
+		 * Get the iterator position (for arrays).
+		 *
+		 * @pre iterator must be dereferenceable
+		 * @pre iterator must come from arrays
+		 * @return the index
+		 */
+		inline unsigned index() const noexcept
+		{
+			assert(m_value.isArray());
+			assert(m_ita != m_value.m_array.end());
+
+			return std::distance(m_value.m_array.begin(), m_ita);
+		}
+
+		/**
+		 * Dereference the iterator.
+		 *
+		 * @pre iterator be dereferenceable
+		 * @return the value
+		 */
+		inline ValueType &operator*() noexcept
+		{
+			assert((m_value.isArray()  && m_ita != m_value.m_array.end()) ||
+			       (m_value.isObject() && m_itm != m_value.m_object.end()));
+
+			if (m_value.isObject()) {
+				return m_itm->second;
+			}
+
+			return *m_ita;
+		}
+
+		/**
+		 * Dereference the iterator as a pointer.
+		 *
+		 * @pre iterator must be dereferenceable
+		 * @return the value
+		 */
+		inline ValueType *operator->() noexcept
+		{
+			return &(*this);
+		}
+
+		/**
+		 * Increment the iterator. (Prefix version).
+		 *
+		 * @pre iterator must be dereferenceable
+		 * @return *this;
+		 */
+		inline BaseIterator &operator++() noexcept
+		{
+			assert((m_value.isArray()  && m_ita != m_value.m_array.end()) ||
+			       (m_value.isObject() && m_itm != m_value.m_object.end()));
+
+			increment();
+
+			return *this;
+		}
+
+		/**
+		 * Increment the iterator. (Postfix version).
+		 *
+		 * @pre iterator must be dereferenceable
+		 * @return *this;
+		 */
+		inline BaseIterator &operator++(int) noexcept
+		{
+			assert((m_value.isArray()  && m_ita != m_value.m_array.end()) ||
+			       (m_value.isObject() && m_itm != m_value.m_object.end()));
+
+			increment();
+
+			return *this;
+		}
+
+		/**
+		 * Compare two iterators.
+		 *
+		 * @param it1 the first iterator
+		 * @param it2 the second iterator
+		 * @return true if they are same
+		 */
+		bool operator==(const BaseIterator &it) const noexcept
+		{
+			if (m_value.isObject() && it.m_value.isObject())
+				return m_itm == it.m_itm;
+			if (m_value.isArray() && it.m_value.isArray())
+				return m_ita == it.m_ita;
+
+			return false;
+		}
+
+		/**
+		 * Test if the iterator is different.
+		 *
+		 * @param it the iterator
+		 * @return true if they are different
+		 */
+		inline bool operator!=(const BaseIterator &it) const noexcept
+		{
+			return !(*this == it);
+		}
+	};
+
+	using iterator = BaseIterator<Value, typename std::deque<Value>::iterator, typename std::map<std::string, Value>::iterator>;
+	using const_iterator = BaseIterator<const Value, typename std::deque<Value>::const_iterator, typename std::map<std::string, Value>::const_iterator>;
+
 public:
 	/**
 	 * Construct a null value.
 	 */
-	inline Value() noexcept
-		: m_type{Type::Null}
+	inline Value()
 	{
 	}
 
 	/**
+	 * Construct a value from a buffer.
+	 *
+	 * @param buffer the text
+	 * @throw Error on errors
+	 */
+	Value(const Buffer &buffer);
+
+	/**
+	 * Construct a value from a file.
+	 *
+	 * @param file the file
+	 * @throw Error on errors
+	 */
+	Value(const File &file);
+
+	/**
+	 * Create a value with a specified type, this is usually only needed when you want to create an object or
+	 * an array.
+	 *
+	 * For any other types, initialize with sane default value.
+	 *
+	 * @param type the type
+	 */
+	Value(Type type);
+
+	/**
 	 * Construct a null value.
 	 */
 	inline Value(std::nullptr_t) noexcept
@@ -251,33 +439,7 @@
 	 */
 	inline Value(Value &&other)
 	{
-		m_type = other.m_type;
-
-		switch (m_type) {
-		case Type::String:
-			new (&m_string) std::string();
-			m_string = std::move(other.m_string);
-			break;
-		case Type::Real:
-			m_number = other.m_number;
-			break;
-		case Type::Int:
-			m_integer = other.m_integer;
-			break;
-		case Type::Boolean:
-			m_boolean = other.m_boolean;
-			break;
-		case Type::Object:
-			new (&m_map) std::map<std::string, Value>();
-			m_map = std::move(other.m_map);
-			break;
-		case Type::Array:
-			new (&m_array) std::deque<Value>();
-			m_array = std::move(other.m_array);
-			break;
-		default:
-			break;
-		}
+		move(std::move(other));
 	}
 
 	/**
@@ -287,33 +449,7 @@
 	 */
 	inline Value(const Value &other)
 	{
-		m_type = other.m_type;
-
-		switch (m_type) {
-		case Type::String:
-			new (&m_string) std::string();
-			m_string = other.m_string;
-			break;
-		case Type::Real:
-			m_number = other.m_number;
-			break;
-		case Type::Int:
-			m_integer = other.m_integer;
-			break;
-		case Type::Boolean:
-			m_boolean = other.m_boolean;
-			break;
-		case Type::Object:
-			new (&m_map) std::map<std::string, Value>();
-			m_map = other.m_map;
-			break;
-		case Type::Array:
-			new (&m_array) std::deque<Value>();
-			m_array = other.m_array;
-			break;
-		default:
-			break;
-		}
+		copy(other);
 	}
 
 	/**
@@ -324,33 +460,7 @@
 	 */
 	inline Value &operator=(const Value &other)
 	{
-		m_type = other.m_type;
-
-		switch (m_type) {
-		case Type::String:
-			new (&m_string) std::string();
-			m_string = other.m_string;
-			break;
-		case Type::Real:
-			m_number = other.m_number;
-			break;
-		case Type::Int:
-			m_integer = other.m_integer;
-			break;
-		case Type::Boolean:
-			m_boolean = other.m_boolean;
-			break;
-		case Type::Object:
-			new (&m_map) std::map<std::string, Value>();
-			m_map = other.m_map;
-			break;
-		case Type::Array:
-			new (&m_array) std::deque<Value>();
-			m_array = other.m_array;
-			break;
-		default:
-			break;
-		}
+		copy(other);
 
 		return *this;
 	}
@@ -362,33 +472,7 @@
 	 */
 	inline Value &operator=(Value &&other)
 	{
-		m_type = other.m_type;
-
-		switch (m_type) {
-		case Type::String:
-			new (&m_string) std::string();
-			m_string = std::move(other.m_string);
-			break;
-		case Type::Real:
-			m_number = other.m_number;
-			break;
-		case Type::Int:
-			m_integer = other.m_integer;
-			break;
-		case Type::Boolean:
-			m_boolean = other.m_boolean;
-			break;
-		case Type::Object:
-			new (&m_map) std::map<std::string, Value>();
-			m_map = std::move(other.m_map);
-			break;
-		case Type::Array:
-			new (&m_array) std::deque<Value>();
-			m_array = std::move(other.m_array);
-			break;
-		default:
-			break;
-		}
+		move(std::move(other));
 
 		return *this;
 	}
@@ -396,21 +480,36 @@
 	/**
 	 * Destructor.
 	 */
-	inline ~Value()
+	~Value();
+
+	inline iterator begin() noexcept
+	{
+		return iterator(*this);
+	}
+
+	inline const_iterator begin() const noexcept
+	{
+		return const_iterator(*this);
+	}
+
+	inline const_iterator cbegin() const noexcept
 	{
-		switch (m_type) {
-		case Type::String:
-			m_string.~basic_string();
-			break;
-		case Type::Object:
-			m_map.~map<std::string, Value>();
-			break;
-		case Type::Array:
-			m_array.~deque<Value>();
-			break;
-		default:
-			break;
-		}
+		return const_iterator(*this);
+	}
+
+	inline iterator end() noexcept
+	{
+		return iterator(*this, true);
+	}
+
+	inline const_iterator end() const noexcept
+	{
+		return const_iterator(*this, true);
+	}
+
+	inline const_iterator cend() const noexcept
+	{
+		return const_iterator(*this, true);
 	}
 
 	/**
@@ -452,22 +551,6 @@
 	std::string toString() const noexcept;
 
 	/**
-	 * Convert the value to object.
-	 *
-	 * @return an object or empty if not an object
-	 * @note the returned object is a copy, modifying it won't modify this value
-	 */
-	Object toObject() const noexcept;
-
-	/**
-	 * Convert the value to array.
-	 *
-	 * @return an array or empty if not an array
-	 * @note the returned array is a copy, modifying it won't modify this value
-	 */
-	Array toArray() const noexcept;
-
-	/**
 	 * Check if the value is boolean type.
 	 *
 	 * @return true if boolean
@@ -548,113 +631,44 @@
 	{
 		return m_type == Type::String;
 	}
-};
-
-/**
- * @class Array
- * @brief Array definition.
- */
-class Array : public Value {
-public:
-	/**
-	 * Construct an empty array.
-	 */
-	inline Array()
-	{
-		m_type = Type::Array;
-		new (&m_array) std::deque<Value>();
-	}
 
 	/**
-	 * Copy constructor from value for safe casts.
+	 * Get the array or object size.
 	 *
-	 * @param v the value to copy from
-	 */
-	inline Array(const Value &v)
-		: Value{v}
-	{
-	}
-
-	/**
-	 * Move constructor from value for safe casts.
-	 *
-	 * @param v the value to move from
+	 * @pre must be an array or object
+	 * @return the size
 	 */
-	inline Array(Value &&v)
-		: Value{std::move(v)}
+	inline unsigned size() const noexcept
 	{
-	}
+		assert(isArray() || isObject());
 
-	/**
-	 * Construct an array from a std::initializer_list.
-	 *
-	 * @param values the list of values
-	 */
-	inline Array(std::initializer_list<Value> values)
-	{
-		m_type = Type::Array;
-		new (&m_array) std::deque<Value>(values.begin(), values.end());
+		if (m_type == Type::Object) {
+			return m_object.size();
+		}
+
+		return m_array.size();
 	}
 
 	/**
-	 * Get non-const iterator to the beginning.
+	 * Remove all the values.
 	 *
-	 * @return the iterator
-	 */
-	inline auto begin() noexcept
-	{
-		return m_array.begin();
-	}
-
-	/**
-	 * Get a const iterator to the beginning.
-	 *
-	 * @return the iterator
+	 * @pre must be an array or an object
 	 */
-	inline auto begin() const noexcept
+	inline void clear() noexcept
 	{
-		return m_array.begin();
-	}
+		assert(isArray() || isObject());
 
-	/**
-	 * Get a const iterator to the beginning.
-	 *
-	 * @return the iterator
-	 */
-	inline auto cbegin() const noexcept
-	{
-		return m_array.cbegin();
+		if (m_type == Type::Array) {
+			m_array.clear();
+		} else {
+			m_object.clear();
+		}
 	}
 
-	/**
-	 * Get a non-const iterator to the end.
-	 *
-	 * @return the iterator
-	 */
-	inline auto end() noexcept
-	{
-		return m_array.end();
-	}
-
-	/**
-	 * Get a const iterator to the end.
-	 *
-	 * @return the iterator
+	/*
+	 * Array functions
+	 * ----------------------------------------------------------
 	 */
-	inline auto end() const noexcept
-	{
-		return m_array.end();
-	}
-
-	/**
-	 * Get a const iterator to the end.
-	 *
-	 * @return the iterator
-	 */
-	inline auto cend() const noexcept
-	{
-		return m_array.cend();
-	}
 
 	/**
 	 * Get the value at the specified position or the defaultValue if position is out of bounds.
@@ -663,10 +677,10 @@
 	 * @param defaultValue the value replacement
 	 * @return the value or defaultValue
 	 */
-	template <typename V>
-	inline Value valueOr(unsigned position, V &&defaultValue) const
+	template <typename DefaultValue>
+	inline Value valueOr(unsigned position, DefaultValue &&defaultValue) const
 	{
-		if (position >= m_array.size()) {
+		if (m_type != Type::Array || position >= m_array.size()) {
 			return defaultValue;
 		}
 
@@ -676,217 +690,168 @@
 	/**
 	 * Get a value at the specified index.
 	 *
+	 * @pre must be an array
 	 * @param position the position
 	 * @return the value
 	 * @throw std::out_of_range if out of bounds
 	 */
 	inline const Value &at(unsigned position) const
 	{
+		assert(isArray());
+
 		return m_array.at(position);
 	}
 
 	/**
-	 * Get a value at the specified index.
+	 * Overloaded function.
 	 *
+	 * @pre must be an array
 	 * @param position the position
 	 * @return the value
 	 * @throw std::out_of_range if out of bounds
 	 */
 	inline Value &at(unsigned position)
 	{
+		assert(isArray());
+
 		return m_array.at(position);
 	}
 
 	/**
 	 * Get a value at the specified index.
 	 *
+	 * @pre must be an array
+	 * @pre position must be valid
 	 * @param position the position
 	 * @return the value
 	 */
 	inline const Value &operator[](unsigned position) const
 	{
+		assert(isArray());
+		assert(position < m_array.size());
+
 		return m_array[position];
 	}
 
 	/**
 	 * Overloaded function.
 	 *
+	 * @pre must be an array
+	 * @pre position must be valid
 	 * @param position the position
 	 * @return the value
 	 */
 	inline Value &operator[](unsigned position)
 	{
+		assert(isArray());
+		assert(position < m_array.size());
+
 		return m_array[position];
 	}
 
 	/**
 	 * Push a value to the beginning of the array.
 	 *
+	 * @pre must be an array
 	 * @param value the value to push
 	 */
-	template <typename T>
-	inline void push(T &&value)
+	inline void push(const Value &value)
 	{
-		m_array.push_front(std::forward<T>(value));
+		assert(isArray());
+
+		m_array.push_front(value);
+	}
+
+	/**
+	 * Overloaded function.
+	 *
+	 * @pre must be an array
+	 * @param value the value to push
+	 */
+	inline void push(Value &&value)
+	{
+		assert(isArray());
+
+		m_array.push_front(std::move(value));
 	}
 
 	/**
 	 * Insert a value at the specified position.
 	 *
+	 * @pre must be an array
+	 * @pre position must be valid
 	 * @param position the position
 	 * @param value the value to push
 	 */
-	template <typename T>
-	inline void insert(unsigned position, T &&value)
+	inline void insert(unsigned position, const Value &value)
 	{
-		m_array.insert(m_array.begin() + position, std::forward<T>(value));
+		assert(isArray());
+		assert(position <= m_array.size());
+
+		m_array.insert(m_array.begin() + position, value);
 	}
 
 	/**
-	 * Add a new value.
+	 * Overloaded function.
 	 *
-	 * @param value the value to append
+	 * @pre must be an array
+	 * @pre position must be valid
+	 * @param position the position
+	 * @param value the value to push
 	 */
-	template <typename T>
-	inline void append(T &&value)
+	inline void insert(unsigned position, Value &&value)
 	{
-		m_array.push_back(std::forward<T>(value));
+		assert(isArray());
+		assert(position <= m_array.size());
+
+		m_array.insert(m_array.begin() + position, std::move(value));
 	}
 
 	/**
-	 * Get the array size.
+	 * Add a new value to the end.
 	 *
-	 * @return the size
+	 * @pre must be an array
+	 * @param value the value to append
 	 */
-	inline unsigned size() const noexcept
+	inline void append(const Value &value)
 	{
-		return m_array.size();
+		assert(isArray());
+
+		m_array.push_back(value);
 	}
 
 	/**
-	 * Remove all the values.
+	 * Overloaded function.
+	 *
+	 * @pre must be an array
+	 * @param value the value to append
 	 */
-	inline void clear()
+	inline void append(Value &&value)
 	{
-		m_array.clear();
+		assert(isArray());
+
+		m_array.push_back(std::move(value));
 	}
 
 	/**
 	 * Remove a value at the specified position.
 	 *
+	 * @pre must be an array
+	 * @pre position must be valid
 	 * @param position the position
 	 */
 	inline void erase(unsigned position)
 	{
-		m_array.erase(m_array.begin() + position);
-	}
-};
-
-/**
- * @class Object
- * @brief Object definition.
- */
-class Object : public Value {
-public:
-	/**
-	 * Construct an empty object.
-	 */
-	Object()
-	{
-		m_type = Type::Object;
-		new (&m_map) std::map<std::string, Value>();
-	}
+		assert(isArray());
+		assert(position < m_array.size());
 
-	/**
-	 * Copy constructor from value for safe casts.
-	 *
-	 * @param v the value to copy from
-	 */
-	Object(const Value &v)
-		: Value{v}
-	{
-	}
-
-	/**
-	 * Move constructor from value for safe casts.
-	 *
-	 * @param v the value to move from
-	 */
-	Object(Value &&v)
-		: Value{std::move(v)}
-	{
-	}
-
-	/**
-	 * Create an object from the initializer_list of key-value pairs.
-	 *
-	 * @param values the values
-	 */
-	Object(std::initializer_list<std::pair<std::string, Value>> values)
-	{
-		m_type = Type::Object;
-		new (&m_map) std::map<std::string, Value>(values.begin(), values.end());
+		m_array.erase(m_array.begin() + position);
 	}
 
-	/**
-	 * Get non-const iterator to the beginning.
-	 *
-	 * @return the iterator
-	 */
-	inline auto begin() noexcept
-	{
-		return m_map.begin();
-	}
-
-	/**
-	 * Get a const iterator to the beginning.
-	 *
-	 * @return the iterator
-	 */
-	inline auto begin() const noexcept
-	{
-		return m_map.begin();
-	}
-
-	/**
-	 * Get a const iterator to the beginning.
-	 *
-	 * @return the iterator
+	/*
+	 * Object functions
+	 * ----------------------------------------------------------
 	 */
-	inline auto cbegin() const noexcept
-	{
-		return m_map.cbegin();
-	}
-
-	/**
-	 * Get a non-const iterator to the end.
-	 *
-	 * @return the iterator
-	 */
-	inline auto end() noexcept
-	{
-		return m_map.end();
-	}
-
-	/**
-	 * Get a const iterator to the end.
-	 *
-	 * @return the iterator
-	 */
-	inline auto end() const noexcept
-	{
-		return m_map.end();
-	}
-
-	/**
-	 * Get a const iterator to the end.
-	 *
-	 * @return the iterator
-	 */
-	inline auto cend() const noexcept
-	{
-		return m_map.cend();
-	}
 
 	/**
 	 * Get the value at the specified key or the defaultValue if key is absent.
@@ -895,12 +860,16 @@
 	 * @param defaultValue the value replacement
 	 * @return the value or defaultValue
 	 */
-	template <typename V>
-	inline Value valueOr(const std::string &name, V &&defaultValue) const
+	template <typename DefaultValue>
+	Value valueOr(const std::string &name, DefaultValue &&defaultValue) const
 	{
-		auto it = m_map.find(name);
+		if (m_type != Type::Object) {
+			return defaultValue;
+		}
 
-		if (it == m_map.end()) {
+		auto it = m_object.find(name);
+
+		if (it == m_object.end()) {
 			return defaultValue;
 		}
 
@@ -910,65 +879,69 @@
 	/**
 	 * Get a value from the object.
 	 *
+	 * @pre must be an object
 	 * @param name the value key
 	 * @return the value
 	 * @throw std::out_of_range if not found
 	 */
 	inline const Value &at(const std::string &name) const
 	{
-		return m_map.at(name);
+		assert(isObject());
+
+		return m_object.at(name);
 	}
 
 	/**
 	 * Overloaded function.
 	 *
+	 * @pre must be an object
 	 * @param name the value key
 	 * @return the value
 	 * @throw std::out_of_range if not found
 	 */
 	inline Value &at(const std::string &name)
 	{
-		return m_map.at(name);
+		assert(isObject());
+
+		return m_object.at(name);
 	}
 
 	/**
 	 * Get a value from the object.
 	 *
+	 * @pre must be an object
 	 * @param name the value key
 	 * @return the value
 	 */
 	inline Value &operator[](const std::string &name)
 	{
-		return m_map.at(name);
+		assert(isObject());
+
+		return m_object[name];
 	}
 
 	/**
 	 * Insert a new value.
 	 *
+	 * @pre must be an object
 	 * @param name the key
 	 * @param value the value
 	 */
-	inline void insert(std::string name, Value value)
+	inline void insert(std::string name, const Value &value)
 	{
-		m_map.insert({std::move(name), std::move(value)});
+		m_object.insert({std::move(name), value});
 	}
 
 	/**
-	 * Remove all the values from the object.
+	 * Overloaded function.
+	 *
+	 * @pre must be an object
+	 * @param name the key
+	 * @param value the value
 	 */
-	inline void clear()
+	inline void insert(std::string name, Value &&value)
 	{
-		m_map.clear();
-	}
-
-	/**
-	 * Get the number of entries in the object.
-	 *
-	 * @return the size
-	 */
-	inline unsigned size() const noexcept
-	{
-		return m_map.size();
+		m_object.insert({std::move(name), std::move(value)});
 	}
 
 	/**
@@ -979,7 +952,7 @@
 	 */
 	inline bool contains(const std::string &key) const noexcept
 	{
-		return m_map.find(key) != m_map.end();
+		return m_object.find(key) != m_object.end();
 	}
 
 	/**
@@ -989,101 +962,7 @@
 	 */
 	inline void erase(const std::string &key)
 	{
-		m_map.erase(key);
-	}
-};
-
-/**
- * @class Buffer
- * @brief Open JSON document from text.
- */
-class Buffer {
-public:
-	std::string text;	//!< The JSON text
-};
-
-/**
- * @class File
- * @brief Open JSON document from a file.
- */
-class File {
-public:
-	std::string path;	//!< The path to the file
-};
-
-/**
- * @class Document
- * @brief Construct a JSON document from a source
- * @see Buffer
- * @see File
- */
-class Document {
-private:
-	Value m_value;
-
-public:
-	/**
-	 * Construct a document from a buffer.
-	 *
-	 * @param buffer the text
-	 * @throw Error on errors
-	 */
-	Document(Buffer buffer);
-
-	/**
-	 * Construct a document from a file.
-	 *
-	 * @param file the file
-	 * @throw Error on errors
-	 */
-	Document(File file);
-
-	/**
-	 * Check if the opened document is an object.
-	 *
-	 * @return true if object
-	 */
-	inline bool isObject() const noexcept
-	{
-		return m_value.typeOf() == Type::Object;
-	}
-
-	/**
-	 * Check if the opened document is an array.
-	 *
-	 * @return true if array
-	 */
-	inline bool isArray() const noexcept
-	{
-		return m_value.typeOf() == Type::Array;
-	}
-
-	/**
-	 * Get the object.
-	 *
-	 * @return the object or empty object if not an object
-	 */
-	inline Object toObject() const noexcept
-	{
-		if (m_value.typeOf() != Type::Object) {
-			return Object{};
-		}
-
-		return Object(m_value);
-	}
-
-	/**
-	 * Get the array.
-	 *
-	 * @return the array or empty object if not an array
-	 */
-	inline Array toArray() const noexcept
-	{
-		if (m_value.typeOf() != Type::Array) {
-			return Array{};
-		}
-
-		return Array(m_value);
+		m_object.erase(key);
 	}
 };
 

--- a/C++/tests/Json/main.cpp	Fri Nov 06 15:09:00 2015 +0100
+++ b/C++/tests/Json/main.cpp	Mon Nov 09 16:52:38 2015 +0100
@@ -29,12 +29,12 @@
 
 TEST(Misc, copy)
 {
-	json::Object object;
+	json::Value object{json::Type::Object};
 
 	object.insert("integer", 123);
 	object.insert("true", true);
 
-	json::Object object2{object};
+	json::Value object2{object};
 
 	ASSERT_TRUE(object2.isObject());
 	ASSERT_EQ(123, object2["integer"].toInt());
@@ -43,10 +43,10 @@
 
 TEST(Misc, copyAssign)
 {
-	json::Object object;
+	json::Value object{json::Type::Object};
 
 	{
-		json::Object tmp;
+		json::Value tmp{json::Type::Object};
 
 		tmp.insert("integer", 123);
 		tmp.insert("true", true);
@@ -61,8 +61,8 @@
 
 TEST(Misc, move)
 {
-	json::Object object(123);
-	json::Object object2(std::move(object));
+	json::Value object(123);
+	json::Value object2(std::move(object));
 
 	ASSERT_TRUE(object2.isInt());
 	ASSERT_EQ(123, object2.toInt());
@@ -70,8 +70,8 @@
 
 TEST(Misc, moveAssign)
 {
-	json::Object object(123);
-	json::Object object2;
+	json::Value object(123);
+	json::Value object2;
 
 	object2 = std::move(object);
 
@@ -161,7 +161,7 @@
 TEST(Object, set)
 {
 	try {
-		json::Object object;
+		json::Value object{json::Type::Object};
 
 		object.insert("integer", 123);
 		object.insert("string", "hello");
@@ -178,7 +178,7 @@
 TEST(Object, clear)
 {
 	try {
-		json::Object object;
+		json::Value object{json::Type::Object};
 
 		object.insert("integer", 123);
 		object.insert("string", "hello");
@@ -198,7 +198,7 @@
 TEST(Object, erase)
 {
 	try {
-		json::Object object;
+		json::Value object{json::Type::Object};
 
 		object.insert("integer", 123);
 		object.insert("string", "hello");
@@ -215,6 +215,8 @@
 	}
 }
 
+#if 0
+
 TEST(Object, valueOr)
 {
 	try {
@@ -276,6 +278,8 @@
 	}
 }
 
+#endif
+
 /* --------------------------------------------------------
  * Array
  * -------------------------------------------------------- */
@@ -283,7 +287,7 @@
 TEST(Array, push)
 {
 	try {
-		json::Array array;
+		json::Value array{json::Type::Array};
 
 		ASSERT_TRUE(array.isArray());
 
@@ -303,7 +307,7 @@
 TEST(Array, append)
 {
 	try {
-		json::Array array;
+		json::Value array{json::Type::Array};
 
 		ASSERT_TRUE(array.isArray());
 
@@ -323,7 +327,7 @@
 TEST(Array, insert)
 {
 	try {
-		json::Array array;
+		json::Value array{json::Type::Array};
 
 		ASSERT_TRUE(array.isArray());
 
@@ -343,7 +347,7 @@
 TEST(Array, clear)
 {
 	try {
-		json::Array array;
+		json::Value array{json::Type::Array};
 
 		array.append(1);
 		array.append("hello");
@@ -360,7 +364,7 @@
 TEST(Array, erase)
 {
 	try {
-		json::Array array;
+		json::Value array{json::Type::Array};
 
 		array.append(1);
 		array.append("hello");
@@ -376,6 +380,8 @@
 	}
 }
 
+#if 0
+
 TEST(Array, valueOr)
 {
 	try {
@@ -435,6 +441,8 @@
 	}
 }
 
+#endif
+
 /* --------------------------------------------------------
  * I/O
  * -------------------------------------------------------- */
@@ -442,7 +450,7 @@
 TEST(FileRead, simple)
 {
 	try {
-		json::Document doc(json::File{"Json/simple.json"});
+		json::Value doc(json::File{"Json/simple.json"});
 
 		ASSERT_TRUE(doc.isObject());
 		ASSERT_FALSE(doc.isArray());
@@ -454,7 +462,7 @@
 TEST(FileRead, fail)
 {
 	try {
-		json::Document(json::File{"Json/notexist.json"});
+		json::Value(json::File{"Json/notexist.json"});
 
 		FAIL() << "Exception expected";
 	} catch (const json::Error &) {
@@ -464,7 +472,7 @@
 TEST(StringRead, simple)
 {
 	try {
-		json::Document doc(json::Buffer{"{ \"license\": \"ISC\" }"});
+		json::Value doc(json::Buffer{"{ \"license\": \"ISC\" }"});
 
 		ASSERT_TRUE(doc.isObject());
 		ASSERT_FALSE(doc.isArray());
@@ -476,13 +484,15 @@
 TEST(StringRead, fail)
 {
 	try {
-		json::Document(json::Buffer{"{ \"license\": ISC }"});
+		json::Value(json::Buffer{"{ \"license\": ISC }"});
 
 		FAIL() << "Exception expected";
 	} catch (const json::Error &ex) {
 	}
 }
 
+#if 0
+
 /* --------------------------------------------------------
  * Object read
  * -------------------------------------------------------- */
@@ -788,6 +798,8 @@
 	}
 }
 
+#endif
+
 int main(int argc, char **argv)
 {
 	testing::InitGoogleTest(&argc, argv);