Bumped version to 0.3.0

It seems that it's not necessary to export those members (as long as you can't access them), and most of them are STL instances, which apparently cause lots of problems for DLLs. (For example, you simply can't export instances of std::map; see http://support.microsoft.com/kb/168958.)

.hgignore

@@ -1,2 +1 @@
 syntax: glob
-

CMakeLists.txt

@@ -22,7 +22,7 @@ include(CheckCXXCompilerFlag)
 project(YAML_CPP)
 
 set(YAML_CPP_VERSION_MAJOR "0")
-set(YAML_CPP_VERSION_MINOR "5")
+set(YAML_CPP_VERSION_MINOR "3")
 set(YAML_CPP_VERSION_PATCH "0")
 set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
 
@@ -57,7 +57,7 @@ option(MSVC_STHREADED_RT "MSVC: Build with single-threaded static runtime libs (
 set(header_directory "include/yaml-cpp/")
 
 file(GLOB sources "src/[a-zA-Z]*.cpp")
-file(GLOB_RECURSE public_headers "include/yaml-cpp/[a-zA-Z]*.h")
+file(GLOB public_headers "include/yaml-cpp/[a-zA-Z]*.h")
 file(GLOB private_headers "src/[a-zA-Z]*.h")
 
 if(YAML_CPP_BUILD_CONTRIB)
@@ -77,11 +77,8 @@ if(VERBOSE)
 	message(STATUS "contrib_private_headers: ${contrib_private_headers}")
 endif()
 
-include_directories(${YAML_CPP_SOURCE_DIR}/src)
 include_directories(${YAML_CPP_SOURCE_DIR}/include)
-
-find_package(Boost REQUIRED)
-include_directories(${Boost_INCLUDE_DIRS})
+include_directories(${YAML_CPP_SOURCE_DIR}/src)
 
 
 ###

include/yaml-cpp/aliasmanager.h

@@ -0,0 +1,34 @@
+#ifndef ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ALIASMANAGER_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 <map>
+
+namespace YAML
+{
+	class Node;
+	
+	class AliasManager
+	{
+	public:
+		AliasManager();
+		
+		void RegisterReference(const Node& node);
+		anchor_t LookupAnchor(const Node& node) const;
+		
+	private:
+		anchor_t _CreateNewAnchor();
+		
+	private:
+		typedef std::map<const Node*, anchor_t> AnchorByIdentity;
+		AnchorByIdentity m_anchorByIdentity;
+		
+		anchor_t m_curAnchor;
+	};
+}
+
+#endif // ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/binary.h

@@ -10,13 +10,15 @@
 
 namespace YAML
 {
+    class Node;
+    
     std::string EncodeBase64(const unsigned char *data, std::size_t size);
     std::vector<unsigned char> DecodeBase64(const std::string& input);
     
     class Binary {
     public:
         Binary(): m_unownedData(0), m_unownedSize(0) {}
-        Binary(const unsigned char *data_, std::size_t size_): m_unownedData(data_), m_unownedSize(size_) {}
+        Binary(const unsigned char *data, std::size_t size): m_unownedData(data), m_unownedSize(size) {}
         
         bool owned() const { return !m_unownedData; }
         std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
@@ -57,6 +59,8 @@ namespace YAML
         const unsigned char *m_unownedData;
         std::size_t m_unownedSize;
     };
+    
+    void operator >> (const Node& node, Binary& binary);
 }
 
 #endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/conversion.h

@@ -0,0 +1,75 @@
+#ifndef CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define CONVERSION_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/null.h"
+#include "yaml-cpp/traits.h"
+#include <limits>
+#include <string>
+#include <sstream>
+
+namespace YAML
+{
+	// traits for conversion
+	
+	template<typename T>
+	struct is_scalar_convertible { enum { value = is_numeric<T>::value }; };
+	
+	template<> struct is_scalar_convertible<std::string> { enum { value = true }; };
+	template<> struct is_scalar_convertible<bool> { enum { value = true }; };
+	template<> struct is_scalar_convertible<_Null> { enum { value = true }; };
+
+	// actual conversion
+	
+	inline bool Convert(const std::string& input, std::string& output) {
+		output = input;
+		return true;
+	}
+	
+	YAML_CPP_API bool Convert(const std::string& input, bool& output);
+	YAML_CPP_API bool Convert(const std::string& input, _Null& output);
+	
+	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";
+	}
+
+
+	template <typename T> 
+	inline bool Convert(const std::string& input, T& output, typename enable_if<is_numeric<T> >::type * = 0) {
+		std::stringstream stream(input);
+		stream.unsetf(std::ios::dec);
+        if((stream >> output) && (stream >> std::ws).eof())
+            return true;
+		
+		if(std::numeric_limits<T>::has_infinity) {
+			if(IsInfinity(input)) {
+				output = std::numeric_limits<T>::infinity();
+				return true;
+			} else if(IsNegativeInfinity(input)) {
+				output = -std::numeric_limits<T>::infinity();
+				return true;
+			}
+		}
+		
+		if(std::numeric_limits<T>::has_quiet_NaN && IsNaN(input)) {
+			output = std::numeric_limits<T>::quiet_NaN();
+			return true;
+		}
+		
+		return false;
+	}
+}
+
+#endif // CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/exceptions.h

@@ -57,10 +57,7 @@ namespace YAML
 
 		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";
@@ -151,36 +148,11 @@ namespace YAML
 		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:

include/yaml-cpp/iterator.h

@@ -0,0 +1,40 @@
+#ifndef ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define 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 <memory>
+
+namespace YAML
+{
+	class Node;
+	struct IterPriv;
+
+	class YAML_CPP_API Iterator
+	{
+	public:
+		Iterator();
+		Iterator(std::auto_ptr<IterPriv> pData);
+		Iterator(const Iterator& rhs);
+		~Iterator();
+
+		Iterator& operator = (const Iterator& rhs);
+		Iterator& operator ++ ();
+		Iterator operator ++ (int);
+		const Node& operator * () const;
+		const Node *operator -> () const;
+		const Node& first() const;
+		const Node& second() const;
+
+		friend YAML_CPP_API bool operator == (const Iterator& it, const Iterator& jt);
+		friend YAML_CPP_API bool operator != (const Iterator& it, const Iterator& jt);
+
+	private:
+		std::auto_ptr<IterPriv> m_pData;
+	};
+}
+
+#endif // ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/ltnode.h

@@ -0,0 +1,18 @@
+#ifndef LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define LTNODE_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
+{
+	class Node;
+
+	struct ltnode {
+		bool operator()(const Node *pNode1, const Node *pNode2) const;
+	};
+}
+
+#endif // LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node.h

@@ -0,0 +1,135 @@
+#ifndef NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define 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/exceptions.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/noncopyable.h"
+#include "yaml-cpp/conversion.h"
+#include "yaml-cpp/iterator.h"
+#include "yaml-cpp/ltnode.h"
+#include <iostream>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace YAML
+{
+	class AliasManager;
+	class Content;
+	class NodeOwnership;
+	class Scanner;
+	class Emitter;
+	class EventHandler;
+
+	struct NodeType { enum value { Null, Scalar, Sequence, Map }; };
+
+	class YAML_CPP_API Node: private noncopyable
+	{
+	public:
+		friend class NodeOwnership;
+		friend class NodeBuilder;
+		
+		Node();
+		~Node();
+
+		void Clear();
+		std::auto_ptr<Node> Clone() const;
+		void EmitEvents(EventHandler& eventHandler) const;
+		void EmitEvents(AliasManager& am, EventHandler& eventHandler) const;
+		
+		NodeType::value Type() const { return m_type; }
+		bool IsAliased() const;
+
+		// file location of start of this node
+		const Mark GetMark() const { return m_mark; }
+
+		// accessors
+		Iterator begin() const;
+		Iterator end() const;
+		std::size_t size() const;
+
+		// extraction of scalars
+		bool GetScalar(std::string& s) const;
+
+		// we can specialize this for other values
+		template <typename T>
+		bool Read(T& value) const;
+
+		template <typename T>
+		const T to() const;
+
+		template <typename T>
+		friend YAML_CPP_API typename enable_if<is_scalar_convertible<T> >::type operator >> (const Node& node, T& value);
+
+		// retrieval for maps and sequences
+		template <typename T>
+		const Node *FindValue(const T& key) const;
+
+		template <typename T>
+		const Node& operator [] (const T& key) const;
+		
+		// specific to maps
+		const Node *FindValue(const char *key) const;
+		const Node *FindValue(char *key) const;
+		const Node& operator [] (const char *key) const;
+		const Node& operator [] (char *key) const;
+
+		// for tags
+		const std::string& Tag() const { return m_tag; }
+
+		// emitting
+		friend YAML_CPP_API Emitter& operator << (Emitter& out, const Node& node);
+
+		// ordering
+		int Compare(const Node& rhs) const;
+		friend bool operator < (const Node& n1, const Node& n2);
+
+	private:
+		explicit Node(NodeOwnership& owner);
+		Node& CreateNode();
+		
+		void Init(NodeType::value type, const Mark& mark, const std::string& tag);
+		
+		void MarkAsAliased();
+		void SetScalarData(const std::string& data);
+		void Append(Node& node);
+		void Insert(Node& key, Node& value);
+
+		// helper for sequences
+		template <typename, bool> friend struct _FindFromNodeAtIndex;
+		const Node *FindAtIndex(std::size_t i) const;
+		
+		// helper for maps
+		template <typename T>
+		const Node& GetValue(const T& key) const;
+
+		template <typename T>
+		const Node *FindValueForKey(const T& key) const;
+
+	private:
+		std::auto_ptr<NodeOwnership> m_pOwnership;
+
+		Mark m_mark;
+		std::string m_tag;
+
+		typedef std::vector<Node *> node_seq;
+		typedef std::map<Node *, Node *, ltnode> node_map;
+
+		NodeType::value m_type;
+		std::string m_scalarData;
+		node_seq m_seqData;
+		node_map m_mapData;
+	};
+}
+
+#include "yaml-cpp/nodeimpl.h"
+#include "yaml-cpp/nodereadimpl.h"
+
+#endif // NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/convert.h

@@ -1,209 +0,0 @@
-#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

include/yaml-cpp/node/detail/bool_type.h

@@ -1,26 +0,0 @@
-#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

include/yaml-cpp/node/detail/impl.h

@@ -1,142 +0,0 @@
-#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

include/yaml-cpp/node/detail/iterator.h

@@ -1,64 +0,0 @@
-#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

include/yaml-cpp/node/detail/iterator_fwd.h

@@ -1,27 +0,0 @@
-#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

include/yaml-cpp/node/detail/memory.h

@@ -1,39 +0,0 @@
-#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

include/yaml-cpp/node/detail/node.h

@@ -1,126 +0,0 @@
-#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

include/yaml-cpp/node/detail/node_data.h

@@ -1,105 +0,0 @@
-#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

include/yaml-cpp/node/detail/node_iterator.h

@@ -1,139 +0,0 @@
-#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

include/yaml-cpp/node/detail/node_ref.h

@@ -1,65 +0,0 @@
-#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

include/yaml-cpp/node/emit.h

@@ -1,23 +0,0 @@
-#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
-

include/yaml-cpp/node/impl.h

@@ -1,355 +0,0 @@
-#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

include/yaml-cpp/node/iterator.h

@@ -1,28 +0,0 @@
-#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

include/yaml-cpp/node/node.h

@@ -1,113 +0,0 @@
-#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

include/yaml-cpp/node/parse.h

@@ -1,28 +0,0 @@
-#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
-

include/yaml-cpp/node/ptr.h

@@ -1,29 +0,0 @@
-#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

include/yaml-cpp/node/type.h

@@ -1,14 +0,0 @@
-#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

include/yaml-cpp/nodeimpl.h

@@ -0,0 +1,85 @@
+#ifndef NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODEIMPL_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/nodeutil.h"
+#include <cassert>
+
+namespace YAML
+{
+	// implementation of templated things
+	template <typename T>
+	inline const T Node::to() const {
+		T value;
+		*this >> value;
+		return value;
+	}
+
+	template <typename T>
+	inline typename enable_if<is_scalar_convertible<T> >::type operator >> (const Node& node, T& value) {
+		if(!ConvertScalar(node, value))
+			throw InvalidScalar(node.m_mark);
+	}
+	
+	template <typename T>
+	inline const Node *Node::FindValue(const T& key) const {
+		switch(m_type) {
+			case NodeType::Null:
+			case NodeType::Scalar:
+				throw BadDereference();
+			case NodeType::Sequence:
+				return FindFromNodeAtIndex(*this, key);
+			case NodeType::Map:
+				return FindValueForKey(key);
+		}
+		assert(false);
+		throw BadDereference();
+	}
+	
+	template <typename T>
+	inline const Node *Node::FindValueForKey(const T& key) const {
+		for(Iterator it=begin();it!=end();++it) {
+			T t;
+			if(it.first().Read(t)) {
+				if(key == t)
+					return &it.second();
+			}
+		}
+		
+		return 0;
+	}
+	
+	template <typename T>
+	inline const Node& Node::GetValue(const T& key) const {
+		if(const Node *pValue = FindValue(key))
+			return *pValue;
+		throw MakeTypedKeyNotFound(m_mark, key);
+	}
+	
+	template <typename T>
+	inline const Node& Node::operator [] (const T& key) const {
+		return GetValue(key);
+	}
+	
+	inline const Node *Node::FindValue(const char *key) const {
+		return FindValue(std::string(key));
+	}
+
+	inline const Node *Node::FindValue(char *key) const {
+		return FindValue(std::string(key));
+	}
+	
+	inline const Node& Node::operator [] (const char *key) const {
+		return GetValue(std::string(key));
+	}
+
+	inline const Node& Node::operator [] (char *key) const {
+		return GetValue(std::string(key));
+	}
+}
+
+#endif // NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/nodereadimpl.h

@@ -0,0 +1,86 @@
+#ifndef NODEREADIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODEREADIMPL_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
+{
+	// implementation for Node::Read
+	// (the goal is to call ConvertScalar if we can, and fall back to operator >> if not)
+	// thanks to litb from stackoverflow.com
+	// http://stackoverflow.com/questions/1386183/how-to-call-a-templated-function-if-it-exists-and-something-else-otherwise/1386390#1386390
+
+	// Note: this doesn't work on gcc 3.2, but does on gcc 3.4 and above. I'm not sure about 3.3.
+	
+#if __GNUC__ && (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ <= 3))
+	// trick doesn't work? Just fall back to ConvertScalar.
+	// This means that we can't use any user-defined types as keys in a map
+	template <typename T>
+	inline bool Node::Read(T& value) const {
+		return ConvertScalar(*this, value);
+	}
+#else
+	// usual case: the trick!
+	template<bool>
+	struct read_impl;
+	
+	// ConvertScalar available
+	template<>
+	struct read_impl<true> {
+		template<typename T>
+		static bool read(const Node& node, T& value) {
+			return ConvertScalar(node, value);
+		}
+	};
+
+	// ConvertScalar not available
+	template<>
+	struct read_impl<false> {
+		template<typename T>
+		static bool read(const Node& node, T& value) {
+			try {
+				node >> value;
+			} catch(const Exception&) {
+				return false;
+			}
+			return true;
+		}
+	};
+	
+	namespace fallback {
+		// sizeof > 1
+		struct flag { char c[2]; };
+		flag Convert(...);
+		
+		int operator,(flag, flag);
+		
+		template<typename T>
+		char operator,(flag, T const&);
+		
+		char operator,(int, flag);
+		int operator,(char, flag);
+	}
+
+	template <typename T>
+	inline bool Node::Read(T& value) const {
+		using namespace fallback;
+
+		return read_impl<sizeof (fallback::flag(), Convert(std::string(), value), fallback::flag()) != 1>::read(*this, value);
+	}
+#endif // done with trick
+	
+	// the main conversion function
+	template <typename T>
+	inline bool ConvertScalar(const Node& node, T& value) {
+		std::string scalar;
+		if(!node.GetScalar(scalar))
+			return false;
+		
+		return Convert(scalar, value);
+	}
+}
+
+#endif // NODEREADIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/nodeutil.h

@@ -0,0 +1,62 @@
+#ifndef NODEUTIL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODEUTIL_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
+{
+	template <typename T, typename U>
+	struct is_same_type {
+		enum { value = false };
+	};
+	
+	template <typename T>
+	struct is_same_type<T, T> {
+		enum { value = true };
+	};
+	
+	template <typename T, bool check>
+	struct is_index_type_with_check {
+		enum { value = false };
+	};
+	
+	template <> struct is_index_type_with_check<std::size_t, false> { enum { value = true }; };
+
+#define MAKE_INDEX_TYPE(Type) \
+	template <> struct is_index_type_with_check<Type, is_same_type<Type, std::size_t>::value> { enum { value = true }; }
+	
+	MAKE_INDEX_TYPE(int);
+	MAKE_INDEX_TYPE(unsigned);
+	MAKE_INDEX_TYPE(short);
+	MAKE_INDEX_TYPE(unsigned short);
+	MAKE_INDEX_TYPE(long);
+	MAKE_INDEX_TYPE(unsigned long);
+
+#undef MAKE_INDEX_TYPE
+	
+	template <typename T>
+	struct is_index_type: public is_index_type_with_check<T, false> {};
+	
+	// messing around with template stuff to get the right overload for operator [] for a sequence
+	template <typename T, bool b>
+	struct _FindFromNodeAtIndex {
+		const Node *pRet;
+		_FindFromNodeAtIndex(const Node&, const T&): pRet(0) {}
+	};
+
+	template <typename T>
+	struct _FindFromNodeAtIndex<T, true> {
+		const Node *pRet;
+		_FindFromNodeAtIndex(const Node& node, const T& key): pRet(node.FindAtIndex(static_cast<std::size_t>(key))) {}
+	};
+
+	template <typename T>
+	inline const Node *FindFromNodeAtIndex(const Node& node, const T& key) {
+		return _FindFromNodeAtIndex<T, is_index_type<T>::value>(node, key).pRet;
+	}
+}
+
+#endif // NODEUTIL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/stlnode.h

@@ -0,0 +1,38 @@
+#ifndef STLNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STLNODE_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 <vector>
+#include <map>
+
+namespace YAML
+{
+	template <typename T>
+	void operator >> (const Node& node, std::vector<T>& v)
+	{
+		v.clear();
+		v.resize(node.size());
+		for(unsigned i=0;i<node.size();++i)
+			node[i] >> v[i];
+	}
+	
+	
+	template <typename K, typename V>
+	void operator >> (const Node& node, std::map<K, V>& m)
+	{
+		m.clear();
+		for(Iterator it=node.begin();it!=node.end();++it) {
+			K k;
+			V v;
+			it.first() >> k;
+			it.second() >> v;
+			m[k] = v;
+		}
+	}
+}
+
+#endif // STLNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/yaml.h

@@ -10,12 +10,8 @@
 #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"
+#include "yaml-cpp/node.h"
+#include "yaml-cpp/stlnode.h"
+#include "yaml-cpp/iterator.h"
 
 #endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/aliasmanager.cpp

@@ -0,0 +1,29 @@
+#include "yaml-cpp/aliasmanager.h"
+#include "yaml-cpp/node.h"
+#include <cassert>
+#include <sstream>
+
+namespace YAML
+{
+	AliasManager::AliasManager(): m_curAnchor(0)
+	{
+	}
+
+	void AliasManager::RegisterReference(const Node& node)
+	{
+		m_anchorByIdentity.insert(std::make_pair(&node, _CreateNewAnchor()));
+	}
+
+	anchor_t AliasManager::LookupAnchor(const Node& node) const
+	{
+		AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(&node);
+		if(it == m_anchorByIdentity.end())
+			return 0;
+		return it->second;
+	}
+
+	anchor_t AliasManager::_CreateNewAnchor()
+	{
+		return ++m_curAnchor;
+	}
+}

src/binary.cpp

@@ -1,4 +1,5 @@
 #include "yaml-cpp/binary.h"
+#include "yaml-cpp/node.h"
 
 namespace YAML
 {
@@ -90,4 +91,12 @@ namespace YAML
         ret.resize(out - &ret[0]);
         return ret;
     }
+
+    void operator >> (const Node& node, Binary& binary)
+    {
+        std::string scalar;
+        node.GetScalar(scalar);
+        std::vector<unsigned char> data = DecodeBase64(scalar);
+        binary.swap(data);
+    }
 }

