Changeset 703:32f280a5ed7d in lemon-0.x for src/work

Timestamp:

07/15/04 14:15:58 (20 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@954

Message:

 

Location:

src/work/deba

Files:

• array_map_factory.h (modified) (15 diffs)
• extended_pair.h (modified) (3 diffs)
• list_graph.h (modified) (2 diffs)
• main.cpp (modified) (3 diffs)
• map_defines.h (modified) (2 diffs)
• map_registry.h (modified) (1 diff)
• vector_map_factory.h (modified) (8 diffs)

src/work/deba/array_map_factory.h

@@ +1 @@
+// -*- c++ -*-
 #ifndef ARRAY_MAP_H
 #define ARRAY_MAP_H
@@ -4 +5 @@
 #include <memory>
 
-
-#include <iostream>
-using namespace std;
+#include "extended_pair.h"
 
 namespace hugo {
@@ -20 +19 @@
     typedef typename MapRegistry::MapBase MapBase;
                 
-    template <typename V, typename A = std::allocator<V> > class Map : public MapBase {
+    template <typename V, typename A = std::allocator<V> > 
+    class Map : public MapBase {
     
       public:
@@ -31 +31 @@
                         
       Map(const Graph& g, MapRegistry& r) : MapBase(g, r) {
-        int max_id = -1;
-        for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
-          int id = getGraph()->id(it);
-          if (id > max_id) {
-            max_id = id;
-          }                     
-        }
-        if (max_id == -1) {
-          capacity = 0;
-          values = 0;
-          return;
-        }
-        capacity = 1;
-        while (capacity <= max_id) {
-          capacity <<= 1;
-        }
-        values = allocator.allocate(capacity);
+        allocate_memory();
         for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
           int id = getGraph()->id(it);
@@ -55 +39 @@
 
       Map(const Graph& g, MapRegistry& r, const Value& v) : MapBase(g, r) {
-        int max_id = -1;
-        for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
-          int id = getGraph()->id(it);
-          if (id > max_id) {
-            max_id = id;
-          }                     
-        }
-        if (max_id == -1) {
-          capacity = 0;
-          values = 0;
-          return;
-        }
-        capacity = 1;
-        while (capacity <= max_id) {
-          capacity <<= 1;
-        }
-        values = allocator.allocate(capacity);
+        allocate_memory();
         for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
           int id = getGraph()->id(it);
@@ -88 +56 @@
       }
 
-      template <typename CMap> Map(const CMap& copy) : MapBase(copy) {
+      template <typename CMap> Map(const CMap& copy) 
+        : capacity(0), values(0), MapBase(copy) {
         if (getGraph()) {
-          init();
+          allocate_memory();
           for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
             set(it, copy[it]);
@@ -118 +87 @@
         this->MapBase::operator=(copy);
         if (getGraph()) {
-          init();
+          allocate_memory();
           for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
             set(it, copy[it]);
@@ -124 +93 @@
         }
       }
-
-       
                                 
       virtual ~Map() {
@@ -182 +149 @@
       }
         
-      /** Compatible iterator with the stl maps' iterators.
-       *  It iterates on pairs of a key and a value.
-       */
       class iterator {
         friend class Map;
         friend class const_iterator;
-        private:
+      private:
 
         /** Private constructor to initalize the the iterators returned
@@ -195 +159 @@
         iterator (Map& pmap, const KeyIt& pit) : map(&pmap), it(pit) {}
 
-        public:
+      public:
 
         /** Default constructor. 
          */
         iterator() {}
+
+        typedef extended_pair<const Key&, const Key&, 
+                              Value&, Value&> Reference;
 
         /** Dereference operator for map.
          */      
-        std::pair<const Key, Value> operator*() {
-          return std::pair<const Key, Value>(it, (*map)[it]);
-        }
+        Reference operator*() {
+          return Reference(it, (*map)[it]);
+        }
+
+        class Pointer {
+          friend class iterator;
+        private:
+          Reference data;
+          Pointer(const Key& key, Value& val) : data(key, val) {}
+        public:
+          Reference* operator->() {return &data;}
+        };
 
         /** Arrow operator for map.
          */      
-        std::pair<const Key, Value>* operator->() {
-          static std::pair<const Key, Value> tmp = operator*();
-          return &tmp;
+        Pointer operator->() {
+          return Pointer(it, ((*map)[it])); 
         }
 
@@ -240 +215 @@
           return !(*this == p_it);
         }
-        
-        private:
+
+        
+      private:
         Map* map;
         KeyIt it;
@@ -261 +237 @@
         friend class Map;
         friend class iterator;
-        private:
+      private:
 
         /** Private constructor to initalize the the iterators returned
          *  by the begin() and end().
          */
-        const_iterator (Map& pmap, const KeyIt& pit) : map(&pmap), it(pit) {}
-
-        public:
+        const_iterator (const Map& pmap, const KeyIt& pit) 
+          : map(&pmap), it(pit) {}
+
+      public:
 
         /** Default constructor. 
@@ -276 +253 @@
         /** Constructor to convert iterator to const_iterator.
          */
-        const_iterator(iterator p_it) {
-          it = p_it.it;
-        }
+        const_iterator(iterator p_it) : map(p_it.map), it(p_it.it) {}
       
+        typedef extended_pair<const Key&, const Key&, 
+          const Value&, const Value&> Reference;
+
         /** Dereference operator for map.
          */      
-        std::pair<const Key, const Value> operator*() const {
-          return std::pair<const Key, const Value>(it, (*map)[it]);
-        }
+        Reference operator*() {
+          return Reference(it, (*map)[it]);
+        }
+
+
+        class Pointer {
+          friend class const_iterator;
+        private:
+          Reference data;
+          Pointer(const Key& key, const Value& val) : data(key, val) {}
+        public:
+          Reference* operator->() {return &data;}
+        };
 
         /** Arrow operator for map.
          */      
-        std::pair<const Key, const Value>* operator->() const {
-          static std::pair<const Key, const Value> tmp = operator*();
-          return &tmp;
+        Pointer operator->() {
+          return Pointer(it, ((*map)[it])); 
         }
 
@@ -320 +307 @@
         }
         
-        private:
+
+      private:
         const Map* map;
         KeyIt it;
@@ -337 +325 @@
       }
 
-      private:
+    private:
+      
+      void allocate_memory() {
+        int max_id = -1;
+        for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
+          int id = getGraph()->id(it);
+          if (id > max_id) {
+            max_id = id;
+          }                     
+        }
+        if (max_id == -1) {
+          capacity = 0;
+          values = 0;
+          return;
+        }
+        capacity = 1;
+        while (capacity <= max_id) {
+          capacity <<= 1;
+        }
+        values = allocator.allocate(capacity);  
+      }      
       int capacity;
       Value* values;

src/work/deba/extended_pair.h

@@ +1 @@
+// -*- c++ -*-
 #ifndef EXTENDED_PAIR_H
 #define EXTENDED_PAIR_H
@@ -7 +8 @@
   typedef T2 second_type;
 
+  extended_pair() : first(), second() {}
+
   extended_pair(A1 f, A2 s) : first(f), second(s) {}
+
+  template <class Pair>
+  extended_pair(const Pair& pair) : first(pair.first), second(pair.second) {}
 
   T1 first;
@@ -13 +19 @@
 };
 
+template <typename T1, typename T2, 
+          typename LA1, typename LA2, typename RA1, typename RA2>
+bool operator==(const extended_pair<T1, LA1, T2, LA2>& left, 
+                const extended_pair<T1, RA1, T2, RA2>& right) {
+  return left.first == right.first && left.second == right.second;
+}
+
+template <typename T1, typename T2, 
+          typename LA1, typename LA2, typename RA1, typename RA2>
+bool operator!=(const extended_pair<T1, LA1, T2, LA2>& left, 
+                const extended_pair<T1, RA1, T2, RA2>& right) {
+  return  !(left == right);
+}
+
+template <typename T1, typename T2, 
+          typename LA1, typename LA2, typename RA1, typename RA2>
+bool operator<(const extended_pair<T1, LA1, T2, LA2>& left, 
+                const extended_pair<T1, RA1, T2, RA2>& right) {
+  if (left.first == right.first) return left.second == right.second;
+  return left.first < right.first;
+}
+
+template <typename T1, typename T2, 
+          typename LA1, typename LA2, typename RA1, typename RA2>
+bool operator>(const extended_pair<T1, LA1, T2, LA2>& left, 
+                const extended_pair<T1, RA1, T2, RA2>& right) {
+  return right < left;
+}
+
+template <typename T1, typename T2, 
+          typename LA1, typename LA2, typename RA1, typename RA2>
+bool operator<=(const extended_pair<T1, LA1, T2, LA2>& left, 
+                const extended_pair<T1, RA1, T2, RA2>& right) {
+  return !(right > left);
+}
+
+template <typename T1, typename T2, 
+          typename LA1, typename LA2, typename RA1, typename RA2>
+bool operator>=(const extended_pair<T1, LA1, T2, LA2>& left, 
+                const extended_pair<T1, RA1, T2, RA2>& right) {
+  return !(right < left);
+}
+
+
 #endif

src/work/deba/list_graph.h

@@ -13 +13 @@
 #include "invalid.h"
 
-#include "vector_map_factory.h"
+#include "array_map_factory.h"
 #include "map_registry.h"
 
@@ -77 +77 @@
     
     CREATE_MAP_REGISTRIES;
-    CREATE_MAPS(VectorMapFactory);
+    CREATE_MAPS(ArrayMapFactory);
   public:
 

src/work/deba/main.cpp

@@ +1 @@
+// -*- c++ -*-
 #include <iostream>
 #include <cstdlib>
@@ -5 +6 @@
 using namespace std;
 using namespace hugo;
+
 
 
@@ -23 +25 @@
   for (pit = map.begin(); pit != map.end(); ++pit) {
     cout << g.id(pit->first) << ' ' << pit->second << endl;
-  }
-  /*
-  ListGraph::NodeMap<double> ot_map = map;
-  for (ListGraph::NodeIt it(g); g.valid(it); g.next(it)) {
-    ot_map[it] *= 2.1;
-    cout << ot_map[it] << endl;
-  }
-  ot_map = map;
-  for (ListGraph::NodeIt it(g); g.valid(it); g.next(it)) {
-    ot_map[it] *= 3.1;
-    cout << ot_map[it] << endl;
-    }*/
+    (*pit).second = g.id(pit->first);
+    cout << g.id((*pit).first) << ' ' << (*pit).second << endl;
+  }  
+  const ListGraph::NodeMap<int> const_map = map;
+  ListGraph::NodeMap<int>::const_iterator cit;
+  for (cit = const_map.begin(); cit != const_map.end(); ++cit) {
+    cerr << g.id(cit->first) << ' ' << cit->second << endl;
+    cerr << g.id((*cit).first) << ' ' << (*cit).second << endl;
+  }  
   return 0;
 }

src/work/deba/map_defines.h

@@ -54 +54 @@
 NodeMap(const Graph& g) : Factory::Map<V>(&g, &(g.node_maps)) {} \
 NodeMap(const Graph& g, const V& v) : Factory::Map<V>(g, g.node_maps, v) {} \
-NodeMap(const NodeMap& copy) : Factory::Map<V>(copy) {} \
+NodeMap(const NodeMap& copy) \
+  : Factory::Map<V>(static_cast<const Factory::Map<V>&>(copy)) {} \
 template <typename CMap> NodeMap(const CMap& copy) : Factory::Map<V>(copy) {} \
 NodeMap& operator=(const NodeMap& copy) { \
-  this->Factory::Map<V>::operator=(copy); \
+  this->Factory::Map<V>::operator=(static_cast<Factory::Map<V>&>(copy)); \
   return *this; \
 } \
@@ -79 +80 @@
 EdgeMap(const Graph& g) : Factory::Map<V>(g, g.edge_maps) {} \
 EdgeMap(const Graph& g, const V& v) : Factory::Map<V>(g, g.node_maps, v) {} \
-EdgeMap(const EdgeMap& copy) : Factory::Map<V>(copy) {} \
+EdgeMap(const EdgeMap& copy) \
+  : Factory::Map<V>(static_cast<Factory::Map<V>&>(copy)) {} \
 template <typename CMap> EdgeMap(const CMap& copy) : Factory::Map<V>(copy) {} \
 EdgeMap& operator=(const EdgeMap& copy) { \
-  this->Factory::Map<V>::operator=(copy); \
+  this->Factory::Map<V>::operator=(static_cast<Factory::Map<V>&>(copy)); \
   return *this; \
 } \

src/work/deba/map_registry.h

@@ -92 +92 @@
       const Graph* getGraph() const { return graph; }
         
-    private:
-                
-      const Graph* graph;
+    protected:
+                
+      const Graph* graph;     
       Registry* registry;
 

src/work/deba/vector_map_factory.h

@@ +1 @@
+// -*- c++ -*-
 #ifndef VECTOR_MAP_H
 #define VECTOR_MAP_H
 
 #include <vector>
-#include <iostream>
 
 #include "extended_pair.h"
@@ -56 +56 @@
        */
       Map(const Graph& g, MapRegistry& r, const Value& v) : MapBase(g, r) {
-        init();
         for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
-          set(it, v);
+          int id = getGraph->id(it);
+          if (id >= container.size) {
+            container.resize(id + 1);
+          }
+          set(it, v);
         }
       }
