Copied all files from new-api branch of old repo

2025-09-09 04:41:16 +00:00 · 2012-05-19 15:34:02 -05:00
parent c8a539f4f4
commit c22512649e
38 changed files with 4333 additions and 27 deletions
--- a/include/yaml-cpp/exceptions.h
+++ b/include/yaml-cpp/exceptions.h
@@ -55,6 +55,13 @@ namespace YAML
 		const char * const AMBIGUOUS_ANCHOR       = "cannot assign the same alias to multiple nodes";
 		const char * const UNKNOWN_ANCHOR         = "the referenced anchor is not defined";

+		const char * const INVALID_SCALAR         = "invalid scalar";
+		const char * const KEY_NOT_FOUND          = "key not found";
+        const char * const BAD_CONVERSION         = "bad conversion";
+		const char * const BAD_DEREFERENCE        = "bad dereference";
+        const char * const BAD_SUBSCRIPT          = "operator[] call on a scalar";
+        const char * const BAD_PUSHBACK           = "appending to a non-sequence";
+		
 		const char * const UNMATCHED_GROUP_TAG    = "unmatched group tag";
 		const char * const UNEXPECTED_END_SEQ     = "unexpected end sequence token";
 		const char * const UNEXPECTED_END_MAP     = "unexpected end map token";
@@ -66,6 +73,24 @@ namespace YAML
 		const char * const EXPECTED_VALUE_TOKEN   = "expected value token";
 		const char * const UNEXPECTED_KEY_TOKEN   = "unexpected key token";
 		const char * const UNEXPECTED_VALUE_TOKEN = "unexpected value token";
+
+		template <typename T>
+		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T&, typename disable_if<is_numeric<T> >::type * = 0) {
+			return KEY_NOT_FOUND;
+		}
+
+		inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
+			std::stringstream stream;
+			stream << KEY_NOT_FOUND << ": " << key;
+			return stream.str();
+		}
+		
+		template <typename T>
+		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T& key, typename enable_if<is_numeric<T> >::type * = 0) {
+			std::stringstream stream;
+			stream << KEY_NOT_FOUND << ": " << key;
+			return stream.str();
+		}
 	}

 	class Exception: public std::runtime_error {
@@ -91,6 +116,72 @@ namespace YAML
 			: Exception(mark_, msg_) {}
 	};