src/conversion.cpp

@@ -1,31 +1,33 @@
-#include "yaml-cpp/node/convert.h"
-#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/conversion.h"
 #include <algorithm>
 
+////////////////////////////////////////////////////////////////
+// Specializations for converting a string to specific types
+
 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
@@ -35,10 +37,10 @@ namespace
 	{
 		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));
@@ -47,10 +49,8 @@ namespace
 
 namespace YAML
 {
-	bool convert<bool>::decode(const Node& node, bool& rhs) {
-		if(!node.IsScalar())
-			return false;
-		
+	bool Convert(const std::string& input, bool& b)
+	{
 		// 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)
@@ -62,22 +62,28 @@ namespace YAML
 			{ "true", "false" },
 			{ "on", "off" },
 		};
-		
-		if(!IsFlexibleCase(node.Scalar()))
+
+		if(!IsFlexibleCase(input))
 			return false;
-		
+
 		for(unsigned i=0;i<sizeof(names)/sizeof(names[0]);i++) {
-			if(names[i].truename == tolower(node.Scalar())) {
-				rhs = true;
+			if(names[i].truename == tolower(input)) {
+				b = true;
 				return true;
 			}
-			
-			if(names[i].falsename == tolower(node.Scalar())) {
-				rhs = false;
+
+			if(names[i].falsename == tolower(input)) {
+				b = false;
 				return true;
 			}
 		}
-		
+
 		return false;
 	}
+	
+	bool Convert(const std::string& input, _Null& /*output*/)
+	{
+		return input.empty() || input == "~" || input == "null" || input == "Null" || input == "NULL";
+	}
 }
+

src/emit.cpp

@@ -1,30 +0,0 @@
-#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();
-	}
-}

