Changeset 1999:2ff283124dfc in lemon-0.x for lemon/bits/array_map.h

Timestamp:

03/06/06 11:28:37 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Clarifing alteration observing system
It is directly connected now to a container

File:

• lemon/bits/array_map.h (modified) (17 diffs)

lemon/bits/array_map.h

@@ -21 +21 @@
 
 #include <memory>
-#include <lemon/bits/map_extender.h>
+
+#include <lemon/bits/traits.h>
 #include <lemon/bits/alteration_notifier.h>
-#include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
 
 /// \ingroup graphbits
 /// \file
-/// \brief Graph maps that construct and destruct
-/// their elements dynamically.
+/// \brief Graph map based on the array storage.
 
 namespace lemon {
@@ -38 +36 @@
   ///
   /// The ArrayMap template class is graph map structure what
-  /// automatically indates the map when a key is added to or erased from
+  /// automatically updates the map when a key is added to or erased from
   /// the map. This map uses the allocators to implement 
   /// the container functionality.
   ///
-  /// The template parameter is the AlterationNotifier that the maps
-  /// will belong to and the Value.
-
-  template <typename _Graph, 
-            typename _Item,
-            typename _Value>
-  class ArrayMap : public AlterationNotifier<_Item>::ObserverBase {
-
-    typedef _Item Item;
+  /// The template parameter is the Graph the current Item type and
+  /// the Value type of the map.
+  template <typename _Graph, typename _Item, typename _Value>
+  class ArrayMap 
+    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
   public:
     /// The graph type of the maps. 
     typedef _Graph Graph;
+    /// The item type of the map.
+    typedef _Item Item;
     /// The reference map tag.
     typedef True ReferenceMapTag;
@@ -61 +57 @@
     /// The value type of the map.
     typedef _Value Value;
+
     /// The const reference type of the map.
     typedef const _Value& ConstReference;
@@ -66 +63 @@
     typedef _Value& Reference;
 
-    typedef const Value ConstValue;
-    typedef Value* Pointer;
-    typedef const Value* ConstPointer;
-
-    typedef AlterationNotifier<_Item> Registry;
+    /// The notifier type.
+    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
 
     /// The MapBase of the Map which imlements the core regisitry function.
-    typedef typename Registry::ObserverBase Parent;
+    typedef typename Notifier::ObserverBase Parent;
                 
-
-
   private:
     typedef std::allocator<Value> Allocator;
 
-
   public:
 
@@ -86 +77 @@
     ///
     /// Graph initialized map constructor.
-    ArrayMap(const Graph& _g) : graph(&_g) {
+    ArrayMap(const Graph& graph) {
+      Parent::attach(graph.getNotifier(Item()));
+      allocate_memory();
+      Notifier* notifier = Parent::getNotifier();
       Item it;
-      attach(_g.getNotifier(Item()));
-      allocate_memory();
-      for (graph->first(it); it != INVALID; graph->next(it)) {
-        int id = graph->id(it);;
+      for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        int id = notifier->id(it);;
         allocator.construct(&(values[id]), Value());
       }                                                         
@@ -99 +91 @@
     ///
     /// It constructs a map and initialize all of the the map. 
-    ArrayMap(const Graph& _g, const Value& _v) : graph(&_g) {
+    ArrayMap(const Graph& graph, const Value& value) {
+      Parent::attach(graph.getNotifier(Item()));
+      allocate_memory();
+      Notifier* notifier = Parent::getNotifier();
       Item it;
-      attach(_g.getNotifier(_Item()));
-      allocate_memory();
-      for (graph->first(it); it != INVALID; graph->next(it)) {
-        int id = graph->id(it);;
-        allocator.construct(&(values[id]), _v);
+      for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        int id = notifier->id(it);;
+        allocator.construct(&(values[id]), value);
       }                                                         
     }
@@ -112 +105 @@
     ///
     /// Constructor to copy a map of the same map type.     
-    ArrayMap(const ArrayMap& copy) : Parent(), graph(copy.graph) {
+    ArrayMap(const ArrayMap& copy) : Parent() {
       if (copy.attached()) {
-        attach(*copy.getRegistry());
+        attach(*copy.getNotifier());
       }
       capacity = copy.capacity;
       if (capacity == 0) return;
       values = allocator.allocate(capacity);
+      Notifier* notifier = Parent::getNotifier();
       Item it;
-      for (graph->first(it); it != INVALID; graph->next(it)) {
-        int id = graph->id(it);;
+      for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        int id = notifier->id(it);;
         allocator.construct(&(values[id]), copy.values[id]);
       }
@@ -146 +140 @@
     using Parent::attached;
 
-    const Graph* getGraph() {
-      return graph;
-    }
-
-
   public:
 
@@ -158 +147 @@
     /// actual keys of the graph. 
     Value& operator[](const Key& key) {
-      int id = graph->id(key);
+      int id = Parent::getNotifier()->id(key);
       return values[id];
     } 
@@ -167 +156 @@
     /// actual keys of the graph. 
     const Value& operator[](const Key& key) const {
-      int id = graph->id(key);
+      int id = Parent::getNotifier()->id(key);
       return values[id];
     }
@@ -181 +170 @@
   protected:
 
-    /// Add a new key to the map. It called by the map registry.
-         
+    /// \brief Adds a new key to the map.
+    ///         
+    /// It adds a new key to the map. It called by the observer notifier
+    /// and it overrides the add() member function of the observer base.     
     virtual void add(const Key& key) {
-      int id = graph->id(key);
+      Notifier* notifier = Parent::getNotifier();
+      int id = notifier->id(key);
       if (id >= capacity) {
         int new_capacity = (capacity == 0 ? 1 : capacity);
@@ -192 +184 @@
         Value* new_values = allocator.allocate(new_capacity);
         Item it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          int jd = graph->id(it);;
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+          int jd = notifier->id(it);;
           if (id != jd) {
             allocator.construct(&(new_values[jd]), values[jd]);
@@ -206 +198 @@
     }
 
+    /// \brief Adds more new keys to the map.
+    ///         
+    /// It adds more new keys to the map. It called by the observer notifier
+    /// and it overrides the add() member function of the observer base.     
     virtual void add(const std::vector<Key>& keys) {
+      Notifier* notifier = Parent::getNotifier();
       int max_id = -1;
       for (int i = 0; i < (int)keys.size(); ++i) {
-        int id = graph->id(keys[i]);
+        int id = notifier->id(keys[i]);
         if (id > max_id) {
           max_id = id;
@@ -221 +218 @@
         Value* new_values = allocator.allocate(new_capacity);
         Item it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          int id = graph->id(it);
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+          int id = notifier->id(it);
           bool found = false;
           for (int i = 0; i < (int)keys.size(); ++i) {
-            int jd = graph->id(keys[i]);
+            int jd = notifier->id(keys[i]);
             if (id == jd) {
               found = true;
@@ -240 +237 @@
       }
       for (int i = 0; i < (int)keys.size(); ++i) {
-        int id = graph->id(keys[i]);
+        int id = notifier->id(keys[i]);
         allocator.construct(&(values[id]), Value());
       }
     }
                 
-    /// Erase a key from the map. It called by the map registry.
-     
+    /// \brief Erase a key from the map.
+    ///
+    /// Erase a key from the map. It called by the observer notifier
+    /// and it overrides the erase() member function of the observer base.     
     virtual void erase(const Key& key) {
-      int id = graph->id(key);
+      int id = Parent::getNotifier()->id(key);
       allocator.destroy(&(values[id]));
     }
 
+    /// \brief Erase more keys from the map.
+    ///
+    /// Erase more keys from the map. It called by the observer notifier
+    /// and it overrides the erase() member function of the observer base.     
     virtual void erase(const std::vector<Key>& keys) {
       for (int i = 0; i < (int)keys.size(); ++i) {
-        int id = graph->id(keys[i]);
+        int id = Parent::getNotifier()->id(keys[i]);
         allocator.destroy(&(values[id]));
       }
     }
 
+    /// \brief Buildes the map.
+    /// 
+    /// It buildes the map. It called by the observer notifier
+    /// and it overrides the build() member function of the observer base. 
     virtual void build() {
+      Notifier* notifier = Parent::getNotifier();
       allocate_memory();
       Item it;
-      for (graph->first(it); it != INVALID; graph->next(it)) {
-        int id = graph->id(it);;
+      for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        int id = notifier->id(it);;
         allocator.construct(&(values[id]), Value());
       }                                                         
     }
 
+    /// \brief Clear the map.
+    ///
+    /// It erase all items from the map. It called by the observer notifier
+    /// and it overrides the clear() member function of the observer base.     
     virtual void clear() {      
+      Notifier* notifier = Parent::getNotifier();
       if (capacity != 0) {
         Item it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          int id = graph->id(it);
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+          int id = notifier->id(it);
           allocator.destroy(&(values[id]));
         }                                                               
@@ -283 +296 @@
       
     void allocate_memory() {
-      int max_id = graph->maxId(_Item());
+      int max_id = Parent::getNotifier()->maxId();
       if (max_id == -1) {
         capacity = 0;
@@ -296 +309 @@
     }      
 
-    const Graph* graph;
     int capacity;
     Value* values;