almost finished implementing exercise 3; the difference between begin()/first() and end()/last() is unclear and left for tomorrow

tiberius · tiberius · commit 90037a7db4bb · 2012-06-19T02:22:12.000+02:00
diff --git a/cpp4j/cpp4j.pro b/cpp4j/cpp4j.pro
@@ -16,7 +16,8 @@ HEADERS += greater.h \
            rationalnumberarray.h \
            tree.h \
            treeiterator.h \
-           treenode.h
+           treenode.h \
+    map.h
 SOURCES += rationalnumber.cpp \
            rationalnumberarray.cpp \
            testMain.cpp \
diff --git a/cpp4j/map.h b/cpp4j/map.h
@@ -0,0 +1,83 @@
+#ifndef MAP_H
+#define MAP_H
+
+#include "pair.h"
+#include "tree.h"
+#include "treeiterator.h"
+
+template <class KeyT, class ValueT, class Order> class Map {
+
+public:
+
+    typedef Pair<KeyT, ValueT> KVPair;
+
+    typedef TreeIterator<KVPair, Order> iterator;
+    typedef Tree<KVPair, Order> KVTree;
+
+    ValueT& operator[](const KeyT& key) {
+        iterator i = find(key);
+
+        if (!i.isValid()) {
+            ValueT dummy;
+            KVPair kv (key, dummy);
+            i = insert(kv);
+        }
+
+        KVPair & kv = *i;
+        return kv.second();
+
+    }
+
+    iterator insert(const Pair<KeyT,ValueT>& kv) {
+        iterator i = find(kv.first());
+        if (i.isValid()) {
+            // update
+            *i = kv;
+        } else {
+            i = m_tree.insert(kv);
+        }
+
+        return i;
+    }
+
+    iterator find(const KeyT& key) {
+        ValueT dummy;
+        KVPair kv (key, dummy);
+        return m_tree.find(kv);
+    }
+
+    iterator begin() {
+        return m_tree.begin();
+    }
+
+    iterator end() {
+        return m_tree.end();
+    }
+
+    iterator first() {
+        return m_tree.first();
+    }
+
+    iterator last() {
+        return m_tree.last();
+    }
+
+    const KeyT& min() {
+        return first()->first();
+    }
+
+    const KeyT& max() {
+        return last()->first();
+    }
+
+    void clear() {
+        m_tree.clear();
+    }
+
+private:
+
+    KVTree m_tree;
+
+};
+
+#endif // MAP_H
diff --git a/cpp4j/maptofirst.h b/cpp4j/maptofirst.h
@@ -4,13 +4,13 @@
 #include "pair.h"
 
 //        int       string    less
