Finished the main iterator stuff, now have to hook it to the nodes/values

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

@@ -16,30 +16,42 @@ namespace YAML
 {
 	namespace detail
 	{
-		template<typename V> struct iterator_value;
+		struct iterator_value;
 
 		template<typename V>
 		class iterator_base: public boost::iterator_adaptor<
 		iterator_base<V>,
-		node_iterator_base<V, typename node_iterator<V>::seq, typename node_iterator<V>::map>,
-		iterator_value<V>,
+		node_iterator,
+		V,
 		std::bidirectional_iterator_tag>
 		{
 		private:
-			template<typename W> friend class iterator_base<W>;
+			template<typename> friend class iterator_base;
+			struct enabler {};
+			typedef typename iterator_base::iterator_adaptor_::base_type base_type;
+			typedef typename iterator_base::iterator_adaptor_::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) {}
+			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() = this->base()->next(); }
 			void decrement() { this->base_reference() = this->base()->previous(); }
+			
+			value_type dereference() {
+				const typename base_type::value_type& v = *this->base();
+				if(v.pNode)
+					return value_type(Value(*v.pNode, m_pMemory));
+				if(v.pKey && v.pValue)
+					return value_type(Value(*v.pKey, m_pMemory), Value(*v.pValue, m_pMemory));
+				return value_type();
+			}
 		
 		private:
 			shared_memory_holder m_pMemory;

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

@@ -14,24 +14,14 @@
 namespace YAML
 {
 	class node;
-
+	
 	namespace detail {
-		struct iterator_value;
-		typedef std::vector<node *> node_seq;
-		typedef std::pair<node *, node *> kv_pair;
-		typedef std::list<kv_pair> node_map;
-		
-		typedef node_seq::iterator node_seq_iterator;
-		typedef node_seq::const_iterator node_seq_const_iterator;
-		
-		typedef node_map::iterator node_map_iterator;
-		typedef node_map::const_iterator node_map_const_iterator;
-		
-		template<typename V, typename SeqIter, typename MapIter> class iterator_base;
+		class iterator_value;
+		template<typename V> class iterator_base;
 	}
-	
-	typedef detail::iterator_base<detail::iterator_value, detail::node_seq_iterator, detail::node_map_iterator> iterator;
-	typedef detail::iterator_base<const detail::iterator_value, detail::node_seq_const_iterator, detail::node_map_const_iterator> const_iterator;
+
+	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/value/detail/node_iterator.h

@@ -22,37 +22,60 @@ namespace YAML
 		
 		template<typename V>
 		struct node_iterator_value {
-			iterator_value(): pNode(0), pKey(0), pValue(0) {}
-			explicit iterator_value(V& rhs): pNode(&rhs), pKey(0), pValue(0) {}
-			explicit iterator_value(V& key, V& value): pNode(0), pKey(&key), pValue(&value) {}
+			node_iterator_value(): pNode(0), pKey(0), pValue(0) {}
+			explicit node_iterator_value(V& rhs): pNode(&rhs), pKey(0), pValue(0) {}
+			explicit node_iterator_value(V& key, V& value): pNode(0), pKey(&key), pValue(&value) {}
 			
 			V *pNode;
 			V *pKey, *pValue;
 		};
 		
-		template<typename V, typename SeqIter, typename MapIter>
-		class node_iterator_base: public boost::iterator_facade<node_iterator_base<V, SeqIter, MapIter>, node_iterator_value<V>, std::bidirectional_iterator_tag>
+		typedef std::vector<node *> node_seq;
+		typedef std::pair<node *, node *> kv_pair;
+		typedef std::list<kv_pair> 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::bidirectional_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;
 			
-			iterator_base(): m_type(iterator_type::None) {}
+			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): m_type(iterator_type::Map), m_mapIt(mapIt) {}
 			
-			template<typename W, typename I, typename J>
-			node_iterator_base(const node_iterator_base<W, I, J>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler())
+			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) {}
 			
 		private:
 			friend class boost::iterator_core_access;
-			template<typename, typename, typename> friend class node_iterator_base;
+			template<typename> friend class node_iterator_base;
 			
-			template<typename W, typename I, typename J>
-			bool equal(const node_iterator_base<W, I, J>& rhs) const {
+			template<typename W>
+			bool equal(const node_iterator_base<W>& rhs) const {
 				if(m_type != rhs.m_type)
 					return false;
 				
@@ -83,7 +106,7 @@ namespace YAML
 			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::Sequence: return value_type(**m_seqIt);
 					case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
 				}
 				return V();
@@ -95,25 +118,9 @@ namespace YAML
 			SeqIter m_seqIt;
 			MapIter m_mapIt;
 		};
-		
-		typedef std::vector<node *> node_seq;
-		typedef std::pair<node *, node *> kv_pair;
-		typedef std::list<kv_pair> node_map;
-		
-		template<typename V>
-		struct node_iterator {
-			typedef node_seq::iterator seq;
-			typedef node_map::iterator map;
-		};
-		
-		template<typename V>
-		struct node_iterator<const V> {
-			typedef node_seq::const_iterator seq;
-			typedef node_map::const_iterator map;
-		};
 
-		typedef node_iterator_base<node, detail::node_seq_iterator,node_map_iterator> node_iterator;
-		typedef node_iterator_base<const node, node_seq_const_iterator, node_map_const_iterator> const_node_iterator;
+		typedef node_iterator_base<node> node_iterator;
+		typedef node_iterator_base<const node> const_node_iterator;
 	}
 }