Changeset 627:6cc21a9c9fda in lemon-0.x for src/work/deba/vector_map_factory.h

Timestamp:

05/13/04 10:20:39 (20 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

 

File:

• src/work/deba/vector_map_factory.h (modified) (1 diff)

src/work/deba/vector_map_factory.h

@@ -4 +4 @@
 #include <vector>
 
-#include "map_base.h"
+#include "map_registry.h"
 
 namespace hugo {
         
-        template <typename G, typename K, typename KIt>
-        class VectorMapFactory {
+  template <typename MapRegistry>
+  class VectorMapFactory {
+  public:
+                
+    typedef typename MapRegistry::Graph Graph;
+    typedef typename MapRegistry::Key Key;
+    typedef typename MapRegistry::KeyIt KeyIt;
+
+    typedef typename MapRegistry::MapBase MapBase;
+                
+    template <typename V> 
+      class Map : public MapBase {
+      public:
+      typedef V Value;
+        
+      Map() {}
+                        
+      Map(Graph& g, MapRegistry& r) : MapBase(g, r) {
+        init();
+      }
+                        
+                                                
+      virtual ~Map() {
+        destroy();
+      }
         
         
-        public:
+      Value& operator[](const Key& key) {
+        int id = graph->id(key);
+        return container[id];
+      } 
                 
-                typedef G Graph;
-                typedef K Key;
-                typedef KIt KeyIt;
+      const Value& operator[](const Key& key) const {
+        int id = graph->id(key);
+        return container[id];
+      }
+        
+      const Value& get(const Key& key) const {
+        int id = graph->id(key);
+        return container[id];
+      } 
                 
-                template <typename V> 
-                class Map : public MapBase<G, K, KIt> {
-                public:
-                        typedef V Value;
+      void set(const Key& key, const Value& val) {
+        int id = graph->id(key);
+        container[id] = val;
+      }
+                
+      void add(const Key& key) {
+        int id = graph->id(key);
+        if (id >= container.size()) {
+          container.resize(id + 1);
+        }
+      }
+                
+      void erase(const Key& key) {}
         
-                        Map() {}
-                        
-                        Map(Graph& g, MapRegistry<G, K, KIt>& r) 
-                                : MapBase<G, K, KIt>(g, r) {
-                                init();
-                        }
-                                
-                        virtual ~Map() {
-                                destroy();
-                        }
-        
-        
-                        Value& operator[](const K& key) {
-                                int id = graph->id(key);
-                                return container[id];
-                        } 
+      private:
+      typedef std::vector<Value> Container;
                 
-                        const Value& operator[](const K& key) const {
-                                int id = graph->id(key);
-                                return container[id];
-                        }
-        
-                        const Value& get(const K& key) const {
-                                int id = graph->id(key);
-                                return container[id];
-                        } 
+      Container container;
+    };
                 
-                        void set(const K& key, const Value& val) {
-                                int id = graph->id(key);
-                                container[id] = val;
-                        }
-                
-                        void add(const K& key) {
-                                int id = graph->id(key);
-                                if (id >= container.size()) {
-                                        container.resize(id + 1);
-                                }
-                        }
-                
-                        void erase(const K& key) {}
-        
-                private:
-                        typedef std::vector<Value> Container;
-                
-                        Container container;
-                };
-                
-        };
+  };
 }