text: #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 YAML_CPP_API 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); }
  
              // map
              template<typename Key, typename Value>
              void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory){ m_pRef->force_insert(key, value, 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
  