Almost Completed SeparateChainingHashTable with test.

Todo: different hash functions.
Restructured Iterator and Node inheritance hierarchy.

YASI_12/YASI_12.vcxproj

@@ -88,6 +88,7 @@
     <ClInclude Include="ds.iterator.h">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
     </ClInclude>
+    <ClInclude Include="ds.iterator_test.h" />
     <ClInclude Include="ds.kvpair.h" />
     <ClInclude Include="ds.list.h" />
     <ClInclude Include="ds.node.h" />

YASI_12/YASI_12.vcxproj.filters

@@ -98,5 +98,8 @@
     <ClInclude Include="ds.hashtable.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="ds.iterator_test.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

YASI_12/ds.binarytreebase.h

@@ -267,9 +267,9 @@ namespace yasi{
 
 		// inorder iterator
 		template< class E, class Node>
-		class InorderBinaryTreeIterator : public NodeIterator<E, Node>{
+		class InorderBinaryTreeIterator : public ForwardNodeIterator<E, Node, InorderBinaryTreeIterator<E,Node>>{
 			typedef InorderBinaryTreeIterator<E, Node> self;
-			typedef NodeIterator<E, Node> base;
+			typedef ForwardNodeIterator<E, Node, InorderBinaryTreeIterator<E, Node>> base;
 		protected:
 			BinaryTreeBase<E, Node>* t;
 		public:
@@ -278,9 +278,9 @@ namespace yasi{
 			InorderBinaryTreeIterator(const BinaryTreeBase* t, Node* pNode) : base(pNode), t(t){}
 			InorderBinaryTreeIterator(const self& other) : base(other.pNode), t(other.t){}
 			// operators
-			self& operator ++ ()/*prefix*/{ pNode = t->inorderSuccessor(pNode); return *this; }
-			self operator ++ (int)/*postfix*/{ self temp = *this; pNode = t->inorderSuccessor(pNode); return temp; }
-			self& operator = (const self& other){ this->pNode = other.pNode; this->t = other.t; *this; }
+			virtual self& operator ++ ()/*prefix*/{ pNode = t->inorderSuccessor(pNode); return *this; }
+			virtual self operator ++ (int)/*postfix*/{ self temp = *this; pNode = t->inorderSuccessor(pNode); return temp; }
+			virtual self& operator = (const self& other){ this->pNode = other.pNode; this->t = other.t; *this; }
 		};
 
 	} // namespace ds

YASI_12/ds.doublylinkedlist.h

@@ -8,44 +8,6 @@ using namespace std;
 namespace yasi{
 namespace ds{
 
-	template< class E, class Node>
-	class DListNodeBase : public virtual ListNodeBase<E, Node>{
-		typedef Node node_t;
-	protected:
-		node_t* pPrev;
-	public:
-		DListNodeBase(): pPrev(NULL) {  }
-		DListNodeBase(const E& e) : ListNodeBase<E, Node>(e), pPrev(NULL) {}
-		virtual ~DListNodeBase(){ pPrev = NULL; }
-		virtual node_t* prev(){ return pPrev; }
-		virtual void setPrev(node_t* pNode){ pPrev = pNode; }
-	};
-
-	template<class E>
-	class DListNode : public virtual DListNodeBase< E, DListNode<E> >{
-		typedef DListNode<E> node;
-	public:
-		virtual ~DListNode(){
-			pPrev = pNext = NULL;
-		}
-		DListNode(){}
-		// because of virtual inheritance, we need to initialize 
-		// all virtual base constructors from here
-		DListNode(const E& elem): DListNodeBase<E, DListNode<E> >(elem), NodeBase<E>(elem){}
-		// to be in sync with ListNode class
-		DListNode(const E& elem, node* pNext) : DListNodeBase<E, DListNode<E> >(elem), NodeBase<E>(elem){
-			this->pNext = pNext;
-		}
-		DListNode(
-			const E& elem, 
-			node* pNext, 
-			node* pPrev) : 
-			NodeBase<E>(elem),
-			DListNodeBase<E, DListNode<E> >(elem){
-			this->pNext = pNext;
-			this->pPrev = pPrev;
-		}
-	};
 
 	// doubly linked list interface
 	template<class E, class Node, class Iter = DLLIterator<E,Node> >
@@ -64,18 +26,20 @@ namespace ds{
 
 	// doubly linked list iterator
 	template<class E, class Node>
-	class DLLIterator : public SLLIterator< E, Node > {
+	class DLLIterator : public virtual BidirectionalNodeIterator< E, Node, DLLIterator<E,Node> > {
 		typedef DLLIterator<E, Node> self;
-		typedef SLLIterator<E, Node> base;
+		typedef BidirectionalNodeIterator< E, Node, DLLIterator<E, Node> > base;
 	public:
 		virtual ~DLLIterator(){}
 		DLLIterator() {}
-		DLLIterator(Node* pNode) : base(pNode){}
-		DLLIterator(const self& other) : base(other.pNode){}
-		// operators
-		self& operator -- ()/*prefix*/{ pNode = pNode->prev(); return *this; }
-		self operator -- (int)/*postfix*/{ self temp = *this; pNode = pNode->prev(); return temp; }
-		self& operator = (const self& other){ this->pNode = other.pNode; return *this; }
+		DLLIterator(Node* pNode) : IteratorBase(pNode){}
+		DLLIterator(const base& other) : IteratorBase(other.pNode){}
+		self& operator=(const self& other){ pNode = other.pNode; return *this; }
+		virtual self operator ++ (int){ self temp(this->pNode); incr();  return temp; }
+		virtual self operator -- (int){ self temp(this->pNode); decr();  return temp; }
+		virtual self& operator ++ (){ incr();  return *this; }
+		virtual self& operator -- (){ decr();  return *this; }
+		//virtual E& operator*(){ if (pNode) return pNode->element; }
 	};
 
 	// doubly linked list class
@@ -89,6 +53,10 @@ namespace ds{
 	protected:
 		// typedefs
 		typedef Node node_t;
+	public:
+		typedef DLLIterator<E, Node> iterator;
+		typedef node_t NodeType;
+	protected:
 
 		// new members
 		//node_t* pTail;