+	class RepresentationException: public Exception {
+	public:
+		RepresentationException(const Mark& mark_, const std::string& msg_)
+			: Exception(mark_, msg_) {}
+	};
+
+	// representation exceptions
+	class InvalidScalar: public RepresentationException {
+	public:
+		InvalidScalar(const Mark& mark_)
+			: RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
+	};
+
+	class KeyNotFound: public RepresentationException {
+	public:
+		template <typename T>
+		KeyNotFound(const Mark& mark_, const T& key_)
+			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {}
+	};
+	
+	template <typename T>
+	class TypedKeyNotFound: public KeyNotFound {
+	public:
+		TypedKeyNotFound(const Mark& mark_, const T& key_)
+			: KeyNotFound(mark_, key_), key(key_) {}
+		virtual ~TypedKeyNotFound() throw() {}
+
+		T key;
+	};
+
+	template <typename T>
+	inline TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
+		return TypedKeyNotFound <T> (mark, key);
+	}
+
+	class BadConversion: public RepresentationException {
+	public:
+		BadConversion()
+        : RepresentationException(Mark::null(), ErrorMsg::BAD_CONVERSION) {}
+	};
+
+    template<typename T>
+	class TypedBadConversion: public BadConversion {
+	public:
+		TypedBadConversion()
+        : BadConversion() {}
+	};
+
+	class BadDereference: public RepresentationException {
+	public:
+		BadDereference()
+		: RepresentationException(Mark::null(), ErrorMsg::BAD_DEREFERENCE) {}
+	};
+
+	class BadSubscript: public RepresentationException {
+	public:
+		BadSubscript()
+		: RepresentationException(Mark::null(), ErrorMsg::BAD_SUBSCRIPT) {}
+	};
+
+	class BadPushback: public RepresentationException {
+	public:
+		BadPushback()
+		: RepresentationException(Mark::null(), ErrorMsg::BAD_PUSHBACK) {}
+	};
+	
 	class EmitterException: public Exception {
 	public:
 		EmitterException(const std::string& msg_)
--- a/include/yaml-cpp/node/convert.h
+++ b/include/yaml-cpp/node/convert.h
@@ -0,0 +1,209 @@
+#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/null.h"
+#include <limits>
+#include <list>
+#include <map>
+#include <sstream>
+#include <vector>
+
+namespace YAML
+{
+    namespace conversion {
+        inline bool IsInfinity(const std::string& input) {
+            return input == ".inf" || input == ".Inf" || input == ".INF" || input == "+.inf" || input == "+.Inf" || input == "+.INF";
+        }
+        
+        inline bool IsNegativeInfinity(const std::string& input) {
+            return input == "-.inf" || input == "-.Inf" || input == "-.INF";
+        }
+        
+        inline bool IsNaN(const std::string& input) {
+            return input == ".nan" || input == ".NaN" || input == ".NAN";
+        }
+    }
+    
+	// std::string
+	template<>
+	struct convert<std::string> {
+		static Node encode(const std::string& rhs) {
+			return Node(rhs);
+		}
+		
+		static bool decode(const Node& node, std::string& rhs) {
+			if(!node.IsScalar())
+				return false;
+			rhs = node.Scalar();
+			return true;
+		}
+	};
+	
+	template<>
+	struct convert<_Null> {
+		static Node encode(const _Null& /* rhs */) {
+			return Node();
+		}
+		
+		static bool decode(const Node& node, _Null& /* rhs */) {
+			return node.IsNull();
+		}
+	};
+	
+#define YAML_DEFINE_CONVERT_STREAMABLE(type)\
+	template<>\
+	struct convert<type> {\
+		static Node encode(const type& rhs) {\
+			std::stringstream stream;\
+			stream << rhs;\
+			return Node(stream.str());\
+		}\
+		\
+		static bool decode(const Node& node, type& rhs) {\
+			if(node.Type() != NodeType::Scalar)\
+				return false;\
+            const std::string& input = node.Scalar();\
+			std::stringstream stream(input);\
+            stream.unsetf(std::ios::dec);\
+			if((stream >> rhs) && (stream >> std::ws).eof())\
+                return true;\
+            if(std::numeric_limits<type>::has_infinity) {\
+                if(conversion::IsInfinity(input)) {\
+                    rhs = std::numeric_limits<type>::infinity();\
+                    return true;\
+                } else if(conversion::IsNegativeInfinity(input)) {\
+                    rhs = -std::numeric_limits<type>::infinity();\
+                    return true;\
+                }\
+            }\
+            \
+            if(std::numeric_limits<type>::has_quiet_NaN && conversion::IsNaN(input)) {\
+                rhs = std::numeric_limits<type>::quiet_NaN();\
+                return true;\
+            }\
+            \
+            return false;\
+		}\
+	}
+	
+	YAML_DEFINE_CONVERT_STREAMABLE(int);
+	YAML_DEFINE_CONVERT_STREAMABLE(unsigned);
+	YAML_DEFINE_CONVERT_STREAMABLE(short);
+	YAML_DEFINE_CONVERT_STREAMABLE(unsigned short);
+	YAML_DEFINE_CONVERT_STREAMABLE(long);
+	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long);
+	YAML_DEFINE_CONVERT_STREAMABLE(long long);
+	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long long);
+	
+	YAML_DEFINE_CONVERT_STREAMABLE(char);
+	YAML_DEFINE_CONVERT_STREAMABLE(unsigned char);
+	
+	YAML_DEFINE_CONVERT_STREAMABLE(float);
+	YAML_DEFINE_CONVERT_STREAMABLE(double);
+	YAML_DEFINE_CONVERT_STREAMABLE(long double);
+	
+#undef YAML_DEFINE_CONVERT_STREAMABLE
+	
+	// bool
+	template<>
+	struct convert<bool> {
+		static Node encode(bool rhs) {
+			return rhs ? Node("true") : Node("false");
+		}
+		
+		static bool decode(const Node& node, bool& rhs);
+	};
+
+	// std::map
+	template<typename K, typename V>
+	struct convert<std::map<K, V> > {
+		static Node encode(const std::map<K, V>& rhs) {
+			Node node(NodeType::Map);
+			for(typename std::map<K, V>::const_iterator it=rhs.begin();it!=rhs.end();++it)
+				node[it->first] = it->second;
+			return node;
+		}
+		
+		static bool decode(const Node& node, std::map<K, V>& rhs) {
+			if(!node.IsMap())
+				return false;
+
+			rhs.clear();
+			for(const_iterator it=node.begin();it!=node.end();++it)
+				rhs[it->first.as<K>()] = it->second.as<V>();
+			return true;
+		}
+	};
+	
+	// std::vector
+	template<typename T>
+	struct convert<std::vector<T> > {
+		static Node encode(const std::vector<T>& rhs) {
+			Node node(NodeType::Sequence);
+			for(typename std::vector<T>::const_iterator it=rhs.begin();it!=rhs.end();++it)
+				node.push_back(*it);
+			return node;
+		}
+		
+		static bool decode(const Node& node, std::vector<T>& rhs) {
+			if(!node.IsSequence())
+				return false;
+			
+			rhs.clear();
+			for(const_iterator it=node.begin();it!=node.end();++it)
+				rhs.push_back(it->as<T>());
+			return true;
+		}
+	};
+	
+	// std::list
+	template<typename T>
+	struct convert<std::list<T> > {
+		static Node encode(const std::list<T>& rhs) {
+			Node node(NodeType::Sequence);
+			for(typename std::list<T>::const_iterator it=rhs.begin();it!=rhs.end();++it)
+				node.push_back(*it);
+			return node;
+		}
+		
+		static bool decode(const Node& node, std::list<T>& rhs) {
+			if(!node.IsSequence())
+				return false;
+			
+			rhs.clear();
+			for(const_iterator it=node.begin();it!=node.end();++it)
+				rhs.push_back(it->as<T>());
+			return true;
+		}
+	};
+    
+    // binary
+    template<>
+	struct convert<Binary> {
+		static Node encode(const Binary& rhs) {
+            return Node(EncodeBase64(rhs.data(), rhs.size()));
+		}
+		
+		static bool decode(const Node& node, Binary& rhs) {
+			if(!node.IsScalar())
+				return false;
+            
+            std::vector<unsigned char> data = DecodeBase64(node.Scalar());
+            if(data.empty() && !node.Scalar().empty())
+                return false;
+            
+            rhs.swap(data);
+            return true;
+		}
+	};
+}
+
+#endif // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/bool_type.h
+++ b/include/yaml-cpp/node/detail/bool_type.h
@@ -0,0 +1,26 @@
+#ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML
+{
+	namespace detail
+	{
+		struct unspecified_bool {
+			struct NOT_ALLOWED;
+			static void true_value(NOT_ALLOWED*) {}
+		};
+		typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*);
+	}
+}
+
+#define YAML_CPP_OPERATOR_BOOL()\
+operator YAML::detail::unspecified_bool_type() const\
+{\
+	return this->operator!() ? 0 : &YAML::detail::unspecified_bool::true_value;\
+}
+
+#endif // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/impl.h
+++ b/include/yaml-cpp/node/detail/impl.h
@@ -0,0 +1,142 @@
+#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/detail/node_data.h"
+#include <boost/type_traits.hpp>
+
+namespace YAML
+{
+	namespace detail
+	{
+		template<typename Key, typename Enable = void>
+		struct get_idx {
+			static node *get(const std::vector<node *>& /* sequence */, const Key& /* key */, shared_memory_holder /* pMemory */) {
+				return 0;
+			}
+		};
+
+		template<typename Key>
+		struct get_idx<Key, typename boost::enable_if<boost::is_unsigned<Key> >::type> {
+			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder /* pMemory */) {
+				return key < sequence.size() ? sequence[key] : 0;
+			}
+
+			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
+				if(key > sequence.size())
+					return 0;
+				if(key == sequence.size())
+					sequence.push_back(&pMemory->create_node());
+				return sequence[key];
+			}
+		};
+		
+		template<typename Key>
+		struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> {
+			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
+				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
+			}
+			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
+				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
+			}
+		};
+
+		// indexing
+		template<typename Key>
+		inline node& node_data::get(const Key& key, shared_memory_holder pMemory) const
+		{
+			switch(m_type) {
+				case NodeType::Map:
+					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+					return pMemory->create_node();
+				case NodeType::Sequence:
+					if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory))
+						return *pNode;
+					return pMemory->create_node();
+				case NodeType::Scalar:
+                    throw BadSubscript();
+			}
+
+			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
+				if(equals(*it->first, key, pMemory))
+					return *it->second;
+			}
+			
+			return pMemory->create_node();
+		}
+		
+		template<typename Key>
+		inline node& node_data::get(const Key& key, shared_memory_holder pMemory)
+		{
+			switch(m_type) {
+				case NodeType::Map:
+					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Sequence:
+					if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
+						m_type = NodeType::Sequence;
+						return *pNode;
+					}
+					
+					convert_to_map(pMemory);
+					break;
+				case NodeType::Scalar:
+                    throw BadSubscript();
+			}
+			
+			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
+				if(equals(*it->first, key, pMemory))
+					return *it->second;
+			}
+			
+			node& k = convert_to_node(key, pMemory);
+			node& v = pMemory->create_node();
+			insert_map_pair(k, v);
+			return v;
+		}
+		
+		template<typename Key>
+		inline bool node_data::remove(const Key& key, shared_memory_holder pMemory)
+		{
+			if(m_type != NodeType::Map)
+				return false;
+			
+			for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
+				if(equals(*it->first, key, pMemory)) {
+					m_map.erase(it);
+					return true;
+				}
+			}
+			
+			return false;
+		}
+
+		template<typename T>
+		inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory)
+		{
+			T lhs;
+			if(convert<T>::decode(Node(node, pMemory), lhs))
+				return lhs == rhs;
+			return false;
+		}
+		
+		template<typename T>
+		inline node& node_data::convert_to_node(const T& rhs, shared_memory_holder pMemory)
+		{
+			Node value = convert<T>::encode(rhs);
+			value.EnsureNodeExists();
+			pMemory->merge(*value.m_pMemory);
+			return *value.m_pNode;
+		}
+	}
+}
+
+#endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/iterator.h
+++ b/include/yaml-cpp/node/detail/iterator.h
@@ -0,0 +1,64 @@
+#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/utility.hpp>
+
+namespace YAML
+{
+	namespace detail
+	{
+		struct iterator_value;
+
+		template<typename V>
+		class iterator_base: public boost::iterator_adaptor<
+		iterator_base<V>,
+		node_iterator,
+		V,
+		std::forward_iterator_tag,
+		V>
+		{
+		private:
+			template<typename> friend class iterator_base;
+			struct enabler {};
+			typedef typename iterator_base::base_type base_type;
+            
+        public:
+			typedef typename iterator_base::value_type value_type;
+			
+		public:
+			iterator_base() {}
+			explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
+			
+			template<class W>
+			iterator_base(const iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()): iterator_base::iterator_adaptor_(rhs.base()), m_pMemory(rhs.m_pMemory) {}
+		
+		private:
+			friend class boost::iterator_core_access;
+
+			void increment() { this->base_reference() = boost::next(this->base()); }
+			
+			value_type dereference() const {
+				const typename base_type::value_type& v = *this->base();
+				if(v.pNode)
+					return value_type(Node(*v, m_pMemory));
+				if(v.first && v.second)
+					return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
+				return value_type();
+			}
+		
+		private:
+			shared_memory_holder m_pMemory;
+		};
+	}
+}
+
+#endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/iterator_fwd.h
+++ b/include/yaml-cpp/node/detail/iterator_fwd.h
@@ -0,0 +1,27 @@
+#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include <list>
+#include <utility>
+#include <vector>
+
+namespace YAML
+{
+	class node;
+	
+	namespace detail {
+		struct iterator_value;
+		template<typename V> class iterator_base;
+	}
+
+	typedef detail::iterator_base<detail::iterator_value> iterator;
+	typedef detail::iterator_base<const detail::iterator_value> const_iterator;
+}
+
+#endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/memory.h
+++ b/include/yaml-cpp/node/detail/memory.h
@@ -0,0 +1,39 @@
+#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/node/ptr.h"
+#include <set>
+#include <boost/shared_ptr.hpp>
+
+namespace YAML
+{
+	namespace detail
+	{
+		class memory {
+		public:
+			node& create_node();
+			void merge(const memory& rhs);
+			
+		private:
+			typedef std::set<shared_node> Nodes;
+			Nodes m_nodes;
+		};
+
+		class memory_holder {
+		public:
+			memory_holder(): m_pMemory(new memory) {}
+			
+			node& create_node() { return m_pMemory->create_node(); }
+			void merge(memory_holder& rhs);
+			
+		private:
+			boost::shared_ptr<memory> m_pMemory;
+		};
+	}
+}
+
+#endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/node.h
+++ b/include/yaml-cpp/node/detail/node.h
@@ -0,0 +1,126 @@
+#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_ref.h"
+#include <set>
+#include <boost/utility.hpp>
+
+namespace YAML
+{
+	namespace detail
+	{
+		class node: private boost::noncopyable
+		{
+		public:
+			node(): m_pRef(new node_ref) {}
+
+			bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; }
+			const node_ref *ref() const { return m_pRef.get(); }
+			
+			bool is_defined() const { return m_pRef->is_defined(); }
+			NodeType::value type() const { return m_pRef->type(); }
+			
+			const std::string& scalar() const { return m_pRef->scalar(); }
+			const std::string& tag() const { return m_pRef->tag(); }
+			
+			void mark_defined() {
+				if(is_defined())
+					return;
+				
+				m_pRef->mark_defined();
+				for(nodes::iterator it=m_dependencies.begin();it!=m_dependencies.end();++it)
+					(*it)->mark_defined();
+				m_dependencies.clear();
+			}
+			
+			void add_dependency(node& rhs) {
+				if(is_defined())
+					rhs.mark_defined();
+				else
+					m_dependencies.insert(&rhs);
+			}
+			
+			void set_ref(const node& rhs) {
+				if(rhs.is_defined())
+					mark_defined();
+				m_pRef = rhs.m_pRef;
+			}
+			void set_data(const node& rhs) {
+				if(rhs.is_defined())
+					mark_defined();
+				m_pRef->set_data(*rhs.m_pRef);
+			}
+				
+			void set_type(NodeType::value type) {
+				if(type != NodeType::Undefined)
+					mark_defined();
+				m_pRef->set_type(type);
+			}
+			void set_null() {
+				mark_defined();
+				m_pRef->set_null();
+			}
+			void set_scalar(const std::string& scalar) {
+				mark_defined();
+				m_pRef->set_scalar(scalar);
+			}
+			void set_tag(const std::string& tag) {
+				mark_defined();
+				m_pRef->set_tag(tag);
+			}
+
+			// size/iterator
+			std::size_t size() const { return m_pRef->size(); }
+			
+			const_node_iterator begin() const { return static_cast<const node_ref&>(*m_pRef).begin(); }
+			node_iterator begin() { return m_pRef->begin(); }
+			
+			const_node_iterator end() const { return static_cast<const node_ref&>(*m_pRef).end(); }
+			node_iterator end() { return m_pRef->end(); }
+
+			// sequence
+			void push_back(node& node, shared_memory_holder pMemory) {
+				m_pRef->push_back(node, pMemory);
+				node.add_dependency(*this);
+			}
+			void insert(node& key, node& value, shared_memory_holder pMemory) {
+				m_pRef->insert(key, value, pMemory);
+				key.add_dependency(*this);
+				value.add_dependency(*this);
+			}
+
+			// indexing
+			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); }
+			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) {
+				node& value = m_pRef->get(key, pMemory);
+				value.add_dependency(*this);
+				return value;
+			}
+			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
+			
+			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); }
+			node& get(node& key, shared_memory_holder pMemory) {
+				node& value = m_pRef->get(key, pMemory);
+				key.add_dependency(*this);
+				value.add_dependency(*this);
+				return value;
+			}
+			bool remove(node& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
+
+		private:
+			shared_node_ref m_pRef;
+			typedef std::set<node *> nodes;
+			nodes m_dependencies;
+		};
+	}
+}
+
+#endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/node_data.h
+++ b/include/yaml-cpp/node/detail/node_data.h
@@ -0,0 +1,105 @@
+#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+#include <boost/utility.hpp>
+#include <list>
+#include <utility>
+#include <vector>
+
+namespace YAML
+{
+	namespace detail
+	{
+		class node_data: private boost::noncopyable
+		{
+		public:
+			node_data();
+			
+			void mark_defined();
+			void set_type(NodeType::value type);
+			void set_tag(const std::string& tag);
+			void set_null();
+			void set_scalar(const std::string& scalar);
+			
+			bool is_defined() const { return m_isDefined; }
+			NodeType::value type() const { return m_isDefined ? m_type : NodeType::Undefined; }
+			const std::string& scalar() const { return m_scalar; }
+			const std::string& tag() const { return m_tag; }
+			
+			// size/iterator
+			std::size_t size() const;
+			
+			const_node_iterator begin() const;
+			node_iterator begin();
+			
+			const_node_iterator end() const;
+			node_iterator end();
+
+			// sequence
+			void push_back(node& node, shared_memory_holder pMemory);
+			void insert(node& key, node& value, shared_memory_holder pMemory);
+
+			// indexing
+			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const;
+			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory);
+			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory);
+			
+			node& get(node& key, shared_memory_holder pMemory) const;
+			node& get(node& key, shared_memory_holder pMemory);
+			bool remove(node& key, shared_memory_holder pMemory);
+			
+		public:
+			static std::string empty_scalar;
+			
+		private:
+			void compute_seq_size() const;
+			void compute_map_size() const;
+
+			void reset_sequence();
+			void reset_map();
+			
+			void insert_map_pair(node& key, node& value);
+			void convert_to_map(shared_memory_holder pMemory);
+			void convert_sequence_to_map(shared_memory_holder pMemory);
+			
+			template<typename T>
+			static bool equals(node& node, const T& rhs, shared_memory_holder pMemory);
+			
+			template<typename T>
+			static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);
+
+		private:
+			bool m_isDefined;
+			NodeType::value m_type;
+			std::string m_tag;
+			
+			// scalar
+			std::string m_scalar;
+			
+			// sequence
+			typedef std::vector<node *> node_seq;
+			node_seq m_sequence;
+			
+			mutable std::size_t m_seqSize;
+			
+			// map
+			typedef std::map<node *, node *> node_map;
+			node_map m_map;
+			
+			typedef std::pair<node *, node *> kv_pair;
+			typedef std::list<kv_pair> kv_pairs;
+			mutable kv_pairs m_undefinedPairs;
+		};
+	}
+}
+
+#endif // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/node_iterator.h
+++ b/include/yaml-cpp/node/detail/node_iterator.h
@@ -0,0 +1,139 @@
+#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/ptr.h"
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <map>
+#include <utility>
+#include <vector>
+
+namespace YAML
+{
+	namespace detail
+	{
+		struct iterator_type { enum value { None, Sequence, Map }; };
+		
+		template<typename V>
+		struct node_iterator_value: public std::pair<V*, V*> {
+			typedef std::pair<V*, V*> kv;
+			
+			node_iterator_value(): kv(), pNode(0) {}
+			explicit node_iterator_value(V& rhs): kv(), pNode(&rhs) {}
+			explicit node_iterator_value(V& key, V& value): kv(&key, &value), pNode(0) {}
+			
+			V& operator *() const { return *pNode; }
+			V& operator ->() const { return *pNode; }
+			
+			V *pNode;
+		};
+		
+		typedef std::vector<node *> node_seq;
+		typedef std::map<node *, node *> node_map;
+		
+		template<typename V>
+		struct node_iterator_type {
+			typedef node_seq::iterator seq;
+			typedef node_map::iterator map;
+		};
+		
+		template<typename V>
+		struct node_iterator_type<const V> {
+			typedef node_seq::const_iterator seq;
+			typedef node_map::const_iterator map;
+		};
+		
+
+		template<typename V>
+		class node_iterator_base: public boost::iterator_facade<
+		node_iterator_base<V>,
+		node_iterator_value<V>,
+		std::forward_iterator_tag,
+		node_iterator_value<V> >
+		{
+		private:
+			struct enabler {};
+			
+		public:
+			typedef typename node_iterator_type<V>::seq SeqIter;
+			typedef typename node_iterator_type<V>::map MapIter;
+			typedef node_iterator_value<V> value_type;
+			
+			node_iterator_base(): m_type(iterator_type::None) {}
+			explicit node_iterator_base(SeqIter seqIt): m_type(iterator_type::Sequence), m_seqIt(seqIt) {}
+			explicit node_iterator_base(MapIter mapIt, MapIter mapEnd): m_type(iterator_type::Map), m_mapIt(mapIt), m_mapEnd(mapEnd) {
+				m_mapIt = increment_until_defined(m_mapIt);
+			}
+			
+			template<typename W>
+			node_iterator_base(const node_iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler())
+			: m_type(rhs.m_type), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt), m_mapEnd(rhs.m_mapEnd) {}
+			
+		private:
+			friend class boost::iterator_core_access;
+			template<typename> friend class node_iterator_base;
+			
+			template<typename W>
+			bool equal(const node_iterator_base<W>& rhs) const {
+				if(m_type != rhs.m_type)
+					return false;
+				
+				switch(m_type) {
+					case iterator_type::None: return true;
+					case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt;
+					case iterator_type::Map: return m_mapIt == rhs.m_mapIt;
+				}
+				return true;
+			}
+			
+			void increment() {
+				switch(m_type) {
+					case iterator_type::None: break;
+					case iterator_type::Sequence:
+						++m_seqIt;
+						break;
+					case iterator_type::Map:
+						++m_mapIt;
+						m_mapIt = increment_until_defined(m_mapIt);
+						break;
+				}
+			}
+
+			value_type dereference() const {
+				switch(m_type) {
+					case iterator_type::None: return value_type();
+					case iterator_type::Sequence: return value_type(**m_seqIt);
+					case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
+				}
+				return value_type();
+			}
+			
+			MapIter increment_until_defined(MapIter it) {
+				while(it != m_mapEnd && !is_defined(it))
+					++it;
+				return it;
+			}
+			
+			bool is_defined(MapIter it) const {
+				return it->first->is_defined() && it->second->is_defined();
+			}
+
+		private:
+			typename iterator_type::value m_type;
+
+			SeqIter m_seqIt;
+			MapIter m_mapIt, m_mapEnd;
+		};
+
+		typedef node_iterator_base<node> node_iterator;
+		typedef node_iterator_base<const node> const_node_iterator;
+	}
+}
+
+#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/detail/node_ref.h
+++ b/include/yaml-cpp/node/detail/node_ref.h
@@ -0,0 +1,65 @@
+#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_data.h"
+#include <boost/utility.hpp>
+
+namespace YAML
+{
+	namespace detail
+	{
+		class node_ref: private boost::noncopyable
+		{
+		public:
+			node_ref(): m_pData(new node_data) {}
+			
+			bool is_defined() const { return m_pData->is_defined(); }
+			NodeType::value type() const { return m_pData->type(); }
+			const std::string& scalar() const { return m_pData->scalar(); }
+			const std::string& tag() const { return m_pData->tag(); }
+			
+			void mark_defined() { m_pData->mark_defined(); }
+			void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; }
+			
+			void set_type(NodeType::value type) { m_pData->set_type(type); }
+			void set_tag(const std::string& tag) { m_pData->set_tag(tag); }
+			void set_null() { m_pData->set_null(); }
+			void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); }
+			
+			// size/iterator
+			std::size_t size() const { return m_pData->size(); }
+			
+			const_node_iterator begin() const { return static_cast<const node_data&>(*m_pData).begin(); }
+			node_iterator begin() {return m_pData->begin(); }
+			
+			const_node_iterator end() const { return static_cast<const node_data&>(*m_pData).end(); }
+			node_iterator end() {return m_pData->end(); }
+
+			// sequence
+			void push_back(node& node, shared_memory_holder pMemory) { m_pData->push_back(node, pMemory); }
+			void insert(node& key, node& value, shared_memory_holder pMemory) { m_pData->insert(key, value, pMemory); }
+			
+			// indexing
+			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
+			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
+			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
+			
+			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
+			node& get(node& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
+			bool remove(node& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
+
+		private:
+			shared_node_data m_pData;
+		};
+	}
+}
+
+#endif // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/emit.h
+++ b/include/yaml-cpp/node/emit.h
@@ -0,0 +1,23 @@
+#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <iosfwd>
+
+namespace YAML
+{
+	class Emitter;
+	class Node;
+	
+	Emitter& operator << (Emitter& out, const Node& node);
+	std::ostream& operator << (std::ostream& out, const Node& node);
+	
+	std::string Dump(const Node& node);
+}
+
+#endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
--- a/include/yaml-cpp/node/impl.h
+++ b/include/yaml-cpp/node/impl.h
@@ -0,0 +1,355 @@
+#ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/exceptions.h"
+#include <string>
+
+namespace YAML
+{
+	inline Node::Node(): m_pNode(0)
+	{
+	}
+	
+	inline Node::Node(NodeType::value type): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
+	{
+		m_pNode->set_type(type);
+	}
+	
+	template<typename T>
+	inline Node::Node(const T& rhs): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
+	{
+		Assign(rhs);
+	}
+	
+    inline Node::Node(const detail::iterator_value& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
+    {
+    }
+
+	inline Node::Node(const Node& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
+	{
+	}
+	
+	inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory): m_pMemory(pMemory), m_pNode(&node)
+	{
+	}
+
+	inline Node::~Node()
+	{
+	}
+
+	inline void Node::EnsureNodeExists() const
+	{
+		if(!m_pNode) {
+			m_pMemory.reset(new detail::memory_holder);
+			m_pNode = &m_pMemory->create_node();
+			m_pNode->set_null();
+		}
+	}
+	
+	inline bool Node::IsDefined() const
+	{
+		return m_pNode ? m_pNode->is_defined() : true;
+	}
+
+	inline NodeType::value Node::Type() const
+	{
+		return m_pNode ? m_pNode->type() : NodeType::Null;
+	}
+	
+	// access
+    
+    // template helpers
+    template<typename T, typename S>
+    struct as_if {
+        explicit as_if(const Node& node_): node(node_) {}
+        const Node& node;
+        
+        const T operator()(const S& fallback) const {
+            if(!node.m_pNode)
+                return fallback;
+            
+            T t;
+            if(convert<T>::decode(node, t))
+                return t;
+            return fallback;
+        }
+    };
+    
+    template<typename S>
+    struct as_if<std::string, S> {
+        explicit as_if(const Node& node_): node(node_) {}
+        const Node& node;
+        
+        const std::string operator()(const S& fallback) const {
+            if(node.Type() != NodeType::Scalar)
+                return fallback;
+            return node.Scalar();
+        }
+    };
+    
+    template<typename T>
+    struct as_if<T, void> {
+        explicit as_if(const Node& node_): node(node_) {}
+        const Node& node;
+        
+        const T operator()() const {
+            if(!node.m_pNode)
+                throw TypedBadConversion<T>();
+			
+            T t;
+            if(convert<T>::decode(node, t))
+                return t;
+            throw TypedBadConversion<T>();
+        }
+    };
+    
+    template<>
+    struct as_if<std::string, void> {
+        explicit as_if(const Node& node_): node(node_) {}
+        const Node& node;
+        
+        const std::string operator()() const {
+            if(node.Type() != NodeType::Scalar)
+                throw TypedBadConversion<std::string>();
+            return node.Scalar();
+        }
+    };
+    
+    // access functions
+	template<typename T>
+	inline const T Node::as() const
+	{
+        return as_if<T, void>(*this)();
+	}
+
+    template<typename T, typename S>
+    inline const T Node::as(const S& fallback) const
+    {
+        return as_if<T, S>(*this)(fallback);
+    }
+    
+	inline const std::string& Node::Scalar() const
+	{
+		return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
+	}
+
+	inline const std::string& Node::Tag() const
+	{
+		return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
+	}
+
+	inline void Node::SetTag(const std::string& tag)
+	{
+		EnsureNodeExists();
+		m_pNode->set_tag(tag);
+	}
+
+	// assignment
+	inline bool Node::is(const Node& rhs) const
+	{
+        if(!m_pNode || !rhs.m_pNode)
+            return false;
+		return m_pNode->is(*rhs.m_pNode);
+	}
+
+	template<typename T>
+	inline Node& Node::operator=(const T& rhs)
+	{
+		Assign(rhs);
+		return *this;
+	}
+	
+	template<typename T>
+	inline void Node::Assign(const T& rhs)
+	{
+		AssignData(convert<T>::encode(rhs));
+	}
+
+	template<>
+	inline void Node::Assign(const std::string& rhs)
+	{
+		EnsureNodeExists();
+		m_pNode->set_scalar(rhs);
+	}
+
+	inline void Node::Assign(const char *rhs)
+	{
+		EnsureNodeExists();
+		m_pNode->set_scalar(rhs);
+	}
+
+	inline void Node::Assign(char *rhs)
+	{
+		EnsureNodeExists();
+		m_pNode->set_scalar(rhs);
+	}
+	
+	inline Node& Node::operator=(const Node& rhs)
+	{
+		if(is(rhs))
+			return *this;
+		AssignNode(rhs);
+		return *this;
+	}
+
+	inline void Node::AssignData(const Node& rhs)
+	{
+		EnsureNodeExists();
+		rhs.EnsureNodeExists();
+		
+		m_pNode->set_data(*rhs.m_pNode);
+		m_pMemory->merge(*rhs.m_pMemory);
+	}
+
+	inline void Node::AssignNode(const Node& rhs)
+	{
+		rhs.EnsureNodeExists();
+
+		if(!m_pNode) {
+			m_pNode = rhs.m_pNode;
+			m_pMemory = rhs.m_pMemory;
+			return;
+		}
+
+		m_pNode->set_ref(*rhs.m_pNode);
+		m_pMemory->merge(*rhs.m_pMemory);
+		m_pNode = rhs.m_pNode;
+	}
+
+	// size/iterator
+	inline std::size_t Node::size() const
+	{
+		return m_pNode ? m_pNode->size() : 0;
+	}
+
+	inline const_iterator Node::begin() const
+	{
+		return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) : const_iterator();
+	}
+	
+	inline iterator Node::begin()
+	{
+		return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
+	}
+
+	inline const_iterator Node::end() const
+	{
+		return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
+	}
+
+	inline iterator Node::end()
+	{
+		return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
+	}
+	
+	// sequence
+	template<typename T>
+	inline void Node::push_back(const T& rhs)
+	{
+		push_back(Node(rhs));
+	}
+	
+	inline void Node::push_back(const Node& rhs)
+	{
+		EnsureNodeExists();
+		rhs.EnsureNodeExists();
+		
+		m_pNode->push_back(*rhs.m_pNode, m_pMemory);
+		m_pMemory->merge(*rhs.m_pMemory);
+	}
+
+	// indexing
+	template<typename Key>
+	inline const Node Node::operator[](const Key& key) const
+	{
+		EnsureNodeExists();
+		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(key, m_pMemory);
+		return Node(value, m_pMemory);
+	}
+	
+	template<typename Key>
+	inline Node Node::operator[](const Key& key)
+	{
+		EnsureNodeExists();
+		detail::node& value = m_pNode->get(key, m_pMemory);
+		return Node(value, m_pMemory);
+	}
+	
+	template<typename Key>
+	inline bool Node::remove(const Key& key)
+	{
+		EnsureNodeExists();
+		return m_pNode->remove(key, m_pMemory);
+	}
+	
+	inline const Node Node::operator[](const Node& key) const
+	{
+		EnsureNodeExists();
+		key.EnsureNodeExists();
+		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
+		return Node(value, m_pMemory);
+	}
+	
+	inline Node Node::operator[](const Node& key)
+	{
+		EnsureNodeExists();
+		key.EnsureNodeExists();
+		detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory);
+		return Node(value, m_pMemory);
+	}
+	
+	inline bool Node::remove(const Node& key)
+	{
+		EnsureNodeExists();
+		key.EnsureNodeExists();
+		return m_pNode->remove(*key.m_pNode, m_pMemory);
+	}
+	
+	inline const Node Node::operator[](const char *key) const
+	{
+		return operator[](std::string(key));
+	}
+	
+	inline Node Node::operator[](const char *key)
+	{
+		return operator[](std::string(key));
+	}
+	
+	inline bool Node::remove(const char *key)
+	{
+		return remove(std::string(key));
+	}
+	
+	inline const Node Node::operator[](char *key) const
+	{
+		return operator[](static_cast<const char *>(key));
+	}
+	
+	inline Node Node::operator[](char *key)
+	{
+		return operator[](static_cast<const char *>(key));
+	}
+	
+	inline bool Node::remove(char *key)
+	{
+		return remove(static_cast<const char *>(key));
+	}
+
+	// free functions
+
+	inline bool operator==(const Node& lhs, const Node& rhs)
+	{
+		return lhs.is(rhs);
+	}
+}
+
+#endif // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/iterator.h
+++ b/include/yaml-cpp/node/iterator.h
@@ -0,0 +1,28 @@
+#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/detail/iterator_fwd.h"
+#include "yaml-cpp/node/detail/iterator.h"
+#include <list>
+#include <utility>
+#include <vector>
+
+namespace YAML
+{
+	namespace detail {
+		struct iterator_value: public Node, std::pair<Node, Node> {
+			iterator_value() {}
+			explicit iterator_value(const Node& rhs): Node(rhs) {}
+			explicit iterator_value(const Node& key, const Node& value): std::pair<Node, Node>(key, value) {}
+		};
+	}
+}
+
+#endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/node.h
+++ b/include/yaml-cpp/node/node.h
@@ -0,0 +1,113 @@
+#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/node/detail/iterator_fwd.h"
+#include "yaml-cpp/node/detail/bool_type.h"
+#include <stdexcept>
+
+namespace YAML
+{
+	class Node
+	{
+	public:
+		friend class NodeBuilder;
+		friend class NodeEvents;
+		friend class detail::node_data;
+		template<typename> friend class detail::iterator_base;
+        template<typename T, typename S> friend struct as_if;
+        
+        typedef YAML::iterator iterator;
+        typedef YAML::const_iterator const_iterator;
+		
+		Node();
+		explicit Node(NodeType::value type);
+		template<typename T> explicit Node(const T& rhs);
+        explicit Node(const detail::iterator_value& rhs);
+		Node(const Node& rhs);
+		~Node();
+		
+		NodeType::value Type() const;
+		bool IsDefined() const;
+		bool IsNull() const { return Type() == NodeType::Null; }
+		bool IsScalar() const { return Type() == NodeType::Scalar; }
+		bool IsSequence() const { return Type() == NodeType::Sequence; }
+		bool IsMap() const { return Type() == NodeType::Map; }
+		
+		// bool conversions
+		YAML_CPP_OPERATOR_BOOL();
+		bool operator!() const { return !IsDefined(); }
+		
+		// access
+		template<typename T> const T as() const;
+		template<typename T, typename S> const T as(const S& fallback) const;
+		const std::string& Scalar() const;
+		const std::string& Tag() const;
+		void SetTag(const std::string& tag);
+
+		// assignment
+		bool is(const Node& rhs) const;
+		template<typename T> Node& operator=(const T& rhs);
+		Node& operator=(const Node& rhs);
+
+		// size/iterator
+		std::size_t size() const;
+
+		const_iterator begin() const;
+		iterator begin();
+		
+		const_iterator end() const;
+		iterator end();
+		
+		// sequence
+		template<typename T> void push_back(const T& rhs);
+		void push_back(const Node& rhs);
+		
+		// indexing
+		template<typename Key> const Node operator[](const Key& key) const;
+		template<typename Key> Node operator[](const Key& key);
+		template<typename Key> bool remove(const Key& key);
+
+		const Node operator[](const Node& key) const;
+		Node operator[](const Node& key);
+		bool remove(const Node& key);
+		
+		const Node operator[](const char *key) const;
+		Node operator[](const char *key);
+		bool remove(const char *key);
+
+		const Node operator[](char *key) const;
+		Node operator[](char *key);
+		bool remove(char *key);
+		
+	private:
+		explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
+		
+		void EnsureNodeExists() const;
+		
+		template<typename T> void Assign(const T& rhs);
+		void Assign(const char *rhs);
+		void Assign(char *rhs);
+
+		void AssignData(const Node& rhs);
+		void AssignNode(const Node& rhs);
+		
+	private:
+		mutable detail::shared_memory_holder m_pMemory;
+		mutable detail::node *m_pNode;
+	};
+
+	bool operator==(const Node& lhs, const Node& rhs);
+	
+	template<typename T>
+	struct convert;
+}
+
+#endif // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/parse.h
+++ b/include/yaml-cpp/node/parse.h
@@ -0,0 +1,28 @@
+#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace YAML
+{
+	class Node;
+	
+	Node Load(const std::string& input);
+	Node Load(const char *input);
+	Node Load(std::istream& input);
+    Node LoadFile(const std::string& filename);
+
+	std::vector<Node> LoadAll(const std::string& input);
+	std::vector<Node> LoadAll(const char *input);
+	std::vector<Node> LoadAll(std::istream& input);
+    std::vector<Node> LoadAllFromFile(const std::string& filename);
+}
+
+#endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
--- a/include/yaml-cpp/node/ptr.h
+++ b/include/yaml-cpp/node/ptr.h
@@ -0,0 +1,29 @@
+#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include "yaml-cpp/dll.h"
+#include <boost/shared_ptr.hpp>
+
+namespace YAML
+{
+	namespace detail {
+		class node;
+		class node_ref;
+		class node_data;
+		class memory;
+		class memory_holder;
+
+		typedef boost::shared_ptr<node> shared_node;
+		typedef boost::shared_ptr<node_ref> shared_node_ref;
+		typedef boost::shared_ptr<node_data> shared_node_data;
+		typedef boost::shared_ptr<memory_holder> shared_memory_holder;
+		typedef boost::shared_ptr<memory> shared_memory;
+	}
+}
+
+#endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/node/type.h
+++ b/include/yaml-cpp/node/type.h
@@ -0,0 +1,14 @@
+#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+namespace YAML
+{
+	struct NodeType { enum value { Undefined, Null, Scalar, Sequence, Map }; };	
+}
+
+#endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/include/yaml-cpp/parser.h
+++ b/include/yaml-cpp/parser.h
@@ -31,7 +31,9 @@ namespace YAML

 		void Load(std::istream& in);
 		bool HandleNextDocument(EventHandler& eventHandler);
