further tree implementation

Author: tiberius

cpp4j/testTemplates.cpp

@@ -30,7 +30,7 @@ using namespace std;
 //template class Pair<int,string>;
 //template class Tree< int,Less<int> >;
 //template class Map<int, string>;
-
+/*
 // list and count all nodes in a set using an iterator
 template<class Container>
 int printAndCount(Container & c) {
@@ -56,7 +56,7 @@ int printAndCountBackwards(Container & c) {
     }
     cout << endl;
     return n;
-}
+}*/
 
 int testTemplates(void)
 {
@@ -96,12 +96,16 @@ int testTemplates(void)
     /////////////////////////////////////////
     // TEST TREE
 
+
+    Tree<int> t;
+
+#if 0 // move this line down while your implementation proceeds...
     // construct empty tree
     Tree<int> t;
     cout << "empty tree: ";
     assert(printAndCount(t) == 0);
 
-#if 0 // move this line down while your implementation proceeds...
+
 
     // insert elements in a certain order
     t.insert(4);

cpp4j/tree.h

@@ -2,9 +2,11 @@
 #define TREE_H
 
 #include "less.h"
+#include "treenode.h"
 
 template <class T, template<typename> class Order = Less > class Tree {
 
+private:
     TreeNode<T, Order> m_root;
 
 };

cpp4j/treeiterator.h

@@ -1,6 +1,7 @@
 #ifndef TREEITERATOR_H
 #define TREEITERATOR_H
 
+#include "tree.h"
 #include "treenode.h"
 
 template <class T, template<typename> class Order > class TreeIterator {
@@ -12,11 +13,11 @@ template <class T, template<typename> class Order > class TreeIterator {
     TreeIterator(TreeNode<T, Order> node) : m_node(node) {}
 
     T& operator*() {
-        return m_node->m_value;
+        return m_node->value();
     }
 
     T* operator->() {
-        return (T*)(m_node->m_value&);
+        return m_node->value();
     }
 
     TreeIterator<T, Order>& operator++() {
@@ -25,28 +26,62 @@ template <class T, template<typename> class Order > class TreeIterator {
         if (m_node->m_right != NULL)
             return TreeIterator(m_right);
 
-        TreeNode<T, Order> parent = m_node->m_up;
+        TreeNode<T, Order> parent = m_node;
 
         Order<T> functor;
-        while (functor(m_node->m_value, parent->value)) {
+        do {
+
             parent = parent->m_up;
-        }
+
+            // keep position
+            if (parent == NULL)
+                return *this;
+
+
+        } while (functor(m_node->m_value, parent->m_value));
 
         m_node = parent;
         return *this;
     }
 
     TreeIterator<T, Order>& operator--() {
+        if (m_node->m_left != NULL) {
+            TreeNode<T, Order> node = m_node.m_left;
+            while (node->m_right != NULL)
+                node = m_right;
+
+            m_node = node;
+        } else if (m_node->m_up != NULL) {
+            TreeNode<T, Order> parent = m_node;
+
+            Order<T> functor;
+            do {
+                parent = parent->m_up;
+                // keep position
+                if (parent == NULL)
+                    return *this;
+
+            } while (functor(m_node->m_value, parent->m_value));
+
+            m_node=parent;
+        }
+
+        return *this;
+    }
+
+    bool operator==(const TreeIterator<T, Order> &rhs) {
+       return this->m_node == rhs.m_node;
+
 
     }
 
-    bool operator==(const TreeIterator<T, Order> &rhs);
     bool operator!=(const TreeIterator<T, Order> &rhs);
 
 
 private:
 
-    TreeNode<T, O> m_node;
+    TreeNode<T, Order> m_node;
+    Tree<T, Order> m_tree;
 
 };