Major switch from Value -> Node. The library compiles with the new API, but...

Major switch from Value -> Node. The library compiles with the new API, but tests are still oldies, and don't compile

src/node/detail/node_data.cpp

-#include "yaml-cpp/value/detail/node_data.h"
-#include "yaml-cpp/value/detail/memory.h"
-#include "yaml-cpp/value/detail/node.h"
+#include "yaml-cpp/node/detail/node_data.h"
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"
 #include <sstream>
 #include <stdexcept>
 
@@ -10,13 +10,13 @@ namespace YAML
 	{
 		std::string node_data::empty_scalar;
 
-		node_data::node_data(): m_isDefined(false), m_type(ValueType::Null)
+		node_data::node_data(): m_isDefined(false), m_type(NodeType::Null)
 		{
 		}
 
-		void node_data::set_type(ValueType::value type)
+		void node_data::set_type(NodeType::value type)
 		{
-			if(type == ValueType::Undefined) {
+			if(type == NodeType::Undefined) {
 				m_type = type;
 				m_isDefined = false;
 				return;
@@ -30,18 +30,18 @@ namespace YAML
 			m_type = type;
 			
 			switch(m_type) {
-				case ValueType::Null:
+				case NodeType::Null:
 					break;
-				case ValueType::Scalar:
+				case NodeType::Scalar:
 					m_scalar.clear();
 					break;
-				case ValueType::Sequence:
+				case NodeType::Sequence:
 					m_sequence.clear();
 					break;
-				case ValueType::Map:
+				case NodeType::Map:
 					m_map.clear();
 					break;
-				case ValueType::Undefined:
+				case NodeType::Undefined:
 					assert(false);
 					break;
 			}
@@ -50,13 +50,13 @@ namespace YAML
 		void node_data::set_null()
 		{
 			m_isDefined = true;
-			m_type = ValueType::Null;
+			m_type = NodeType::Null;
 		}
 		
 		void node_data::set_scalar(const std::string& scalar)
 		{
 			m_isDefined = true;
-			m_type = ValueType::Scalar;
+			m_type = NodeType::Scalar;
 			m_scalar = scalar;
 		}
 
@@ -69,8 +69,8 @@ namespace YAML
 		const_node_iterator node_data::begin() const
 		{
 			switch(m_type) {
-				case ValueType::Sequence: return const_node_iterator(m_sequence.begin());
-				case ValueType::Map: return const_node_iterator(m_map.begin());
+				case NodeType::Sequence: return const_node_iterator(m_sequence.begin());
+				case NodeType::Map: return const_node_iterator(m_map.begin());
 				default: return const_node_iterator();
 			}
 		}
@@ -78,8 +78,8 @@ namespace YAML
 		node_iterator node_data::begin()
 		{
 			switch(m_type) {
-				case ValueType::Sequence: return node_iterator(m_sequence.begin());
-				case ValueType::Map: return node_iterator(m_map.begin());
+				case NodeType::Sequence: return node_iterator(m_sequence.begin());
+				case NodeType::Map: return node_iterator(m_map.begin());
 				default: return node_iterator();
 			}
 		}
@@ -87,8 +87,8 @@ namespace YAML
 		const_node_iterator node_data::end() const
 		{
 			switch(m_type) {
-				case ValueType::Sequence: return const_node_iterator(m_sequence.end());
-				case ValueType::Map: return const_node_iterator(m_map.end());
+				case NodeType::Sequence: return const_node_iterator(m_sequence.end());
+				case NodeType::Map: return const_node_iterator(m_map.end());
 				default: return const_node_iterator();
 			}
 		}
@@ -96,8 +96,8 @@ namespace YAML
 		node_iterator node_data::end()
 		{
 			switch(m_type) {
-				case ValueType::Sequence: return node_iterator(m_sequence.end());
-				case ValueType::Map: return node_iterator(m_map.end());
+				case NodeType::Sequence: return node_iterator(m_sequence.end());
+				case NodeType::Map: return node_iterator(m_map.end());
 				default: return node_iterator();
 			}
 		}
@@ -105,7 +105,7 @@ namespace YAML
 		// sequence
 		void node_data::append(node& node, shared_memory_holder /* pMemory */)
 		{
-			if(m_type != ValueType::Sequence)
+			if(m_type != NodeType::Sequence)
 				throw std::runtime_error("Can't append to a non-sequence node");
 			
 			m_sequence.push_back(&node);
@@ -113,7 +113,7 @@ namespace YAML
 
 		void node_data::insert(node& key, node& value, shared_memory_holder /* pMemory */)
 		{
-			if(m_type != ValueType::Map)
+			if(m_type != NodeType::Map)
 				throw std::runtime_error("Can't insert into a non-map node");
 
 			m_map.push_back(kv_pair(&key, &value));
@@ -122,7 +122,7 @@ namespace YAML
 		// indexing
 		node& node_data::get(node& key, shared_memory_holder pMemory) const
 		{
-			if(m_type != ValueType::Map)
+			if(m_type != NodeType::Map)
 				return pMemory->create_node();
 			
 			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
@@ -136,16 +136,16 @@ namespace YAML
 		node& node_data::get(node& key, shared_memory_holder pMemory)
 		{
 			switch(m_type) {
-				case ValueType::Undefined:
-				case ValueType::Null:
-				case ValueType::Scalar:
-					m_type = ValueType::Map;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Scalar:
+					m_type = NodeType::Map;
 					m_map.clear();
 					break;
-				case ValueType::Sequence:
+				case NodeType::Sequence:
 					convert_sequence_to_map(pMemory);
 					break;
-				case ValueType::Map:
+				case NodeType::Map:
 					break;
 			}
 
@@ -161,7 +161,7 @@ namespace YAML
 		
 		bool node_data::remove(node& key, shared_memory_holder /* pMemory */)
 		{
-			if(m_type != ValueType::Map)
+			if(m_type != NodeType::Map)
 				return false;
 
 			for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
@@ -176,7 +176,7 @@ namespace YAML
 
 		void node_data::convert_sequence_to_map(shared_memory_holder pMemory)
 		{
-			assert(m_type == ValueType::Sequence);
+			assert(m_type == NodeType::Sequence);
 			
 			m_map.clear();
 			for(std::size_t i=0;i<m_sequence.size();i++) {
@@ -189,7 +189,7 @@ namespace YAML
 			}
 			
 			m_sequence.clear();
-			m_type = ValueType::Map;
+			m_type = NodeType::Map;
 		}
 	}
 }

src/node/emit.cpp

-#include "yaml-cpp/value/emit.h"
+#include "yaml-cpp/node/emit.h"
 #include "yaml-cpp/emitfromevents.h"
 #include "yaml-cpp/emitter.h"
-#include "valueevents.h"
+#include "nodeevents.h"
 
 namespace YAML
 {
-	Emitter& operator << (Emitter& out, const Value& value)
+	Emitter& operator << (Emitter& out, const Node& node)
 	{
 		EmitFromEvents emitFromEvents(out);
-		ValueEvents events(value);
+		NodeEvents events(node);
 		events.Emit(emitFromEvents);
 		return out;
 	}
 	
-	std::ostream& operator << (std::ostream& out, const Value& value)
+	std::ostream& operator << (std::ostream& out, const Node& node)
 	{
 		Emitter emitter;
-		emitter << value;
+		emitter << node;
 		out << emitter.c_str();
 		return out;
 	}

src/node/valuebuilder.cpp → src/node/nodebuilder.cpp

-#include "valuebuilder.h"
+#include "nodebuilder.h"
 #include "yaml-cpp/mark.h"
-#include "yaml-cpp/value.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
 #include <cassert>
 
 namespace YAML
 {
-	ValueBuilder::ValueBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
+	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
 	}
 	
-	ValueBuilder::~ValueBuilder()
+	NodeBuilder::~NodeBuilder()
 	{
 	}
 	
-	Value ValueBuilder::Root()
+	Node NodeBuilder::Root()
 	{
 		if(!m_pRoot)
-			return Value();
+			return Node();
 		
-		return Value(*m_pRoot, m_pMemory);
+		return Node(*m_pRoot, m_pMemory);
 	}
 
-	void ValueBuilder::OnDocumentStart(const Mark&)
+	void NodeBuilder::OnDocumentStart(const Mark&)
 	{
 	}
 	
-	void ValueBuilder::OnDocumentEnd()
+	void NodeBuilder::OnDocumentEnd()
 	{
 	}
 	
-	void ValueBuilder::OnNull(const Mark& mark, anchor_t anchor)
+	void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor)
 	{
 		detail::node& node = Push(anchor);
 		node.set_null();
 		Pop();
 	}
 	
-	void ValueBuilder::OnAlias(const Mark& /*mark*/, anchor_t anchor)
+	void NodeBuilder::OnAlias(const Mark& /*mark*/, anchor_t anchor)
 	{
 		detail::node& node = *m_anchors[anchor];
 		m_stack.push_back(&node);
 		Pop();
 	}
 	
-	void ValueBuilder::OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value)
+	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);
 		Pop();
 	}
 	
-	void ValueBuilder::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor)
+	void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor)
 	{
 		detail::node& node = Push(anchor);
-		node.set_type(ValueType::Sequence);
+		node.set_type(NodeType::Sequence);
 	}
 	
-	void ValueBuilder::OnSequenceEnd()
+	void NodeBuilder::OnSequenceEnd()
 	{
 		Pop();
 	}
 	
-	void ValueBuilder::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(ValueType::Map);
+		node.set_type(NodeType::Map);
 		m_mapDepth++;
 	}
 	
-	void ValueBuilder::OnMapEnd()
+	void NodeBuilder::OnMapEnd()
 	{
 		assert(m_mapDepth > 0);
 		m_mapDepth--;
 		Pop();
 	}
 
-	detail::node& ValueBuilder::Push(anchor_t anchor)
+	detail::node& NodeBuilder::Push(anchor_t anchor)
 	{
-		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == ValueType::Map && m_keys.size() < m_mapDepth);
+		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
 		
 		detail::node& node = m_pMemory->create_node();
 		m_stack.push_back(&node);
@@ -90,7 +91,7 @@ namespace YAML
 		return node;
 	}
 	