-
+		
+		bool GetNextDocument(Node& document); // old API only
+		
 		void PrintTokens(std::ostream& out);

 	private:
--- a/include/yaml-cpp/yaml.h
+++ b/include/yaml-cpp/yaml.h
@@ -10,4 +10,12 @@
 #include "yaml-cpp/stlemitter.h"
 #include "yaml-cpp/exceptions.h"

+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/convert.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/detail/impl.h"
+#include "yaml-cpp/node/parse.h"
+#include "yaml-cpp/node/emit.h"
+
 #endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- a/src/convert.cpp
+++ b/src/convert.cpp
@@ -0,0 +1,83 @@
+#include "yaml-cpp/node/convert.h"
+#include "yaml-cpp/node/impl.h"
+#include <algorithm>
+
+namespace
+{
+	// we're not gonna mess with the mess that is all the isupper/etc. functions
+	bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; }
+	bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; }
+	char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
+	
+	std::string tolower(const std::string& str)
+	{
+		std::string s(str);
+		std::transform(s.begin(), s.end(), s.begin(), ToLower);
+		return s;
+	}
+	
+	template <typename T>
+	bool IsEntirely(const std::string& str, T func)
+	{
+		for(std::size_t i=0;i<str.size();i++)
+			if(!func(str[i]))
+				return false;
+		
+		return true;
+	}
+	
+	// IsFlexibleCase
+	// . Returns true if 'str' is:
+	//   . UPPERCASE
+	//   . lowercase
+	//   . Capitalized
+	bool IsFlexibleCase(const std::string& str)
+	{
+		if(str.empty())
+			return true;
+		
+		if(IsEntirely(str, IsLower))
+			return true;
+		
+		bool firstcaps = IsUpper(str[0]);
+		std::string rest = str.substr(1);
+		return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
+	}
+}
+
+namespace YAML
+{
+	bool convert<bool>::decode(const Node& node, bool& rhs) {
+		if(!node.IsScalar())
+			return false;
+		
+		// we can't use iostream bool extraction operators as they don't
+		// recognize all possible values in the table below (taken from
+		// http://yaml.org/type/bool.html)
+		static const struct {
+			std::string truename, falsename;
+		} names[] = {
+			{ "y", "n" },
+			{ "yes", "no" },
+			{ "true", "false" },
+			{ "on", "off" },
+		};
+		
+		if(!IsFlexibleCase(node.Scalar()))
+			return false;
+		
+		for(unsigned i=0;i<sizeof(names)/sizeof(names[0]);i++) {
+			if(names[i].truename == tolower(node.Scalar())) {
+				rhs = true;
+				return true;
+			}
+			
+			if(names[i].falsename == tolower(node.Scalar())) {
+				rhs = false;
+				return true;
+			}
+		}
+		
+		return false;
+	}
+}
--- a/src/emit.cpp
+++ b/src/emit.cpp
@@ -0,0 +1,30 @@
+#include "yaml-cpp/node/emit.h"
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+#include "nodeevents.h"
+
+namespace YAML
+{
+	Emitter& operator << (Emitter& out, const Node& node)
+	{
+		EmitFromEvents emitFromEvents(out);
+		NodeEvents events(node);
+		events.Emit(emitFromEvents);
+		return out;
+	}
+	
+	std::ostream& operator << (std::ostream& out, const Node& node)
+	{
+		Emitter emitter;
+		emitter << node;
+		out << emitter.c_str();
+		return out;
+	}
+
+	std::string Dump(const Node& node)
+	{
+		Emitter emitter;
+		emitter << node;
+		return emitter.c_str();
+	}
+}
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -0,0 +1,29 @@
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"
+
+namespace YAML
+{
+	namespace detail
+	{
+		void memory_holder::merge(memory_holder& rhs)
+		{
+			if(m_pMemory == rhs.m_pMemory)
+				return;
+			
+			m_pMemory->merge(*rhs.m_pMemory);
+			rhs.m_pMemory = m_pMemory;
+		}
+		
+		node& memory::create_node()
+		{
+			shared_node pNode(new node);
+			m_nodes.insert(pNode);
+			return *pNode;
+		}
+		
+		void memory::merge(const memory& rhs)
+		{
+			m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
+		}
+	}
+}
--- a/src/node_data.cpp
+++ b/src/node_data.cpp
@@ -0,0 +1,295 @@
+#include "yaml-cpp/node/detail/node_data.h"
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/exceptions.h"
+#include <sstream>
+
+namespace YAML
+{
+	namespace detail
+	{
+		std::string node_data::empty_scalar;
+
+		node_data::node_data(): m_isDefined(false), m_type(NodeType::Null), m_seqSize(0)
+		{
+		}
+
+		void node_data::mark_defined()
+		{
+			if(m_type == NodeType::Undefined)
+				m_type = NodeType::Null;
+			m_isDefined = true;
+		}
+
+		void node_data::set_type(NodeType::value type)
+		{
+			if(type == NodeType::Undefined) {
+				m_type = type;
+				m_isDefined = false;
+				return;
+			}
+			
+
+			m_isDefined = true;
+			if(type == m_type)
+				return;
+			
+			m_type = type;
+			
+			switch(m_type) {
+				case NodeType::Null:
+					break;
+				case NodeType::Scalar:
+					m_scalar.clear();
+					break;
+				case NodeType::Sequence:
+					reset_sequence();
+					break;
+				case NodeType::Map:
+					reset_map();
+					break;
+				case NodeType::Undefined:
+					assert(false);
+					break;
+			}
+		}
+
+		void node_data::set_tag(const std::string& tag)
+		{
+			m_tag = tag;
+		}
+		
+		void node_data::set_null()
+		{
+			m_isDefined = true;
+			m_type = NodeType::Null;
+		}
+		
+		void node_data::set_scalar(const std::string& scalar)
+		{
+			m_isDefined = true;
+			m_type = NodeType::Scalar;
+			m_scalar = scalar;
+		}
+
+		// size/iterator
+		std::size_t node_data::size() const
+		{
+			if(!m_isDefined)
+				return 0;
+
+			switch(m_type) {
+				case NodeType::Sequence: compute_seq_size(); return m_seqSize;
+				case NodeType::Map: compute_map_size(); return m_map.size() - m_undefinedPairs.size();
+				default:
+					return 0;
+			}
+			return 0;
+		}
+		
+		void node_data::compute_seq_size() const
+		{
+			while(m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
+				m_seqSize++;
+		}
+
+		void node_data::compute_map_size() const
+		{
+			kv_pairs::iterator it = m_undefinedPairs.begin();
+			while(it != m_undefinedPairs.end()) {
+				kv_pairs::iterator jt = boost::next(it);
+				if(it->first->is_defined() && it->second->is_defined())
+					m_undefinedPairs.erase(it);
+				it = jt;
+			}
+		}
+		
+		const_node_iterator node_data::begin() const
+		{
+			if(!m_isDefined)
+				return const_node_iterator();
+			
+			switch(m_type) {
+				case NodeType::Sequence: return const_node_iterator(m_sequence.begin());
+				case NodeType::Map: return const_node_iterator(m_map.begin(), m_map.end());
+				default: return const_node_iterator();
+			}
+		}
+		
+		node_iterator node_data::begin()
+		{
+			if(!m_isDefined)
+				return node_iterator();
+
+			switch(m_type) {
+				case NodeType::Sequence: return node_iterator(m_sequence.begin());
+				case NodeType::Map: return node_iterator(m_map.begin(), m_map.end());
+				default: return node_iterator();
+			}
+		}
+		
+		const_node_iterator node_data::end() const
+		{
+			if(!m_isDefined)
+				return const_node_iterator();
+
+			switch(m_type) {
+				case NodeType::Sequence: return const_node_iterator(m_sequence.end());
+				case NodeType::Map: return const_node_iterator(m_map.end(), m_map.end());
+				default: return const_node_iterator();
+			}
+		}
+		
+		node_iterator node_data::end()
+		{
+			if(!m_isDefined)
+				return node_iterator();
+
+			switch(m_type) {
+				case NodeType::Sequence: return node_iterator(m_sequence.end());
+				case NodeType::Map: return node_iterator(m_map.end(), m_map.end());
+				default: return node_iterator();
+			}
+		}
+
+		// sequence
+		void node_data::push_back(node& node, shared_memory_holder /* pMemory */)
+		{
+			if(m_type == NodeType::Undefined || m_type == NodeType::Null) {
+				m_type = NodeType::Sequence;
+				reset_sequence();
+			}
+			
+			if(m_type != NodeType::Sequence)
+                throw BadPushback();
+			
+			m_sequence.push_back(&node);
+		}
+
+		void node_data::insert(node& key, node& value, shared_memory_holder pMemory)
+		{
+			switch(m_type) {
+				case NodeType::Map:
+					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Sequence:
+					convert_to_map(pMemory);
+					break;
+				case NodeType::Scalar:
+                    throw BadSubscript();
+			}
+
+			insert_map_pair(key, value);
+		}
+
+		// indexing
+		node& node_data::get(node& key, shared_memory_holder pMemory) const
+		{
+			if(m_type != NodeType::Map)
+				return pMemory->create_node();
+			
+			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
+				if(it->first->is(key))
+					return *it->second;
+			}
+			
+			return pMemory->create_node();
+		}
+		
+		node& node_data::get(node& key, shared_memory_holder pMemory)
+		{
+			switch(m_type) {
+				case NodeType::Map:
+					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Sequence:
+					convert_to_map(pMemory);
+					break;
+				case NodeType::Scalar:
+                    throw BadSubscript();
+			}
+
+			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
+				if(it->first->is(key))
+					return *it->second;
+			}
+			
+			node& value = pMemory->create_node();
+			insert_map_pair(key, value);
+			return value;
+		}
+		
+		bool node_data::remove(node& key, shared_memory_holder /* pMemory */)
+		{
+			if(m_type != NodeType::Map)
+				return false;
+
+			for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
+				if(it->first->is(key)) {
+					m_map.erase(it);
+					return true;
+				}
+			}
+			
+			return false;
+		}
+
+		void node_data::reset_sequence()
+		{
+			m_sequence.clear();
+			m_seqSize = 0;
+		}
+
+		void node_data::reset_map()
+		{
+			m_map.clear();
+			m_undefinedPairs.clear();
+		}
+
+		void node_data::insert_map_pair(node& key, node& value)
+		{
+			m_map[&key] = &value;
+			if(!key.is_defined() || !value.is_defined())
+				m_undefinedPairs.push_back(kv_pair(&key, &value));
+		}
+
+		void node_data::convert_to_map(shared_memory_holder pMemory)
+		{
+			switch(m_type) {
+				case NodeType::Undefined:
+				case NodeType::Null:
+					reset_map();
+					m_type = NodeType::Map;
+					break;
+				case NodeType::Sequence:
+					convert_sequence_to_map(pMemory);
+					break;
+				case NodeType::Map:
+					break;
+				case NodeType::Scalar:
+					assert(false);
+					break;
+			}
+		}
+
+		void node_data::convert_sequence_to_map(shared_memory_holder pMemory)
+		{
+			assert(m_type == NodeType::Sequence);
+
+			reset_map();
+			for(std::size_t i=0;i<m_sequence.size();i++) {
+				std::stringstream stream;
+				stream << i;
+
+				node& key = pMemory->create_node();
+				key.set_scalar(stream.str());
+				insert_map_pair(key, *m_sequence[i]);
+			}
+			
+			reset_sequence();
+			m_type = NodeType::Map;
+		}
+	}
+}
--- a/src/nodebuilder.cpp
+++ b/src/nodebuilder.cpp
@@ -0,0 +1,138 @@
+#include "nodebuilder.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include <cassert>
+
+namespace YAML
+{
+	NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
+	{
+		m_anchors.push_back(0); // since the anchors start at 1
+	}
+	
+	NodeBuilder::~NodeBuilder()
+	{
+	}
+	
+	Node NodeBuilder::Root()
+	{
+		if(!m_pRoot)
+			return Node();
+		
+		return Node(*m_pRoot, m_pMemory);
+	}
+
+	void NodeBuilder::OnDocumentStart(const Mark&)
+	{
+	}
+	
+	void NodeBuilder::OnDocumentEnd()
+	{
+	}
+	
+	void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor)
+	{
+		detail::node& node = Push(anchor);
+		node.set_null();
+		Pop();
+	}
+	
+	void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor)
+	{
+		detail::node& node = *m_anchors[anchor];
+		Push(node);
+		Pop();
+	}
+	
+	void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag, anchor_t anchor, const std::string& value)
+	{
+		detail::node& node = Push(anchor);
+		node.set_scalar(value);
+		node.set_tag(tag);
+		Pop();
+	}
+	
+	void NodeBuilder::OnSequenceStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
+	{
+		detail::node& node = Push(anchor);
+		node.set_tag(tag);
+		node.set_type(NodeType::Sequence);
+	}
+	
+	void NodeBuilder::OnSequenceEnd()
+	{
+		Pop();
+	}
+	
+	void NodeBuilder::OnMapStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
+	{
+		detail::node& node = Push(anchor);
+		node.set_type(NodeType::Map);
+		node.set_tag(tag);
+		m_mapDepth++;
+	}
+	
+	void NodeBuilder::OnMapEnd()
+	{
+		assert(m_mapDepth > 0);
+		m_mapDepth--;
+		Pop();
+	}
+
+	detail::node& NodeBuilder::Push(anchor_t anchor)
+	{
+		detail::node& node = m_pMemory->create_node();
+		RegisterAnchor(anchor, node);
+		Push(node);
+		return node;
+	}
+	
+	void NodeBuilder::Push(detail::node& node)
+	{
+		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
+		
+		m_stack.push_back(&node);
+		if(needsKey)
+			m_keys.push_back(PushedKey(&node, false));
+	}
+	
+	void NodeBuilder::Pop()
+	{
+		assert(!m_stack.empty());
+		if(m_stack.size() == 1) {
+			m_pRoot = m_stack[0];
+			m_stack.pop_back();
+			return;
+		}
+		
+		detail::node& node = *m_stack.back();
+		m_stack.pop_back();
+
+		detail::node& collection = *m_stack.back();
+		
+		if(collection.type() == NodeType::Sequence) {
+			collection.push_back(node, m_pMemory);
+		} else if(collection.type() == NodeType::Map) {
+			assert(!m_keys.empty());
+			PushedKey& key = m_keys.back();
+			if(key.second) {
+				collection.insert(*key.first, node, m_pMemory);
+				m_keys.pop_back();
+			} else {
+				key.second = true;
+			}
+		} else {
+			assert(false);
+			m_stack.clear();
+		}
+	}
+
+	void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
+	{
+		if(anchor) {
+			assert(anchor == m_anchors.size());
+			m_anchors.push_back(&node);
+		}
+	}
+}
--- a/src/nodebuilder.h
+++ b/src/nodebuilder.h
@@ -0,0 +1,58 @@
+#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/node/ptr.h"
+#include <vector>
+
+namespace YAML
+{
+	class Node;
+
+	class NodeBuilder: public EventHandler
+	{
+	public:
+		NodeBuilder();
+		virtual ~NodeBuilder();
+		
+		Node Root();
+		
+		virtual void OnDocumentStart(const Mark& mark);
+		virtual void OnDocumentEnd();
+		
+		virtual void OnNull(const Mark& mark, anchor_t anchor);
+		virtual void OnAlias(const Mark& mark, anchor_t anchor);
+		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value);
+		
+		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnSequenceEnd();
+		
+		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnMapEnd();
+		
+	private:
+		detail::node& Push(anchor_t anchor);
+		void Push(detail::node& node);
+		void Pop();
+		void RegisterAnchor(anchor_t anchor, detail::node& node);
+		
+	private:
+		detail::shared_memory_holder m_pMemory;
+		detail::node *m_pRoot;
+		
+		typedef std::vector<detail::node *> Nodes;
+		Nodes m_stack;
+		Nodes m_anchors;
+
+		typedef std::pair<detail::node *, bool> PushedKey;
+		std::vector<PushedKey> m_keys;
+		std::size_t m_mapDepth;
+	};
+}
+
+#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
--- a/src/nodeevents.cpp
+++ b/src/nodeevents.cpp
@@ -0,0 +1,99 @@
+#include "nodeevents.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/mark.h"
+
+namespace YAML
+{
+	void NodeEvents::AliasManager::RegisterReference(const detail::node& node)
+	{
+		m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
+	}
+	
+	anchor_t NodeEvents::AliasManager::LookupAnchor(const detail::node& node) const
+	{
+		AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
+		if(it == m_anchorByIdentity.end())
+			return 0;
+		return it->second;
+	}
+
+	NodeEvents::NodeEvents(const Node& node): m_pMemory(node.m_pMemory), m_root(*node.m_pNode)
+	{
+		Setup(m_root);
+	}
+
+	void NodeEvents::Setup(const detail::node& node)
+	{
+		int& refCount = m_refCount[node.ref()];
+		refCount++;
+		if(refCount > 1)
+			return;
+		
+		if(node.type() == NodeType::Sequence) {
+			for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
+				Setup(**it);
+		} else if(node.type() == NodeType::Map) {
+			for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
+				Setup(*it->first);
+				Setup(*it->second);
+			}
+		}
+	}
+
+	void NodeEvents::Emit(EventHandler& handler)
+	{
+		AliasManager am;
+		
+		handler.OnDocumentStart(Mark());
+		Emit(m_root, handler, am);
+		handler.OnDocumentEnd();
+	}
+
+	void NodeEvents::Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const
+	{
+		anchor_t anchor = NullAnchor;
+		if(IsAliased(node)) {
+			anchor = am.LookupAnchor(node);
+			if(anchor) {
+				handler.OnAlias(Mark(), anchor);
+				return;
+			}
+			
+			am.RegisterReference(node);
+			anchor = am.LookupAnchor(node);
+		}
+		
+		switch(node.type()) {
+			case NodeType::Undefined:
+				break;
+			case NodeType::Null:
+				handler.OnNull(Mark(), anchor);
+				break;
+			case NodeType::Scalar:
+				handler.OnScalar(Mark(), node.tag(), anchor, node.scalar());
+				break;
+			case NodeType::Sequence:
+				handler.OnSequenceStart(Mark(), node.tag(), anchor);
+				for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
+					Emit(**it, handler, am);
+				handler.OnSequenceEnd();
+				break;
+			case NodeType::Map:
+				handler.OnMapStart(Mark(), node.tag(), anchor);
+				for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
+					Emit(*it->first, handler, am);
+					Emit(*it->second, handler, am);
+				}
+				handler.OnMapEnd();
+				break;
+		}
+	}
+
+	bool NodeEvents::IsAliased(const detail::node& node) const
+	{
+		RefCount::const_iterator it = m_refCount.find(node.ref());
+		return it != m_refCount.end() && it->second > 1;
+	}
+}
--- a/src/nodeevents.h
+++ b/src/nodeevents.h
@@ -0,0 +1,57 @@
+#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/node/ptr.h"
+#include <map>
+#include <vector>
+
+namespace YAML
+{
+	class EventHandler;
+	class Node;
+	
+	class NodeEvents
+	{
+	public:
+		explicit NodeEvents(const Node& node);
+		
+		void Emit(EventHandler& handler);
+		
+	private:
+		class AliasManager {
+		public:
+			AliasManager(): m_curAnchor(0) {}
+			
+			void RegisterReference(const detail::node& node);
+			anchor_t LookupAnchor(const detail::node& node) const;
+			
+		private:
+			anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
+			
+		private:
+			typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity;
+			AnchorByIdentity m_anchorByIdentity;
+			
+			anchor_t m_curAnchor;
+		};
+		
+		void Setup(const detail::node& node);
+		void Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const;
+		bool IsAliased(const detail::node& node) const;
+		
+	private:
+		detail::shared_memory_holder m_pMemory;
+		detail::node& m_root;
+		
+		typedef std::map<const detail::node_ref *, int> RefCount;
+		RefCount m_refCount;
+	};
+}
+
+#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
--- a/src/parse.cpp
+++ b/src/parse.cpp
@@ -0,0 +1,64 @@
+#include "yaml-cpp/node/parse.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/parser.h"
+#include "nodebuilder.h"
+
+#include <fstream>
+#include <sstream>
+
+namespace YAML
+{
+	Node Load(const std::string& input) {
+		std::stringstream stream(input);
+		return Load(stream);
+	}
+	
+	Node Load(const char *input) {
+		std::stringstream stream(input);
+		return Load(stream);
+	}
+	
+	Node Load(std::istream& input) {
+		Parser parser(input);
+		NodeBuilder builder;
+		if(!parser.HandleNextDocument(builder))
+			return Node();
+		
+		return builder.Root();
+	}
+
+    Node LoadFile(const std::string& filename) {
+        std::ifstream fin(filename.c_str());
+        return Load(fin);
+    }
+
+	std::vector<Node> LoadAll(const std::string& input) {
+		std::stringstream stream(input);
+		return LoadAll(stream);
+	}
+	
+	std::vector<Node> LoadAll(const char *input) {
+		std::stringstream stream(input);
+		return LoadAll(stream);
+	}
+	
+	std::vector<Node> LoadAll(std::istream& input) {
+		std::vector<Node> docs;
+		
+		Parser parser(input);
+		while(1) {
+			NodeBuilder builder;
+			if(!parser.HandleNextDocument(builder))
+				break;
+			docs.push_back(builder.Root());
+		}
+		
+		return docs;
+	}
+
+    std::vector<Node> LoadAllFromFile(const std::string& filename) {
+        std::ifstream fin(filename.c_str());
+        return LoadAll(fin);
+    }
+}
--- a/src/singledocparser.cpp
+++ b/src/singledocparser.cpp
@@ -253,7 +253,6 @@ namespace YAML
 				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP_FLOW);
 			
 			Token& token = m_scanner.peek();