src/iterator.cpp

@@ -0,0 +1,103 @@
+#include "yaml-cpp/node.h"
+#include "yaml-cpp/exceptions.h"
+#include "iterpriv.h"
+
+namespace YAML
+{
+	Iterator::Iterator(): m_pData(new IterPriv)
+	{
+	}
+
+	Iterator::Iterator(std::auto_ptr<IterPriv> pData): m_pData(pData)
+	{
+	}
+
+	Iterator::Iterator(const Iterator& rhs): m_pData(new IterPriv(*rhs.m_pData))
+	{
+	}
+
+	Iterator& Iterator::operator = (const Iterator& rhs)
+	{
+		if(this == &rhs)
+			return *this;
+
+		m_pData.reset(new IterPriv(*rhs.m_pData));
+		return *this;
+	}
+
+	Iterator::~Iterator()
+	{
+	}
+
+	Iterator& Iterator::operator ++ ()
+	{
+		if(m_pData->type == IterPriv::IT_SEQ)
+			++m_pData->seqIter;
+		else if(m_pData->type == IterPriv::IT_MAP)
+			++m_pData->mapIter;
+
+		return *this;
+	}
+
+	Iterator Iterator::operator ++ (int)
+	{
+		Iterator temp = *this;
+
+		if(m_pData->type == IterPriv::IT_SEQ)
+			++m_pData->seqIter;
+		else if(m_pData->type == IterPriv::IT_MAP)
+			++m_pData->mapIter;
+
+		return temp;
+	}
+
+	const Node& Iterator::operator * () const
+	{
+		if(m_pData->type == IterPriv::IT_SEQ)
+			return **m_pData->seqIter;
+
+		throw BadDereference();
+	}
+
+	const Node *Iterator::operator -> () const
+	{
+		if(m_pData->type == IterPriv::IT_SEQ)
+			return *m_pData->seqIter;
+
+		throw BadDereference();
+	}
+
+	const Node& Iterator::first() const
+	{
+		if(m_pData->type == IterPriv::IT_MAP)
+			return *m_pData->mapIter->first;
+
+		throw BadDereference();
+	}
+
+	const Node& Iterator::second() const
+	{
+		if(m_pData->type == IterPriv::IT_MAP)
+			return *m_pData->mapIter->second;
+
+		throw BadDereference();
+	}
+
+	bool operator == (const Iterator& it, const Iterator& jt)
+	{
+		if(it.m_pData->type != jt.m_pData->type)
+			return false;
+
+		if(it.m_pData->type == IterPriv::IT_SEQ)
+			return it.m_pData->seqIter == jt.m_pData->seqIter;
+		else if(it.m_pData->type == IterPriv::IT_MAP)
+			return it.m_pData->mapIter == jt.m_pData->mapIter;
+
+		return true;
+	}
+
+	bool operator != (const Iterator& it, const Iterator& jt)
+	{
+		return !(it == jt);
+	}
+}