@@ -66 +69 @@
       template <typename CMap> Map(const CMap& copy) : MapBase(copy) {
         if (getGraph()) {
-          init();
           for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
+            int id = getGraph->id(it);
+            if (id >= container.size) {
+              container.resize(id + 1);
+            }
             set(it, copy[it]);
           }
@@ -81 +87 @@
         this->MapBase::operator=(copy);
         if (getGraph()) {
-          init();
           for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
+            int id = getGraph->id(it);
+            if (id >= container.size) {
+              container.resize(id + 1);
+            }
             set(it, copy[it]);
           }
@@ -91 +100 @@
        */
       virtual ~Map() {
-        destroy();
       }
                 
@@ -152 +160 @@
         iterator() {}
 
+        typedef extended_pair<const Key&, const Key&, 
+                              Value&, Value&> Reference;
+
         /** Dereference operator for map.
          */      
-        std::pair<const Key, Value> operator*() {
-          return std::pair<const Key, Value>(it, (*map)[it]);
-        }
-
+        Reference operator*() {
+          return Reference(it, (*map)[it]);
+        }
 
         class Pointer {
           friend class iterator;
         private:
-          typedef extended_pair<const Key&, const Key&, Value&, Value&> Pair;
-          Pair data;
+          Reference data;
           Pointer(const Key& key, Value& val) : data(key, val) {}
         public:
-          Pair* operator->() {return &data;}
+          Reference* operator->() {return &data;}
         };
 
@@ -228 +237 @@
          *  by the begin() and end().
          */
-        const_iterator (Map& pmap, const KeyIt& pit) : map(&pmap), it(pit) {}
+        const_iterator (const Map& pmap, const KeyIt& pit) 
+          : map(&pmap), it(pit) {}
 
       public:
@@ -238 +248 @@
         /** Constructor to convert iterator to const_iterator.
          */
-        const_iterator(iterator p_it) {
-          it = p_it.it;
-        }
+        const_iterator(iterator p_it) : map(p_it.map), it(p_it.it) {}
       
+        typedef extended_pair<const Key&, const Key&, 
+          const Value&, const Value&> Reference;
+
         /** Dereference operator for map.
          */      
-        std::pair<const Key, const Value> operator*() const {
-          return std::pair<const Key, const Value>(it, (*map)[it]);
-        }
+        Reference operator*() {
+          return Reference(it, (*map)[it]);
+        }
+
 
         class Pointer {
           friend class const_iterator;
         private:
-          typedef extended_pair<const Key&, const Key&, const Value&, const Value&> Pair;
-          Pair data;
+          Reference data;
           Pointer(const Key& key, const Value& val) : data(key, val) {}
         public:
-          Pair* operator->() {return &data;}
+          Reference* operator->() {return &data;}
         };
+
         /** Arrow operator for map.
          */      
-        Pointer operator->() const {
-          return Pointer(it, (*map)[it]);
+        Pointer operator->() {
+          return Pointer(it, ((*map)[it])); 
         }