-            const Mark mark = token.mark;
 			// first check for end
 			if(token.type == Token::FLOW_MAP_END) {
 				m_scanner.pop();
@@ -265,7 +264,7 @@ namespace YAML
 				m_scanner.pop();
 				HandleNode(eventHandler);
 			} else {
-				eventHandler.OnNull(mark, NullAnchor);
+				eventHandler.OnNull(token.mark, NullAnchor);
 			}
 			
 			// now grab value (optional)
@@ -273,7 +272,7 @@ namespace YAML
 				m_scanner.pop();
 				HandleNode(eventHandler);
 			} else {
-				eventHandler.OnNull(mark, NullAnchor);
+				eventHandler.OnNull(token.mark, NullAnchor);
 			}
 			
 			// now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,8 +1,8 @@
 file(GLOB test_headers [a-z]*.h)
 file(GLOB test_sources [a-z]*.cpp)
-file(GLOB test_core_sources core/[a-z]*.cpp)
+file(GLOB test_new_api_sources new-api/[a-z]*.cpp)

-list(APPEND test_sources ${test_core_sources})
+list(APPEND test_sources ${test_new_api_sources})

 include_directories(${YAML_CPP_SOURCE_DIR}/test)

--- a/test/emittertests.cpp
+++ b/test/emittertests.cpp
@@ -1,6 +1,5 @@
 #include "tests.h"
 #include "yaml-cpp/yaml.h"