src/iterpriv.h

@@ -0,0 +1,33 @@
+#ifndef ITERPRIV_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ITERPRIV_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/ltnode.h"
+#include <vector>
+#include <map>
+
+namespace YAML
+{
+	class Node;
+
+	// IterPriv
+	// . The implementation for iterators - essentially a union of sequence and map iterators.
+	struct IterPriv
+	{
+		IterPriv(): type(IT_NONE) {}
+		IterPriv(std::vector <Node *>::const_iterator it): type(IT_SEQ), seqIter(it) {}
+		IterPriv(std::map <Node *, Node *, ltnode>::const_iterator it): type(IT_MAP), mapIter(it) {}
+
+		enum ITER_TYPE { IT_NONE, IT_SEQ, IT_MAP };
+		ITER_TYPE type;
+
+		std::vector <Node *>::const_iterator seqIter;
+		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
+	};
+}
+
+#endif // ITERPRIV_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/memory.cpp

@@ -1,29 +0,0 @@
-#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());
-		}
-	}
-}

src/node.cpp

@@ -0,0 +1,269 @@
+#include "yaml-cpp/node.h"
+#include "yaml-cpp/aliasmanager.h"
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/eventhandler.h"
+#include "iterpriv.h"
+#include "nodebuilder.h"
+#include "nodeownership.h"
+#include "scanner.h"
+#include "tag.h"
+#include "token.h"
+#include <cassert>
+#include <stdexcept>
+
+namespace YAML
+{
+	bool ltnode::operator()(const Node *pNode1, const Node *pNode2) const {
+		return *pNode1 < *pNode2;
+	}
+
+	Node::Node(): m_pOwnership(new NodeOwnership), m_type(NodeType::Null)
+	{
+	}
+
+	Node::Node(NodeOwnership& owner): m_pOwnership(new NodeOwnership(&owner)), m_type(NodeType::Null)
+	{
+	}
+
+	Node::~Node()
+	{
+		Clear();
+	}
+
+	void Node::Clear()
+	{
+		m_pOwnership.reset(new NodeOwnership);
+		m_type = NodeType::Null;
+		m_tag.clear();
+		m_scalarData.clear();
+		m_seqData.clear();
+		m_mapData.clear();
+	}
+	
+	bool Node::IsAliased() const
+	{
+		return m_pOwnership->IsAliased(*this);
+	}
+
+	Node& Node::CreateNode()
+	{
+		return m_pOwnership->Create();
+	}
+
+	std::auto_ptr<Node> Node::Clone() const
+	{
+		std::auto_ptr<Node> pNode(new Node);
+		NodeBuilder nodeBuilder(*pNode);
+		EmitEvents(nodeBuilder);
+		return pNode;
+	}
+
+	void Node::EmitEvents(EventHandler& eventHandler) const
+	{
+		eventHandler.OnDocumentStart(m_mark);
+		AliasManager am;
+		EmitEvents(am, eventHandler);
+		eventHandler.OnDocumentEnd();
+	}
+
+	void Node::EmitEvents(AliasManager& am, EventHandler& eventHandler) const
+	{
+		anchor_t anchor = NullAnchor;
+		if(IsAliased()) {
+			anchor = am.LookupAnchor(*this);
+			if(anchor) {
+				eventHandler.OnAlias(m_mark, anchor);
+				return;
+			}
+			
+			am.RegisterReference(*this);
+			anchor = am.LookupAnchor(*this);
+		}
+		
+		switch(m_type) {
+			case NodeType::Null:
+				eventHandler.OnNull(m_mark, anchor);
+				break;
+			case NodeType::Scalar:
+				eventHandler.OnScalar(m_mark, m_tag, anchor, m_scalarData);
+				break;
+			case NodeType::Sequence:
+				eventHandler.OnSequenceStart(m_mark, m_tag, anchor);
+				for(std::size_t i=0;i<m_seqData.size();i++)
+					m_seqData[i]->EmitEvents(am, eventHandler);
+				eventHandler.OnSequenceEnd();
+				break;
+			case NodeType::Map:
+				eventHandler.OnMapStart(m_mark, m_tag, anchor);
+				for(node_map::const_iterator it=m_mapData.begin();it!=m_mapData.end();++it) {
+					it->first->EmitEvents(am, eventHandler);
+					it->second->EmitEvents(am, eventHandler);
+				}
+				eventHandler.OnMapEnd();
+				break;
+		}
+	}
+
+	void Node::Init(NodeType::value type, const Mark& mark, const std::string& tag)
+	{
+		Clear();
+		m_mark = mark;
+		m_type = type;
+		m_tag = tag;
+	}
+
+	void Node::MarkAsAliased()
+	{
+		m_pOwnership->MarkAsAliased(*this);
+	}
+	
+	void Node::SetScalarData(const std::string& data)
+	{
+		assert(m_type == NodeType::Scalar); // TODO: throw?
+		m_scalarData = data;
+	}
+
+	void Node::Append(Node& node)
+	{
+		assert(m_type == NodeType::Sequence); // TODO: throw?
+		m_seqData.push_back(&node);
+	}
+	
+	void Node::Insert(Node& key, Node& value)
+	{
+		assert(m_type == NodeType::Map); // TODO: throw?
+		m_mapData[&key] = &value;
+	}
+
+	// begin
+	// Returns an iterator to the beginning of this (sequence or map).
+	Iterator Node::begin() const
+	{
+		switch(m_type) {
+			case NodeType::Null:
+			case NodeType::Scalar:
+				return Iterator();
+			case NodeType::Sequence:
+				return Iterator(std::auto_ptr<IterPriv>(new IterPriv(m_seqData.begin())));
+			case NodeType::Map:
+				return Iterator(std::auto_ptr<IterPriv>(new IterPriv(m_mapData.begin())));
+		}
+		
+		assert(false);
+		return Iterator();
+	}
+
+	// end
+	// . Returns an iterator to the end of this (sequence or map).
+	Iterator Node::end() const
+	{
+		switch(m_type) {
+			case NodeType::Null:
+			case NodeType::Scalar:
+				return Iterator();
+			case NodeType::Sequence:
+				return Iterator(std::auto_ptr<IterPriv>(new IterPriv(m_seqData.end())));
+			case NodeType::Map:
+				return Iterator(std::auto_ptr<IterPriv>(new IterPriv(m_mapData.end())));
+		}
+		
+		assert(false);
+		return Iterator();
+	}
+
+	// size
+	// . Returns the size of a sequence or map node
+	// . Otherwise, returns zero.
+	std::size_t Node::size() const
+	{
+		switch(m_type) {
+			case NodeType::Null:
+			case NodeType::Scalar:
+				return 0;
+			case NodeType::Sequence:
+				return m_seqData.size();
+			case NodeType::Map:
+				return m_mapData.size();
+		}
+		
+		assert(false);
+		return 0;
+	}
+
+	const Node *Node::FindAtIndex(std::size_t i) const
+	{
+		if(m_type == NodeType::Sequence)
+			return m_seqData[i];
+		return 0;
+	}
+
+	bool Node::GetScalar(std::string& s) const
+	{
+		switch(m_type) {
+			case NodeType::Null:
+				s = "~";
+				return true;
+			case NodeType::Scalar:
+				s = m_scalarData;
+				return true;
+			case NodeType::Sequence:
+			case NodeType::Map:
+				return false;
+		}
+		
+		assert(false);
+		return false;
+	}
+
+	Emitter& operator << (Emitter& out, const Node& node)
+	{
+		EmitFromEvents emitFromEvents(out);
+		node.EmitEvents(emitFromEvents);
+		return out;
+	}
+
+	int Node::Compare(const Node& rhs) const
+	{
+		if(m_type != rhs.m_type)
+			return rhs.m_type - m_type;
+		
+		switch(m_type) {
+			case NodeType::Null:
+				return 0;
+			case NodeType::Scalar:
+				return m_scalarData.compare(rhs.m_scalarData);
+			case NodeType::Sequence:
+				if(m_seqData.size() < rhs.m_seqData.size())
+					return 1;
+				else if(m_seqData.size() > rhs.m_seqData.size())
+					return -1;
+				for(std::size_t i=0;i<m_seqData.size();i++)
+					if(int cmp = m_seqData[i]->Compare(*rhs.m_seqData[i]))
+						return cmp;
+				return 0;
+			case NodeType::Map:
+				if(m_mapData.size() < rhs.m_mapData.size())
+					return 1;
+				else if(m_mapData.size() > rhs.m_mapData.size())
+					return -1;
+				node_map::const_iterator it = m_mapData.begin();
+				node_map::const_iterator jt = rhs.m_mapData.begin();
+				for(;it!=m_mapData.end() && jt!=rhs.m_mapData.end();it++, jt++) {
+					if(int cmp = it->first->Compare(*jt->first))
+						return cmp;
+					if(int cmp = it->second->Compare(*jt->second))
+						return cmp;
+				}
+				return 0;
+		}
+		
+		assert(false);
+		return 0;
+	}
+
+	bool operator < (const Node& n1, const Node& n2)
+	{
+		return n1.Compare(n2) < 0;
+	}
+}

