Copied all files from new-api branch of old repo

src/convert.cpp

+#include "yaml-cpp/node/convert.h"
+#include "yaml-cpp/node/impl.h"
+#include <algorithm>
+
+namespace
+{
+	// we're not gonna mess with the mess that is all the isupper/etc. functions
+	bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; }
+	bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; }
+	char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
+	
+	std::string tolower(const std::string& str)
+	{
+		std::string s(str);
+		std::transform(s.begin(), s.end(), s.begin(), ToLower);
+		return s;
+	}
+	
+	template <typename T>
+	bool IsEntirely(const std::string& str, T func)
+	{
+		for(std::size_t i=0;i<str.size();i++)
+			if(!func(str[i]))
+				return false;
+		
+		return true;
+	}
+	
+	// IsFlexibleCase
+	// . Returns true if 'str' is:
+	//   . UPPERCASE
+	//   . lowercase
+	//   . Capitalized
+	bool IsFlexibleCase(const std::string& str)
+	{
+		if(str.empty())
+			return true;
+		
+		if(IsEntirely(str, IsLower))
+			return true;
+		
+		bool firstcaps = IsUpper(str[0]);
+		std::string rest = str.substr(1);
+		return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
+	}
+}
+
+namespace YAML
+{
+	bool convert<bool>::decode(const Node& node, bool& rhs) {
+		if(!node.IsScalar())
+			return false;
+		
+		// we can't use iostream bool extraction operators as they don't
+		// recognize all possible values in the table below (taken from
+		// http://yaml.org/type/bool.html)
+		static const struct {
+			std::string truename, falsename;
+		} names[] = {
+			{ "y", "n" },
+			{ "yes", "no" },
+			{ "true", "false" },
+			{ "on", "off" },
+		};
+		
+		if(!IsFlexibleCase(node.Scalar()))
+			return false;
+		
+		for(unsigned i=0;i<sizeof(names)/sizeof(names[0]);i++) {
+			if(names[i].truename == tolower(node.Scalar())) {
+				rhs = true;
+				return true;
+			}
+			
+			if(names[i].falsename == tolower(node.Scalar())) {
+				rhs = false;
+				return true;
+			}
+		}
+		
+		return false;
+	}
+}

src/emit.cpp

+#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/memory.cpp

+#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_data.cpp

+#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

+#include "nodebuilder.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include <cassert>
+
+namespace YAML
+{
+	NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
+	{
+		m_anchors.push_back(0); // since the anchors start at 1
+	}
+	
+	NodeBuilder::~NodeBuilder()
+	{
+	}
+	
+	Node NodeBuilder::Root()
+	{
+		if(!m_pRoot)
+			return Node();
+		
+		return Node(*m_pRoot, m_pMemory);
+	}
+
+	void NodeBuilder::OnDocumentStart(const Mark&)
+	{
+	}
+	
+	void NodeBuilder::OnDocumentEnd()
+	{
+	}
+	
+	void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor)
+	{
+		detail::node& node = Push(anchor);
+		node.set_null();
+		Pop();
+	}
+	
+	void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor)
+	{
+		detail::node& node = *m_anchors[anchor];
+		Push(node);
+		Pop();
+	}
+	
+	void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag, anchor_t anchor, const std::string& value)
+	{
+		detail::node& node = Push(anchor);
+		node.set_scalar(value);
+		node.set_tag(tag);
+		Pop();
+	}
+	
+	void NodeBuilder::OnSequenceStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
+	{
+		detail::node& node = Push(anchor);
+		node.set_tag(tag);
+		node.set_type(NodeType::Sequence);
+	}
+	
+	void NodeBuilder::OnSequenceEnd()
+	{
+		Pop();
+	}
+	
+	void NodeBuilder::OnMapStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
+	{
+		detail::node& node = Push(anchor);
+		node.set_type(NodeType::Map);
+		node.set_tag(tag);
+		m_mapDepth++;
+	}
+	
+	void NodeBuilder::OnMapEnd()
+	{
+		assert(m_mapDepth > 0);
+		m_mapDepth--;
+		Pop();
+	}
+
+	detail::node& NodeBuilder::Push(anchor_t anchor)
+	{
+		detail::node& node = m_pMemory->create_node();
+		RegisterAnchor(anchor, node);
+		Push(node);
+		return node;
+	}
+	
+	void NodeBuilder::Push(detail::node& node)
+	{
+		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
+		
+		m_stack.push_back(&node);
+		if(needsKey)
+			m_keys.push_back(PushedKey(&node, false));
+	}
+	
+	void NodeBuilder::Pop()
+	{
+		assert(!m_stack.empty());
+		if(m_stack.size() == 1) {
+			m_pRoot = m_stack[0];
+			m_stack.pop_back();
+			return;
+		}
+		
+		detail::node& node = *m_stack.back();
+		m_stack.pop_back();
+
+		detail::node& collection = *m_stack.back();
+		
+		if(collection.type() == NodeType::Sequence) {
+			collection.push_back(node, m_pMemory);
+		} else if(collection.type() == NodeType::Map) {
+			assert(!m_keys.empty());
+			PushedKey& key = m_keys.back();
+			if(key.second) {
+				collection.insert(*key.first, node, m_pMemory);
+				m_keys.pop_back();
+			} else {
+				key.second = true;
+			}
+		} else {
+			assert(false);
+			m_stack.clear();
+		}
+	}
+
+	void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
+	{
+		if(anchor) {
+			assert(anchor == m_anchors.size());
+			m_anchors.push_back(&node);
+		}
+	}
+}