-	void ValueBuilder::Pop()
+	void NodeBuilder::Pop()
 	{
 		assert(!m_stack.empty());
 		if(m_stack.size() == 1) {
@@ -104,9 +105,9 @@ namespace YAML
 
 		detail::node& collection = *m_stack.back();
 		
-		if(collection.type() == ValueType::Sequence) {
+		if(collection.type() == NodeType::Sequence) {
 			collection.append(node, m_pMemory);
-		} else if(collection.type() == ValueType::Map) {
+		} else if(collection.type() == NodeType::Map) {
 			detail::node& key = *m_keys.back();
 			if(&key != &node) {
 				m_keys.pop_back();
@@ -118,7 +119,7 @@ namespace YAML
 		}
 	}
 
-	void ValueBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
+	void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
 	{
 		if(anchor) {
 			assert(anchor == m_anchors.size());

src/node/valuebuilder.h → src/node/nodebuilder.h

-#ifndef VALUE_VALUEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_VALUEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#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/value/ptr.h"
+#include "yaml-cpp/node/ptr.h"
 #include <vector>
 
 namespace YAML
 {
-	class Value;
+	class Node;
 
-	class ValueBuilder: public EventHandler
+	class NodeBuilder: public EventHandler
 	{
 	public:
-		ValueBuilder();
-		virtual ~ValueBuilder();
+		NodeBuilder();
+		virtual ~NodeBuilder();
 		
-		Value Root();
+		Node Root();
 		
 		virtual void OnDocumentStart(const Mark& mark);
 		virtual void OnDocumentEnd();
@@ -52,5 +52,5 @@ namespace YAML
 	};
 }
 
-#endif // VALUE_VALUEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 

src/node/valueevents.cpp → src/node/nodeevents.cpp

-#include "valueevents.h"
-#include "yaml-cpp/value.h"
+#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 ValueEvents::AliasManager::RegisterReference(const detail::node& node)
+	void NodeEvents::AliasManager::RegisterReference(const detail::node& node)
 	{
 		m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
 	}
 	
-	anchor_t ValueEvents::AliasManager::LookupAnchor(const detail::node& node) const
+	anchor_t NodeEvents::AliasManager::LookupAnchor(const detail::node& node) const
 	{
 		AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
 		if(it == m_anchorByIdentity.end())
@@ -18,22 +19,22 @@ namespace YAML
 		return it->second;
 	}
 
-	ValueEvents::ValueEvents(const Value& value): m_pMemory(value.m_pMemory), m_root(*value.m_pNode)
+	NodeEvents::NodeEvents(const Node& node): m_pMemory(node.m_pMemory), m_root(*node.m_pNode)
 	{
 		Setup(m_root);
 	}
 
-	void ValueEvents::Setup(const detail::node& node)
+	void NodeEvents::Setup(const detail::node& node)
 	{
 		int& refCount = m_refCount[node.ref()];
 		refCount++;
 		if(refCount > 1)
 			return;
 		
-		if(node.type() == ValueType::Sequence) {
+		if(node.type() == NodeType::Sequence) {
 			for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
 				Setup(**it);
-		} else if(node.type() == ValueType::Map) {
+		} else if(node.type() == NodeType::Map) {
 			for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
 				Setup(*it->first);
 				Setup(*it->second);
@@ -41,7 +42,7 @@ namespace YAML
 		}
 	}
 
-	void ValueEvents::Emit(EventHandler& handler)
+	void NodeEvents::Emit(EventHandler& handler)
 	{
 		AliasManager am;
 		
@@ -50,7 +51,7 @@ namespace YAML
 		handler.OnDocumentEnd();
 	}
 
-	void ValueEvents::Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const
+	void NodeEvents::Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const
 	{
 		anchor_t anchor = NullAnchor;
 		if(IsAliased(node)) {
@@ -65,21 +66,21 @@ namespace YAML
 		}
 		
 		switch(node.type()) {
-			case ValueType::Undefined:
+			case NodeType::Undefined:
 				break;
-			case ValueType::Null:
+			case NodeType::Null:
 				handler.OnNull(Mark(), anchor);
 				break;
-			case ValueType::Scalar:
+			case NodeType::Scalar:
 				handler.OnScalar(Mark(), "", anchor, node.scalar());
 				break;
-			case ValueType::Sequence:
+			case NodeType::Sequence:
 				handler.OnSequenceStart(Mark(), "", anchor);
 				for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
 					Emit(**it, handler, am);
 				handler.OnSequenceEnd();
 				break;
-			case ValueType::Map:
+			case NodeType::Map:
 				handler.OnMapStart(Mark(), "", anchor);
 				for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
 					Emit(*it->first, handler, am);
@@ -90,7 +91,7 @@ namespace YAML
 		}
 	}
 
-	bool ValueEvents::IsAliased(const detail::node& node) const
+	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/node/valueevents.h → src/node/nodeevents.h

-#ifndef VALUE_VALUEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_VALUEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#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/value/ptr.h"
+#include "yaml-cpp/node/ptr.h"
 #include <map>
 #include <vector>
 
 namespace YAML
 {
-	class Value;
 	class EventHandler;
+	class Node;
 	
-	class ValueEvents
+	class NodeEvents
 	{
 	public:
-		explicit ValueEvents(const Value& value);
+		explicit NodeEvents(const Node& node);
 		
 		void Emit(EventHandler& handler);
 		
@@ -53,5 +53,5 @@ namespace YAML
 	};
 }
 
-#endif // VALUE_VALUEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 

src/node/parse.cpp

-#include "yaml-cpp/value/parse.h"
-#include "yaml-cpp/value/value.h"
-#include "yaml-cpp/value/impl.h"
+#include "yaml-cpp/node/parse.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
 #include "yaml-cpp/parser.h"
-#include "valuebuilder.h"
+#include "nodebuilder.h"
 
 #include <sstream>
 
 namespace YAML
 {
-	Value Parse(const std::string& input) {
+	Node Parse(const std::string& input) {
 		std::stringstream stream(input);
 		return Parse(stream);
 	}
 	
-	Value Parse(const char *input) {
+	Node Parse(const char *input) {
 		std::stringstream stream(input);
 		return Parse(stream);
 	}
 	
-	Value Parse(std::istream& input) {
+	Node Parse(std::istream& input) {
 		Parser parser(input);
-		ValueBuilder builder;
+		NodeBuilder builder;
 		if(!parser.HandleNextDocument(builder))
-			return Value();
+			return Node();
 		
 		return builder.Root();
 	}

src/parser.cpp

@@ -3,7 +3,6 @@
 #include "yaml-cpp/eventhandler.h"
 #include "yaml-cpp/exceptions.h"
 #include "yaml-cpp/node.h"
-#include "nodebuilder.h"
 #include "scanner.h"
 #include "singledocparser.h"
 #include "tag.h"
@@ -11,6 +10,10 @@
 #include <sstream>
 #include <cstdio>
 
+#if YAML_CPP_OLD_API
+#include "old-api/nodebuilder.h"
+#endif
+
 namespace YAML
 {
 	Parser::Parser()
@@ -55,6 +58,7 @@ namespace YAML
 		return true;
 	}
 
+#if YAML_CPP_OLD_API
 	// GetNextDocument
 	// . Reads the next document in the queue (of tokens).
 	// . Throws a ParserException on error.
@@ -63,6 +67,7 @@ namespace YAML
 		NodeBuilder builder(document);
 		return HandleNextDocument(builder);
 	}
+#endif
 
 	// ParseDirectives
 	// . Reads any directives that are next in the queue.

util/value.cpp

-#include "yaml-cpp/value.h"
+#include "yaml-cpp/yaml.h"
 #include <map>
 
 int main()
 {
-	YAML::Value value = YAML::Parse("{foo: bar, monkey: value}");
-	std::cout << value << "\n";
+	YAML::Node node = YAML::Parse("{foo: bar, monkey: value}");
+	std::cout << node << "\n";
 	
 	return 0;
 }