src/node_data.cpp

@@ -1,295 +0,0 @@
-#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;
-		}
-	}
-}

src/nodebuilder.cpp

@@ -1,134 +1,141 @@
 #include "nodebuilder.h"
 #include "yaml-cpp/mark.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node.h"
 #include <cassert>
 
 namespace YAML
 {
-	NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
+	NodeBuilder::NodeBuilder(Node& root): m_root(root), m_initializedRoot(false), m_finished(false)
 	{
+		m_root.Clear();
 		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()
 	{
+		assert(m_finished);
 	}
-	
-	void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor)
+
+	void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor)
 	{
-		detail::node& node = Push(anchor);
-		node.set_null();
+		Node& node = Push(anchor);
+		node.Init(NodeType::Null, mark, "");
 		Pop();
 	}
-	
-	void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor)
+
+	void NodeBuilder::OnAlias(const Mark& /*mark*/, anchor_t anchor)
 	{
-		detail::node& node = *m_anchors[anchor];
-		Push(node);
+		Node& node = *m_anchors[anchor];
+		Insert(node);
+		node.MarkAsAliased();
+	}
+
+	void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value)
+	{
+		Node& node = Push(anchor);
+		node.Init(NodeType::Scalar, mark, tag);
+		node.SetScalarData(value);
 		Pop();
 	}
