Set the pimpl node in Node to be optional, so we don't create unnecessary guys...

Set the pimpl node in Node to be optional, so we don't create unnecessary guys every time you call Node tmp = foo[value];

include/yaml-cpp/node/impl.h

@@ -14,7 +14,7 @@
 
 namespace YAML
 {
-	inline Node::Node(): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
+	inline Node::Node(): m_pNode(0)
 	{
 	}
 	
@@ -41,15 +41,27 @@ namespace YAML
 	{
 	}
 
+	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 NodeType::value Node::Type() const
 	{
-		return m_pNode->type();
+		return m_pNode ? m_pNode->type() : NodeType::Null;
 	}
 	
 	// access
 	template<typename T>
 	inline const T Node::as() const
 	{
+		if(!m_pNode)
+			throw std::runtime_error("Unable to convert to type");
+			
 		T t;
 		if(convert<T>::decode(*this, t))
 			return t;
@@ -66,13 +78,13 @@ namespace YAML
 
 	inline const std::string& Node::scalar() const
 	{
-		return m_pNode->scalar();
+		return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
 	}
 
 	// assignment
 	inline bool Node::is(const Node& rhs) const
 	{
-		return m_pNode->is(*rhs.m_pNode);
+		return m_pNode ? m_pNode->is(*rhs.m_pNode) : false;
 	}
 
 	template<typename T>
@@ -91,16 +103,19 @@ namespace YAML
 	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);
 	}
 	
@@ -114,12 +129,18 @@ namespace YAML
 
 	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)
 	{
+		EnsureNodeExists();
+		rhs.EnsureNodeExists();
+
 		m_pNode->set_ref(*rhs.m_pNode);
 		m_pMemory->merge(*rhs.m_pMemory);
 		m_pNode = rhs.m_pNode;
@@ -128,27 +149,27 @@ namespace YAML
 	// size/iterator
 	inline std::size_t Node::size() const
 	{
-		return m_pNode->size();
+		return m_pNode ? m_pNode->size() : 0;
 	}
 
 	inline const_iterator Node::begin() const
 	{
-		return const_iterator(m_pNode->begin(), m_pMemory);
+		return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) : const_iterator();
 	}
 	
 	inline iterator Node::begin()
 	{
-		return iterator(m_pNode->begin(), m_pMemory);
+		return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
 	}
 
 	inline const_iterator Node::end() const
 	{
-		return const_iterator(m_pNode->end(), m_pMemory);
+		return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
 	}
 
 	inline iterator Node::end()
 	{
-		return iterator(m_pNode->end(), m_pMemory);
+		return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
 	}
 	
 	// sequence
@@ -160,6 +181,9 @@ namespace YAML
 	
 	inline void Node::append(const Node& rhs)
 	{
+		EnsureNodeExists();
+		rhs.EnsureNodeExists();
+		
 		m_pNode->append(*rhs.m_pNode, m_pMemory);
 		m_pMemory->merge(*rhs.m_pMemory);
 	}
@@ -168,6 +192,7 @@ namespace YAML
 	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);
 	}
@@ -175,6 +200,7 @@ namespace YAML
 	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);
 	}
@@ -182,23 +208,30 @@ namespace YAML
 	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);
 	}
 	

include/yaml-cpp/node/node.h

@@ -72,6 +72,8 @@ namespace YAML
 	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);
@@ -80,8 +82,8 @@ namespace YAML
 		void AssignNode(const Node& rhs);
 		
 	private:
-		detail::shared_memory_holder m_pMemory;
-		detail::node *m_pNode;
+		mutable detail::shared_memory_holder m_pMemory;
+		mutable detail::node *m_pNode;
 	};
 
 	bool operator==(const Node& lhs, const Node& rhs);