-#include "yaml-cpp/eventhandler.h"
 #include <iostream>

 namespace Test
@@ -1000,21 +999,6 @@ namespace Test
 	}
 	
 	namespace {
-        class NullEventHandler: public YAML::EventHandler {
-            virtual void OnDocumentStart(const YAML::Mark&) {}
-            virtual void OnDocumentEnd() {}
-            
-            virtual void OnNull(const YAML::Mark&, YAML::anchor_t) {}
-            virtual void OnAlias(const YAML::Mark&, YAML::anchor_t) {}
-            virtual void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t, const std::string&) {}
-            
-            virtual void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
-            virtual void OnSequenceEnd() {}
-            
-            virtual void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
-            virtual void OnMapEnd() {}
-        };
-        
 		void RunEmitterTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, int& passed, int& total) {
 			YAML::Emitter out;
 			std::string desiredOutput;
@@ -1024,10 +1008,7 @@ namespace Test

 			if(output == desiredOutput) {
 				try {
-					std::stringstream stream(output);
-					YAML::Parser parser;
-                    NullEventHandler handler;
-                    parser.HandleNextDocument(handler);
+                    YAML::Node node = YAML::Load(output);
 					passed++;
 				} catch(const YAML::Exception& e) {
 					std::cout << "Emitter test failed: " << name << "\n";
--- a/test/new-api/nodetests.cpp
+++ b/test/new-api/nodetests.cpp
@@ -0,0 +1,433 @@
+#include "nodetests.h"
+#include "yaml-cpp/yaml.h"
+#include <boost/foreach.hpp>
+#include <iostream>
+
+namespace {
+	struct TEST {
+		TEST(): ok(false) {}
+		TEST(bool ok_): ok(ok_) {}
+		TEST(const char *error_): ok(false), error(error_) {}
+		
+		bool ok;
+		std::string error;
+	};
+}
+
+#define YAML_ASSERT(cond) do { if(!(cond)) return "  Assert failed: " #cond; } while(false)
+
+#define YAML_ASSERT_THROWS(cond, exc) do { try { (cond); return "  Expression did not throw: " #cond; } catch(const exc&) {} catch(...) { return "  Expression threw something other than " #exc ": " #cond; } } while(false)
+
+namespace Test
+{
+	namespace Node
+	{
+		TEST SimpleScalar()
+		{
+			YAML::Node node = YAML::Node("Hello, World!");
+			YAML_ASSERT(node.IsScalar());
+			YAML_ASSERT(node.as<std::string>() == "Hello, World!");
+			return true;
+		}
+		
+		TEST IntScalar()
+		{
+			YAML::Node node = YAML::Node(15);
+			YAML_ASSERT(node.IsScalar());
+			YAML_ASSERT(node.as<int>() == 15);
+			return true;
+		}
+
+		TEST SimpleAppendSequence()
+		{
+			YAML::Node node;
+			node.push_back(10);
+			node.push_back("foo");
+			node.push_back("monkey");
+			YAML_ASSERT(node.IsSequence());
+			YAML_ASSERT(node.size() == 3);
+			YAML_ASSERT(node[0].as<int>() == 10);
+			YAML_ASSERT(node[1].as<std::string>() == "foo");
+			YAML_ASSERT(node[2].as<std::string>() == "monkey");
+			YAML_ASSERT(node.IsSequence());
+			return true;
+		}
+
+		TEST SimpleAssignSequence()
+		{
+			YAML::Node node;
+			node[0] = 10;
+			node[1] = "foo";
+			node[2] = "monkey";
+			YAML_ASSERT(node.IsSequence());
+			YAML_ASSERT(node.size() == 3);
+			YAML_ASSERT(node[0].as<int>() == 10);
+			YAML_ASSERT(node[1].as<std::string>() == "foo");
+			YAML_ASSERT(node[2].as<std::string>() == "monkey");
+			YAML_ASSERT(node.IsSequence());
+			return true;
+		}
+
+		TEST SimpleMap()
+		{
+			YAML::Node node;
+			node["key"] = "value";
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node["key"].as<std::string>() == "value");
+			YAML_ASSERT(node.size() == 1);
+			return true;
+		}
+
+		TEST MapWithUndefinedValues()
+		{
+			YAML::Node node;
+			node["key"] = "value";
+			node["undefined"];
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node["key"].as<std::string>() == "value");
+			YAML_ASSERT(node.size() == 1);
+
+			node["undefined"] = "monkey";
+			YAML_ASSERT(node["undefined"].as<std::string>() == "monkey");
+			YAML_ASSERT(node.size() == 2);
+			
+			return true;
+		}
+		
+		TEST MapIteratorWithUndefinedValues()
+		{
+			YAML::Node node;
+			node["key"] = "value";
+			node["undefined"];
+			
+			std::size_t count = 0;
+			for(YAML::const_iterator it=node.begin();it!=node.end();++it)
+				count++;
+			YAML_ASSERT(count == 1);
+			return true;
+		}
+		
+		TEST SimpleSubkeys()
+		{
+			YAML::Node node;
+			node["device"]["udid"] = "12345";
+			node["device"]["name"] = "iPhone";
+			node["device"]["os"] = "4.0";
+			node["username"] = "monkey";
+			YAML_ASSERT(node["device"]["udid"].as<std::string>() == "12345");
+			YAML_ASSERT(node["device"]["name"].as<std::string>() == "iPhone");
+			YAML_ASSERT(node["device"]["os"].as<std::string>() == "4.0");
+			YAML_ASSERT(node["username"].as<std::string>() == "monkey");
+			return true;
+		}
+		
+		TEST StdVector()
+		{
+			std::vector<int> primes;
+			primes.push_back(2);
+			primes.push_back(3);
+			primes.push_back(5);
+			primes.push_back(7);
+			primes.push_back(11);
+			primes.push_back(13);
+			
+			YAML::Node node;
+			node["primes"] = primes;
+			YAML_ASSERT(node["primes"].as<std::vector<int> >() == primes);
+			return true;
+		}
+
+		TEST StdList()
+		{
+			std::list<int> primes;
+			primes.push_back(2);
+			primes.push_back(3);
+			primes.push_back(5);
+			primes.push_back(7);
+			primes.push_back(11);
+			primes.push_back(13);
+			
+			YAML::Node node;
+			node["primes"] = primes;
+			YAML_ASSERT(node["primes"].as<std::list<int> >() == primes);
+			return true;
+		}
+
+		TEST StdMap()
+		{
+			std::map<int, int> squares;
+			squares[0] = 0;
+			squares[1] = 1;
+			squares[2] = 4;
+			squares[3] = 9;
+			squares[4] = 16;
+			
+			YAML::Node node;
+			node["squares"] = squares;
+			YAML_ASSERT((node["squares"].as<std::map<int, int> >() == squares));
+			return true;
+		}
+		
+		TEST SimpleAlias()
+		{
+			YAML::Node node;
+			node["foo"] = "value";
+			node["bar"] = node["foo"];
+			YAML_ASSERT(node["foo"].as<std::string>() == "value");
+			YAML_ASSERT(node["bar"].as<std::string>() == "value");
+			YAML_ASSERT(node["foo"] == node["bar"]);
+			YAML_ASSERT(node.size() == 2);
+			return true;
+		}
+
+		TEST AliasAsKey()
+		{
+			YAML::Node node;
+			node["foo"] = "value";
+			YAML::Node value = node["foo"];
+			node[value] = "foo";
+			YAML_ASSERT(node["foo"].as<std::string>() == "value");
+			YAML_ASSERT(node[value].as<std::string>() == "foo");
+			YAML_ASSERT(node["value"].as<std::string>() == "foo");
+			YAML_ASSERT(node.size() == 2);
+			return true;
+		}
+		
+		TEST SelfReferenceSequence()
+		{
+			YAML::Node node;
+			node[0] = node;
+			YAML_ASSERT(node.IsSequence());
+			YAML_ASSERT(node.size() == 1);
+			YAML_ASSERT(node[0] == node);
+			YAML_ASSERT(node[0][0] == node);
+			YAML_ASSERT(node[0][0] == node[0]);
+			return true;
+		}
+
+		TEST ValueSelfReferenceMap()
+		{
+			YAML::Node node;
+			node["key"] = node;
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node.size() == 1);
+			YAML_ASSERT(node["key"] == node);
+			YAML_ASSERT(node["key"]["key"] == node);
+			YAML_ASSERT(node["key"]["key"] == node["key"]);
+			return true;
+		}
+
+		TEST KeySelfReferenceMap()
+		{
+			YAML::Node node;
+			node[node] = "value";
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node.size() == 1);
+			YAML_ASSERT(node[node].as<std::string>() == "value");
+			return true;
+		}
+
+		TEST SelfReferenceMap()
+		{
+			YAML::Node node;
+			node[node] = node;
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node.size() == 1);
+			YAML_ASSERT(node[node] == node);
+			YAML_ASSERT(node[node][node] == node);
+			YAML_ASSERT(node[node][node] == node[node]);
+			return true;
+		}
+		
+		TEST TempMapVariable()
+		{
+			YAML::Node node;
+			YAML::Node tmp = node["key"];
+			tmp = "value";
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node.size() == 1);
+			YAML_ASSERT(node["key"].as<std::string>() == "value");
+			return true;
+		}
+
+		TEST TempMapVariableAlias()
+		{
+			YAML::Node node;
+			YAML::Node tmp = node["key"];
+			tmp = node["other"];
+			node["other"] = "value";
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node.size() == 2);
+			YAML_ASSERT(node["key"].as<std::string>() == "value");
+			YAML_ASSERT(node["other"].as<std::string>() == "value");
+			YAML_ASSERT(node["other"] == node["key"]);
+			return true;
+		}
+		
+		TEST Bool()
+		{
+			YAML::Node node;
+			node[true] = false;
+			YAML_ASSERT(node.IsMap());
+			YAML_ASSERT(node[true].as<bool>() == false);
+			return true;
+		}
+		
+		TEST AutoBoolConversion()
+		{
+			YAML::Node node;
+			node["foo"] = "bar";
+			YAML_ASSERT(static_cast<bool>(node["foo"]));
+			YAML_ASSERT(!node["monkey"]);
+			YAML_ASSERT(!!node["foo"]);
+			return true;
+		}
+        
+        TEST Reassign()
+        {
+            YAML::Node node = YAML::Load("foo");
+            node = YAML::Node();
+            return true;
+        }
+        
+        TEST FallbackValues()
+        {
+            YAML::Node node = YAML::Load("foo: bar\nx: 2");
+            YAML_ASSERT(node["foo"].as<std::string>() == "bar");
+            YAML_ASSERT(node["foo"].as<std::string>("hello") == "bar");
+            YAML_ASSERT(node["baz"].as<std::string>("hello") == "hello");
+            YAML_ASSERT(node["x"].as<int>() == 2);
+            YAML_ASSERT(node["x"].as<int>(5) == 2);
+            YAML_ASSERT(node["y"].as<int>(5) == 5);
+            return true;
+        }
+        
+        TEST NumericConversion()
+        {
+            YAML::Node node = YAML::Load("[1.5, 1, .nan, .inf, -.inf, 0x15, 015]");
+            YAML_ASSERT(node[0].as<float>() == 1.5f);
+            YAML_ASSERT(node[0].as<double>() == 1.5);
+            YAML_ASSERT_THROWS(node[0].as<int>(), std::runtime_error);
+            YAML_ASSERT(node[1].as<int>() == 1);
+            YAML_ASSERT(node[1].as<float>() == 1.0f);
+            YAML_ASSERT(node[2].as<float>() != node[2].as<float>());
+            YAML_ASSERT(node[3].as<float>() == std::numeric_limits<float>::infinity());
+            YAML_ASSERT(node[4].as<float>() == -std::numeric_limits<float>::infinity());
+            YAML_ASSERT(node[5].as<int>() == 21);
+            YAML_ASSERT(node[6].as<int>() == 13);
+            return true;
+        }
+        
+        TEST Binary()
+        {
+            YAML::Node node = YAML::Load("[!!binary \"SGVsbG8sIFdvcmxkIQ==\", !!binary \"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4K\"]");
+            YAML_ASSERT(node[0].as<YAML::Binary>() == YAML::Binary(reinterpret_cast<const unsigned char*>("Hello, World!"), 13));
+            YAML_ASSERT(node[1].as<YAML::Binary>() == YAML::Binary(reinterpret_cast<const unsigned char*>("Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.\n"), 270));
+            return true;
+        }
+        
+        TEST IterateSequence()
+        {
+            YAML::Node node = YAML::Load("[1, 3, 5, 7]");
+            int seq[] = {1, 3, 5, 7};
+            int i=0;
+            for(YAML::const_iterator it=node.begin();it!=node.end();++it) {
+                YAML_ASSERT(i < 4);
+                int x = seq[i++];
+                YAML_ASSERT(it->as<int>() == x);
+            }
+            YAML_ASSERT(i == 4);
+            return true;
+        }
+        
+        TEST IterateMap()
+        {
+            YAML::Node node = YAML::Load("{a: A, b: B, c: C}");
+            int i=0;
+            for(YAML::const_iterator it=node.begin();it!=node.end();++it) {
+                YAML_ASSERT(i < 3);
+                i++;
+                YAML_ASSERT(it->first.as<char>() + 'A' - 'a' == it->second.as<char>());
+            }
+            YAML_ASSERT(i == 3);
+            return true;
+        }
+        
+        TEST ForEach()
+        {
+            YAML::Node node = YAML::Load("[1, 3, 5, 7]");
+            int seq[] = {1, 3, 5, 7};
+            int i = 0;
+            BOOST_FOREACH(const YAML::Node &item, node) {
+                int x = seq[i++];
+                YAML_ASSERT(item.as<int>() == x);
+            }
+            return true;
+        }
+
+        TEST ForEachMap()
+        {
+            YAML::Node node = YAML::Load("{a: A, b: B, c: C}");
+            BOOST_FOREACH(const YAML::const_iterator::value_type &p, node) {
+                YAML_ASSERT(p.first.as<char>() + 'A' - 'a' == p.second.as<char>());
+            }
+            return true;
+        }
+	}
+	
+	void RunNodeTest(TEST (*test)(), const std::string& name, int& passed, int& total) {
+		TEST ret;
+		try {
+			ret = test();
+		} catch(...) {
+			ret.ok = false;
+		}
+		if(ret.ok) {
+			passed++;
+		} else {
+			std::cout << "Node test failed: " << name << "\n";
+			if(ret.error != "")
+				std::cout << ret.error << "\n";
+		}
+		total++;
+	}
+	
+	bool RunNodeTests()
+	{
+		int passed = 0;
+		int total = 0;
+
+		RunNodeTest(&Node::SimpleScalar, "simple scalar", passed, total);
+		RunNodeTest(&Node::IntScalar, "int scalar", passed, total);
+		RunNodeTest(&Node::SimpleAppendSequence, "simple append sequence", passed, total);
+		RunNodeTest(&Node::SimpleAssignSequence, "simple assign sequence", passed, total);
+		RunNodeTest(&Node::SimpleMap, "simple map", passed, total);
+		RunNodeTest(&Node::MapWithUndefinedValues, "map with undefined values", passed, total);
+		RunNodeTest(&Node::MapIteratorWithUndefinedValues, "map iterator with undefined values", passed, total);
+		RunNodeTest(&Node::SimpleSubkeys, "simple subkey", passed, total);
+		RunNodeTest(&Node::StdVector, "std::vector", passed, total);
+		RunNodeTest(&Node::StdList, "std::list", passed, total);
+		RunNodeTest(&Node::StdMap, "std::map", passed, total);
+		RunNodeTest(&Node::SimpleAlias, "simple alias", passed, total);
+		RunNodeTest(&Node::AliasAsKey, "alias as key", passed, total);
+		RunNodeTest(&Node::SelfReferenceSequence, "self reference sequence", passed, total);
+		RunNodeTest(&Node::ValueSelfReferenceMap, "value self reference map", passed, total);
+		RunNodeTest(&Node::KeySelfReferenceMap, "key self reference map", passed, total);
+		RunNodeTest(&Node::SelfReferenceMap, "self reference map", passed, total);
+		RunNodeTest(&Node::TempMapVariable, "temp map variable", passed, total);
+		RunNodeTest(&Node::TempMapVariableAlias, "temp map variable alias", passed, total);
+		RunNodeTest(&Node::Bool, "bool", passed, total);
+		RunNodeTest(&Node::AutoBoolConversion, "auto bool conversion", passed, total);
+		RunNodeTest(&Node::Reassign, "reassign", passed, total);
+		RunNodeTest(&Node::FallbackValues, "fallback values", passed, total);
+		RunNodeTest(&Node::NumericConversion, "numeric conversion", passed, total);
+		RunNodeTest(&Node::Binary, "binary", passed, total);
+		RunNodeTest(&Node::IterateSequence, "iterate sequence", passed, total);
+		RunNodeTest(&Node::IterateMap, "iterate map", passed, total);
+		RunNodeTest(&Node::ForEach, "for each", passed, total);
+		RunNodeTest(&Node::ForEachMap, "for each map", passed, total);
+
+		std::cout << "Node tests: " << passed << "/" << total << " passed\n";
+		return passed == total;
+	}
+}
--- a/test/new-api/parsertests.cpp
+++ b/test/new-api/parsertests.cpp
@@ -0,0 +1,8 @@
+#include "parsertests.h"
+
+namespace Test {
+	bool RunParserTests()
+	{
+		return true;
+	}
+}
--- a/test/new-api/spectests.cpp
+++ b/test/new-api/spectests.cpp
--- a/test/nodetests.h
+++ b/test/nodetests.h
@@ -0,0 +1,13 @@
+#ifndef NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace Test {
+	bool RunNodeTests();
+}
+
+#endif // NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A6666
+
--- a/test/parsertests.h
+++ b/test/parsertests.h
@@ -0,0 +1,13 @@
+#ifndef PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace Test {
+	bool RunParserTests();
+}
+
+#endif // PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
--- a/test/tests.cpp
+++ b/test/tests.cpp
@@ -1,5 +1,7 @@
 #include "tests.h"
 #include "emittertests.h"
+#include "nodetests.h"
+#include "parsertests.h"
 #include "spectests.h"
 #include "yaml-cpp/yaml.h"
 #include <fstream>
@@ -12,12 +14,18 @@ namespace Test
 	void RunAll()
 	{
 		bool passed = true;
+		if(!RunParserTests())
+			passed = false;
+			
 		if(!RunEmitterTests())
 			passed = false;

 		if(!RunSpecTests())
 			passed = false;
-		
+
+		if(!RunNodeTests())
+			passed = false;
+
 		if(passed)
 			std::cout << "All tests passed!\n";
 	}