-	
-	void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag, anchor_t anchor, const std::string& value)
+
+	void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor)
 	{
-		detail::node& node = Push(anchor);
-		node.set_scalar(value);
-		node.set_tag(tag);
-		Pop();
+		Node& node = Push(anchor);
+		node.Init(NodeType::Sequence, mark, tag);
 	}
-	
-	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)
+
+	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();
+		Node& node = Push(anchor);
+		node.Init(NodeType::Map, mark, tag);
+		m_didPushKey.push(false);
 	}
 
-	detail::node& NodeBuilder::Push(anchor_t anchor)
+	void NodeBuilder::OnMapEnd()
 	{
-		detail::node& node = m_pMemory->create_node();
+		m_didPushKey.pop();
+		Pop();
+	}
+	
+	Node& NodeBuilder::Push(anchor_t anchor)
+	{
+		Node& node = Push();
 		RegisterAnchor(anchor, node);
-		Push(node);
 		return node;
 	}
 	
-	void NodeBuilder::Push(detail::node& node)
+	Node& NodeBuilder::Push()
 	{
-		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
+		if(!m_initializedRoot) {
+			m_initializedRoot = true;
+			return m_root;
+		}
 		
-		m_stack.push_back(&node);
-		if(needsKey)
-			m_keys.push_back(PushedKey(&node, false));
+		Node& node = m_root.CreateNode();
+		m_stack.push(&node);
+		return node;
+	}
+	
+	Node& NodeBuilder::Top()
+	{
+		return m_stack.empty() ? m_root : *m_stack.top();
 	}
 	
 	void NodeBuilder::Pop()
 	{
-		assert(!m_stack.empty());
-		if(m_stack.size() == 1) {
-			m_pRoot = m_stack[0];
-			m_stack.pop_back();
+		assert(!m_finished);
+		if(m_stack.empty()) {
+			m_finished = true;
 			return;
 		}
 		
-		detail::node& node = *m_stack.back();
-		m_stack.pop_back();
+		Node& node = *m_stack.top();
+		m_stack.pop();
+		Insert(node);
+	}
+	
+	void NodeBuilder::Insert(Node& node)
+	{
+		Node& curTop = Top();
+		switch(curTop.Type()) {
+			case NodeType::Null:
+			case NodeType::Scalar:
+				assert(false);
+				break;
+			case NodeType::Sequence:
+				curTop.Append(node);
+				break;
+			case NodeType::Map:
+				assert(!m_didPushKey.empty());
+				if(m_didPushKey.top()) {
+					assert(!m_pendingKeys.empty());
 
-		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();
+					Node& key = *m_pendingKeys.top();
+					m_pendingKeys.pop();
+					curTop.Insert(key, node);
+					m_didPushKey.top() = false;
+				} else {
+					m_pendingKeys.push(&node);
+					m_didPushKey.top() = true;
+				}
+				break;
 		}
 	}
 
-	void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
+	void NodeBuilder::RegisterAnchor(anchor_t anchor, Node& node)
 	{
 		if(anchor) {
 			assert(anchor == m_anchors.size());

src/nodebuilder.h

@@ -1,26 +1,26 @@
-#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#ifndef NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define 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 <map>
+#include <memory>
+#include <stack>
 #include <vector>
 
 namespace YAML
 {
 	class Node;
-
+	
 	class NodeBuilder: public EventHandler
 	{
 	public:
-		NodeBuilder();
+		explicit NodeBuilder(Node& root);
 		virtual ~NodeBuilder();
-		
-		Node Root();
-		
+
 		virtual void OnDocumentStart(const Mark& mark);
 		virtual void OnDocumentEnd();
 		
@@ -35,24 +35,27 @@ namespace YAML
 		virtual void OnMapEnd();
 		
 	private:
-		detail::node& Push(anchor_t anchor);
-		void Push(detail::node& node);
+		Node& Push(anchor_t anchor);
+		Node& Push();
+		Node& Top();
 		void Pop();
-		void RegisterAnchor(anchor_t anchor, detail::node& node);
+
+		void Insert(Node& node);
+		void RegisterAnchor(anchor_t anchor, Node& node);
 		
 	private:
-		detail::shared_memory_holder m_pMemory;
-		detail::node *m_pRoot;
+		Node& m_root;
+		bool m_initializedRoot;
+		bool m_finished;
 		
-		typedef std::vector<detail::node *> Nodes;
-		Nodes m_stack;
-		Nodes m_anchors;
+		std::stack<Node *> m_stack;
+		std::stack<Node *> m_pendingKeys;
+		std::stack<bool> m_didPushKey;
 
-		typedef std::pair<detail::node *, bool> PushedKey;
-		std::vector<PushedKey> m_keys;
-		std::size_t m_mapDepth;
+		typedef std::vector<Node *> Anchors;
+		Anchors m_anchors;
 	};
 }
 
-#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif // NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 

src/nodeevents.cpp

@@ -1,99 +0,0 @@
-#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;
-	}
-}

src/nodeevents.h

@@ -1,57 +0,0 @@
-#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
-

src/nodeownership.cpp

@@ -0,0 +1,31 @@
+#include "nodeownership.h"
+#include "yaml-cpp/node.h"
+
+namespace YAML
+{
+	NodeOwnership::NodeOwnership(NodeOwnership *pOwner): m_pOwner(pOwner)
+	{
+		if(!m_pOwner)
+			m_pOwner = this;
+	}
+	
+	NodeOwnership::~NodeOwnership()
+	{
+	}
+
+	Node& NodeOwnership::_Create()
+	{
+		m_nodes.push_back(std::auto_ptr<Node>(new Node));
+		return m_nodes.back();
+	}
+
+	void NodeOwnership::_MarkAsAliased(const Node& node)
+	{
+		m_aliasedNodes.insert(&node);
+	}
+
+	bool NodeOwnership::_IsAliased(const Node& node) const
+	{
+		return m_aliasedNodes.count(&node) > 0;
+	}
+}

src/nodeownership.h

@@ -0,0 +1,39 @@
+#ifndef NODE_OWNERSHIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_OWNERSHIP_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/noncopyable.h"
+#include "ptr_vector.h"
+#include <set>
+
+namespace YAML
+{
+	class Node;
+	
+	class NodeOwnership: private noncopyable
+	{
+	public:
+		explicit NodeOwnership(NodeOwnership *pOwner = 0);
+		~NodeOwnership();
+		
+		Node& Create() { return m_pOwner->_Create(); }
+		void MarkAsAliased(const Node& node) { m_pOwner->_MarkAsAliased(node); }
+		bool IsAliased(const Node& node) const { return m_pOwner->_IsAliased(node); }
+		
+	private:
+		Node& _Create();
+		void _MarkAsAliased(const Node& node);
+		bool _IsAliased(const Node& node) const;
+		
+	private:
+		ptr_vector<Node> m_nodes;
+		std::set<const Node *> m_aliasedNodes;
+		NodeOwnership *m_pOwner;
+	};
+}
+
+#endif // NODE_OWNERSHIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/null.cpp

@@ -1,6 +1,12 @@
 #include "yaml-cpp/null.h"
+#include "yaml-cpp/node.h"
 
 namespace YAML
 {
 	_Null Null;
+
+	bool IsNull(const Node& node)
+	{
+		return node.Read(Null);
+	}
 }

src/parse.cpp

@@ -1,64 +0,0 @@
-#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);
-    }
-}