src/nodebuilder.h

+#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/node/ptr.h"
+#include <vector>
+
+namespace YAML
+{
+	class Node;
+
+	class NodeBuilder: public EventHandler
+	{
+	public:
+		NodeBuilder();
+		virtual ~NodeBuilder();
+		
+		Node Root();
+		
+		virtual void OnDocumentStart(const Mark& mark);
+		virtual void OnDocumentEnd();
+		
+		virtual void OnNull(const Mark& mark, anchor_t anchor);
+		virtual void OnAlias(const Mark& mark, anchor_t anchor);
+		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value);
+		
+		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnSequenceEnd();
+		
+		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnMapEnd();
+		
+	private:
+		detail::node& Push(anchor_t anchor);
+		void Push(detail::node& node);
+		void Pop();
+		void RegisterAnchor(anchor_t anchor, detail::node& node);
+		
+	private:
+		detail::shared_memory_holder m_pMemory;
+		detail::node *m_pRoot;
+		
+		typedef std::vector<detail::node *> Nodes;
+		Nodes m_stack;
+		Nodes m_anchors;
+
+		typedef std::pair<detail::node *, bool> PushedKey;
+		std::vector<PushedKey> m_keys;
+		std::size_t m_mapDepth;
+	};
+}
+
+#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+

src/nodeevents.cpp

+#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

+#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/parse.cpp

+#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/singledocparser.cpp

@@ -253,7 +253,6 @@ namespace YAML
 				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP_FLOW);
 			
 			Token& token = m_scanner.peek();
-            const Mark mark = token.mark;
 			// first check for end
 			if(token.type == Token::FLOW_MAP_END) {
 				m_scanner.pop();
@@ -265,7 +264,7 @@ namespace YAML
 				m_scanner.pop();
 				HandleNode(eventHandler);
 			} else {
-				eventHandler.OnNull(mark, NullAnchor);
+				eventHandler.OnNull(token.mark, NullAnchor);
 			}
 			
 			// now grab value (optional)
@@ -273,7 +272,7 @@ namespace YAML
 				m_scanner.pop();
 				HandleNode(eventHandler);
 			} else {
-				eventHandler.OnNull(mark, NullAnchor);
+				eventHandler.OnNull(token.mark, NullAnchor);
 			}
 			
 			// now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node)

test/CMakeLists.txt

 file(GLOB test_headers [a-z]*.h)
 file(GLOB test_sources [a-z]*.cpp)
-file(GLOB test_core_sources core/[a-z]*.cpp)
+file(GLOB test_new_api_sources new-api/[a-z]*.cpp)
 
-list(APPEND test_sources ${test_core_sources})
+list(APPEND test_sources ${test_new_api_sources})
 
 include_directories(${YAML_CPP_SOURCE_DIR}/test)
 

test/emittertests.cpp

 #include "tests.h"
 #include "yaml-cpp/yaml.h"
-#include "yaml-cpp/eventhandler.h"
 #include <iostream>
 
 namespace Test
@@ -1000,21 +999,6 @@ namespace Test
 	}
 	
 	namespace {
-        class NullEventHandler: public YAML::EventHandler {
-            virtual void OnDocumentStart(const YAML::Mark&) {}
-            virtual void OnDocumentEnd() {}
-            
-            virtual void OnNull(const YAML::Mark&, YAML::anchor_t) {}
-            virtual void OnAlias(const YAML::Mark&, YAML::anchor_t) {}
-            virtual void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t, const std::string&) {}
-            
-            virtual void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
-            virtual void OnSequenceEnd() {}
-            
-            virtual void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
-            virtual void OnMapEnd() {}
-        };
-        
 		void RunEmitterTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, int& passed, int& total) {
 			YAML::Emitter out;
 			std::string desiredOutput;
@@ -1024,10 +1008,7 @@ namespace Test
 
 			if(output == desiredOutput) {
 				try {
-					std::stringstream stream(output);
-					YAML::Parser parser;
-                    NullEventHandler handler;
-                    parser.HandleNextDocument(handler);
+                    YAML::Node node = YAML::Load(output);
 					passed++;
 				} catch(const YAML::Exception& e) {
 					std::cout << "Emitter test failed: " << name << "\n";

test/new-api/nodetests.cpp

+#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

+#include "parsertests.h"
+
+namespace Test {
+	bool RunParserTests()
+	{
+		return true;
+	}
+}

test/nodetests.h

+#ifndef NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace Test {
+	bool RunNodeTests();
+}
+
+#endif // NODETESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A6666
+

test/parsertests.h

+#ifndef PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace Test {
+	bool RunParserTests();
+}
+
+#endif // PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+

test/tests.cpp

 #include "tests.h"
 #include "emittertests.h"
+#include "nodetests.h"
+#include "parsertests.h"
 #include "spectests.h"
 #include "yaml-cpp/yaml.h"
 #include <fstream>
@@ -12,12 +14,18 @@ namespace Test
 	void RunAll()
 	{
 		bool passed = true;
+		if(!RunParserTests())
+			passed = false;
+			
 		if(!RunEmitterTests())
 			passed = false;
 
 		if(!RunSpecTests())
 			passed = false;
-		
+
+		if(!RunNodeTests())
+			passed = false;
+
 		if(passed)
 			std::cout << "All tests passed!\n";
 	}