-template <class T1, class T2, template<class> class Order > class MapToFirst {
+template <class T1, class T2, class Order > class MapToFirst {
 
 public:
 
                              //int,string
     bool operator ()(const Pair<T1,T2> &left, const Pair<T1,T2> &right){
-        Order<T1> functor; // less<int>
+        Order functor; // less<int>
         return functor(left.first(),right.first());
     }
 
diff --git a/cpp4j/pair.h b/cpp4j/pair.h
@@ -7,24 +7,17 @@ template <class T1, class T2> class Pair {
 
 public :
 
-    Pair  ():
-        m_first(),
-        m_second()
-    { }
-
-    Pair (T1 firstParam, T2 secondParam):
-        m_first(firstParam),
-        m_second(secondParam)
-    { }
-
-    Pair (Pair <T1,T2>& otherPair):
-        m_first(otherPair.first()),
-        m_second(otherPair.second())
-    { }
-
-    Pair& operator=
-    (const Pair &right){
-        return Pair(right.first(), right.second());
+    Pair  (): m_first(), m_second() { }
+
+    Pair (T1 firstParam, T2 secondParam): m_first(firstParam), m_second(secondParam) { }
+
+    Pair (const Pair <T1,T2>& otherPair): m_first(otherPair.first()), m_second(otherPair.second()) { }
+    Pair (Pair <T1,T2>& otherPair): m_first(otherPair.first()), m_second(otherPair.second()) { }
+
+    Pair& operator= (const Pair &right){
+        m_first = right.first();
+        m_second = right.second();
+        return *this;
     }
 
     friend ostream& operator<< (ostream &os, const Pair<T1,T2>& pair){
@@ -50,7 +43,7 @@ public :
 
 private:
 
-    T1 m_first ;
+    T1 m_first;
     T2 m_second;
 
 };
diff --git a/cpp4j/testTemplates.cpp b/cpp4j/testTemplates.cpp
@@ -19,7 +19,7 @@ using namespace std;
 #include "maptofirst.h"
 //#include "order.h"
 #include "tree.h"
-//#include "map.h"
+#include "map.h"
 
 // you should define your own namespace for
 // the templates/classes in this project
@@ -91,7 +91,7 @@ int testTemplates(void)
 
     /////////////////////////////////////////
     // TEST PAIR ORDER
-    MapToFirst< int, float, Less > lessPair;
+    MapToFirst< int, float, Less<int> > lessPair;
     cout << i_f << " < " << i_f2 << " == " << lessPair(i_f, i_f2) << endl;
     assert(lessPair(i_f, i_f2));
 
@@ -156,7 +156,7 @@ int testTemplates(void)
 
     // now we contruct a tree with a "reverse" order
     //typedef Tree< float, Greater<float> > RevFloatTree; // had to replace this line by the following
-    typedef Tree< float, Greater > RevFloatTree;
+    typedef Tree< float, Greater<float> > RevFloatTree;
     RevFloatTree ft;
     ft.insert(3.1);
     ft.insert(6.2);
@@ -165,18 +165,11 @@ int testTemplates(void)
     cout << "reverse-sorted 4-float tree: ";
     assert(printAndCount(ft) == 4);
 
-    RevFloatTree::iterator beginIt = ft.begin();
-    RevFloatTree::iterator endIt = ft.end();
-    cout << *beginIt;
-    cout << *endIt;
-
     // if we list elements backwards, they should be
     //   in the same order as with the function Less<>
     cout << "listing backwards: ";
     assert(printAndCountBackwards(ft) == 4);
 
-#if 0 // move this line down while your implementation proceeds...
-
     /////////////////////////////////////////
     // TEST MAP
 
@@ -186,8 +179,7 @@ int testTemplates(void)
     Pair<int,string> p7(7,"James Bond");
     string value;
 
-    Map<int,string, MapToFirst<int,string,Less> > m;
-
+    Map<int,string, MapToFirst<int, string, Less<int> > > m;
     // insert pairs of (key,value)
     m.insert(p42);
     m.insert(p7);
@@ -204,22 +196,27 @@ int testTemplates(void)
     cout << "setting m[3] and m[1]." << endl;
     m[1] = p1.second();
     m[3] = p3.second();
+    cout << "find 1 in map: " << (value=m[1]) << endl;
+    assert(value == p1.second());
     cout << "find 3 in map: " << (value=m[3]) << endl;
     assert(value == p3.second());
 
     cout << "resulting map: ";
     assert(printAndCount(m) == 4);
 
     // test first() and last(), min() and max()
-    Map<int,string>::iterator first = m.first();
-    Map<int,string>::iterator last = m.last();
+    Map<int,string, MapToFirst<int, string, Less<int> > >::iterator first = m.first();
+    Map<int,string, MapToFirst<int, string, Less<int> > >::iterator last = m.last();
     cout << "first in map: " << *first << endl;
     cout << "last in map: " << *last << endl;
     assert(first->first() == 1);
     assert(last->first() == 42);
     assert(m.min() == first->first());
     assert(m.max() == last->first());
 
+#if 0 // move this line down while your implementation proceeds...
+
+
 #endif
 
     cout << "Success!" << endl;
diff --git a/cpp4j/tree.h b/cpp4j/tree.h
@@ -5,19 +5,19 @@
 #include "treeiterator.h"
 #include "treenode.h"
 
-template <class T, template<class> class Order = Less > class Tree {
+template <class T, class Order = Less<T> > class Tree {
 
 public:
 
     Tree():m_root(NULL) {}
 
     typedef TreeIterator<T,Order> iterator;
-    typedef TreeNode<T,Order> node;
+    //typedef TreeNode<T,Order> node;
 
     iterator insert(const T& value) {
 
         if (m_root == NULL) {
-            m_root = new node(value);
+            m_root = new TreeNode<T, Order>(value);
             return begin();
         } else {
             return insert_internal (iterator (m_root, this), value);
@@ -47,21 +47,29 @@ template <class T, template<class> class Order = Less > class Tree {
         return iterator (node, this, iterator::end);
     }
 
-    /*iterator first();
-    iterator last();
-    iterator find(const T& value);*/
+    const iterator first() const {
+        return begin();
+    }
+
+    const iterator last() const {
+        return end();
+    }
+
+    iterator find(const T& value) {
+        return find_internal(iterator (m_root, this, iterator::middle), value);
+    }
 
 
 protected:
     TreeNode<T, Order> * m_root;
 
     iterator insert_internal(iterator i, const T& value) {
-        Order<T> order;
+        Order order;
 
         if (order(value, i.m_node->m_value)) { // links
             iterator prev = iterator (i.m_node->m_left, this);
             if (prev.m_node == NULL) {
-                prev.m_node = new node(value);
+                prev.m_node = new TreeNode<T,Order>(value);
                 prev.m_node->m_up = i.m_node;
                 i.m_node->m_left = prev.m_node;
                 return prev;
@@ -73,7 +81,7 @@ template <class T, template<class> class Order = Less > class Tree {
         } else if (order(i.m_node->m_value, value)) { // rechts
             iterator next = iterator (i.m_node->m_right, this);
             if (next.m_node == NULL) {
-                next.m_node = new node(value);
+                next.m_node = new TreeNode<T,Order>(value);
                 next.m_node->m_up = i.m_node;
                 i.m_node->m_right = next.m_node;
                 return next;
@@ -88,6 +96,23 @@ template <class T, template<class> class Order = Less > class Tree {
         }
     }
 
+    iterator find_internal (iterator i, const T& value) {
+        if (i.m_node == NULL)
+            return i;
+
+        Order order;
+
+        const bool left = order(value, i.m_node->m_value);
+        const bool right = order(i.m_node->m_value, value);
+
+        if (left)
+            return find_internal(iterator(i.m_node->m_left, this), value);
+
+        if (right)
+            return find_internal(iterator(i.m_node->m_right, this), value);
+
+        return i;
+    }
 
 };
 
diff --git a/cpp4j/treeiterator.h b/cpp4j/treeiterator.h
@@ -3,20 +3,28 @@
 
 #include "treenode.h"
 
-template <class T, template<typename> class Order > class Tree;
+template <class T, class Order > class Tree;
 
-template <class T, template<typename> class Order > class TreeIterator {
+template <class T, class Order > class TreeIterator {
 
     friend class Tree<T, Order>;
 
 public:
 
+    enum iteration_mode { begin, middle, end };
+    TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree, const iteration_mode mode = middle)
+        : m_mode(mode), m_node(node), m_tree(tree) {}
+
+    bool isValid(void) {
+        return m_node != NULL;
+    }
+
     T& operator*() {
         return m_node->value();
     }
 
     T* operator->() {
-        return m_node->value();
+        return &m_node->m_value;
     }
 
     // zum nächsten Element
@@ -71,7 +79,7 @@ template <class T, template<typename> class Order > class TreeIterator {
         if (m_node == NULL || m_mode == begin)
             return *this;
 
-        m_mode == middle;
+        m_mode = middle;
 
         if (m_node->m_left != NULL) {
             m_node = m_node->m_left;
@@ -122,18 +130,12 @@ template <class T, template<typename> class Order > class TreeIterator {
 
 protected:
 
-    enum iteration_mode { begin, middle, end };
     iteration_mode m_mode;
 
-    TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree)
-        : m_node(node), m_tree(tree), m_mode(middle) {}
-
-    TreeIterator(TreeNode<T, Order> * node, const Tree<T, Order> * tree, const iteration_mode mode)
-        : m_node(node), m_tree(tree), m_mode(mode) {}
+    TreeNode<T, Order> * m_node;
 
 private:
 
-    TreeNode<T, Order> * m_node;
     const Tree<T, Order> * m_tree;
 };
 
diff --git a/cpp4j/treenode.h b/cpp4j/treenode.h