src/parser.cpp

@@ -1,7 +1,9 @@
 #include "yaml-cpp/parser.h"
 #include "yaml-cpp/eventhandler.h"
 #include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/node.h"
 #include "directives.h"
+#include "nodebuilder.h"
 #include "scanner.h"
 #include "singledocparser.h"
 #include "tag.h"
@@ -53,6 +55,15 @@ namespace YAML
 		return true;
 	}
 
+	// GetNextDocument
+	// . Reads the next document in the queue (of tokens).
+	// . Throws a ParserException on error.
+	bool Parser::GetNextDocument(Node& document)
+	{
+		NodeBuilder builder(document);
+		return HandleNextDocument(builder);
+	}
+
 	// ParseDirectives
 	// . Reads any directives that are next in the queue.
 	void Parser::ParseDirectives()

src/stream.cpp

@@ -400,7 +400,8 @@ namespace YAML
 		if (m_nPrefetchedUsed >= m_nPrefetchedAvailable)
 		{
 			std::streambuf *pBuf = m_input.rdbuf();
-			m_nPrefetchedAvailable = static_cast<std::size_t>(pBuf->sgetn(ReadBuffer(m_pPrefetched), YAML_PREFETCH_SIZE));
+			m_nPrefetchedAvailable = pBuf->sgetn(ReadBuffer(m_pPrefetched), 
+				YAML_PREFETCH_SIZE);
 			m_nPrefetchedUsed = 0;
 			if (!m_nPrefetchedAvailable)
 			{

test/CMakeLists.txt

@@ -1,8 +1,8 @@
 file(GLOB test_headers [a-z]*.h)
 file(GLOB test_sources [a-z]*.cpp)
-file(GLOB test_new_api_sources new-api/[a-z]*.cpp)
+file(GLOB test_old_api_sources old-api/[a-z]*.cpp)
 
-list(APPEND test_sources ${test_new_api_sources})
+list(APPEND test_sources ${test_old_api_sources})
 
 include_directories(${YAML_CPP_SOURCE_DIR}/test)
 

test/emittertests.cpp

@@ -1008,7 +1008,10 @@ namespace Test
 
 			if(output == desiredOutput) {
 				try {
-                    YAML::Node node = YAML::Load(output);
+					std::stringstream stream(output);
+					YAML::Parser parser;
+					YAML::Node node;
+					parser.GetNextDocument(node);
 					passed++;
 				} catch(const YAML::Exception& e) {
 					std::cout << "Emitter test failed: " << name << "\n";

test/new-api/nodetests.cpp

@@ -1,433 +0,0 @@
-#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;
-	}
-}

test/new-api/parsertests.cpp

@@ -1,8 +0,0 @@
-#include "parsertests.h"
-
-namespace Test {
-	bool RunParserTests()
-	{
-		return true;
-	}
-}

test/tests.cpp

@@ -22,10 +22,7 @@ namespace Test
 
 		if(!RunSpecTests())
 			passed = false;
-
-		if(!RunNodeTests())
-			passed = false;
-
+		
 		if(passed)
 			std::cout << "All tests passed!\n";
 	}

util/parse.cpp

@@ -37,8 +37,13 @@ public:
 void parse(std::istream& input)
 {
 	try {
-		YAML::Node doc = YAML::Load(input);
-		std::cout << doc << "\n";
+		YAML::Parser parser(input);
+		YAML::Node doc;
+		while(parser.GetNextDocument(doc)) {
+			YAML::Emitter emitter;
+			emitter << doc;
+			std::cout << emitter.c_str() << "\n";
+		}
 	} catch(const YAML::Exception& e) {
 		std::cerr << e.what() << "\n";
 	}