Changeset 1414:01d9d6bc1284 in lemon-0.x for src/lemon/bits/array_map.h

Timestamp:

05/14/05 19:20:40 (19 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Handling simultan edge adding.
Fixed bug: directed edge maps for undir graphs

File:

• src/lemon/bits/array_map.h (modified) (12 diffs)

src/lemon/bits/array_map.h

@@ -1 +1 @@
 /* -*- C++ -*-
- * src/lemon/array_map.h - Part of LEMON, a generic C++ optimization library
+ * src/lemon/bits/array_map.h - Part of LEMON, a generic C++ optimization library
  *
  * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
@@ -32 +32 @@
   /// @{
         
-  /** The ArrayMap template class is graph map structure what
-   *  automatically updates the map when a key is added to or erased from
-   *  the map. This map factory uses the allocators to implement 
-   *  the container functionality.
-   *
-   *  The template parameter is the AlterationNotifier that the maps
-   *  will belong to and the Value.
-   */
+  /// The ArrayMap template class is graph map structure what
+  /// automatically updates the map when a key is added to or erased from
+  /// the map. This map factory 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, 
@@ -69 +69 @@
   public:
 
-    /** Graph and Registry initialized map constructor.
-     */
+    /// Graph and Registry initialized map constructor.
+     
     ArrayMap(const Graph& _g) : graph(&_g) {
       Item it;
@@ -95 +95 @@
     }
 
-    /** Constructor to copy a map of the same map type.
-     */
+    /// Constructor to copy a map of the same map type.
+     
     ArrayMap(const ArrayMap& copy) : Parent() {
       if (copy.attached()) {
@@ -115 +115 @@
     using Parent::attached;
 
-    /** Assign operator to copy a map of the same map type.
-     */
+    /// Assign operator to copy a map of the same map type.
+     
     ArrayMap& operator=(const ArrayMap& copy) {
       if (&copy == this) return *this;
@@ -142 +142 @@
     }
 
-    /** The destructor of the map.
-     */
+    /// The destructor of the map.
+     
     virtual ~ArrayMap() {      
       if (attached()) {
@@ -152 +152 @@
         
         
-    /**
-     * The subscript operator. The map can be subscripted by the
-     * actual keys of the graph. 
-     */
+    ///The subscript operator. The map can be subscripted by the
+    ///actual keys of the graph. 
+     
     Value& operator[](const Key& key) {
       int id = graph->id(key);
@@ -161 +160 @@
     } 
                 
-    /**
-     * The const subscript operator. The map can be subscripted by the
-     * actual keys of the graph. 
-     */
+
+    ///The const subscript operator. The map can be subscripted by the
+    ///actual keys of the graph. 
+     
     const Value& operator[](const Key& key) const {
       int id = graph->id(key);
@@ -170 +169 @@
     }
         
-    /** Setter function of the map. Equivalent with map[key] = val.
-     *  This is a compatibility feature with the not dereferable maps.
-     */
+    /// Setter function of the map. Equivalent with map[key] = val.
+    /// This is a compatibility feature with the not dereferable maps.
+     
     void set(const Key& key, const Value& val) {
       (*this)[key] = val;
     }
                 
-    /** Add a new key to the map. It called by the map registry.
-     */
+    /// Add a new key to the map. It called by the map registry.
+     
     void add(const Key& key) {
       int id = graph->id(key);
@@ -201 +200 @@
       allocator.construct(&(values[id]), Value());
     }
-                
-    /** Erase a key from the map. It called by the map registry.
-     */
+
+    void add(const std::vector<Key>& keys) {
+      int max_id = -1;
+      for (int i = 0; i < (int)keys.size(); ++i) {
+        int id = graph->id(keys[i]);
+        if (id > max_id) {
+          max_id = id;
+        }
+      }
+      if (max_id >= capacity) {
+        int new_capacity = (capacity == 0 ? 1 : capacity);
+        while (new_capacity <= max_id) {
+          new_capacity <<= 1;
+        }
+        Value* new_values = allocator.allocate(new_capacity);
+        Item it;
+        for (graph->first(it); it != INVALID; graph->next(it)) {
+          int id = graph->id(it);
+          bool found = false;
+          for (int i = 0; i < (int)keys.size(); ++i) {
+            int jd = graph->id(keys[i]);
+            if (id == jd) {
+              found = true;
+              break;
+            }
+          }
+          if (found) continue;
+          allocator.construct(&(new_values[id]), values[id]);
+          allocator.destroy(&(values[id]));
+        }
+        if (capacity != 0) allocator.deallocate(values, capacity);
+        values = new_values;
+        capacity = new_capacity;
+      }
+      for (int i = 0; i < (int)keys.size(); ++i) {
+        int id = graph->id(keys[i]);
+        allocator.construct(&(values[id]), Value());
+      }
+    }
+                
+    /// Erase a key from the map. It called by the map registry.
+     
     void erase(const Key& key) {
       int id = graph->id(key);
       allocator.destroy(&(values[id]));
+    }
+
+    void erase(const std::vector<Key>& keys) {
+      for (int i = 0; i < (int)keys.size(); ++i) {
+        int id = graph->id(keys[i]);
+        allocator.destroy(&(values[id]));
+      }
     }
 
@@ -222 +267 @@
         Item it;
         for (graph->first(it); it != INVALID; graph->next(it)) {
-          int id = graph->id(it);;
+          int id = graph->id(it);
           allocator.destroy(&(values[id]));
         }                                                               
@@ -233 +278 @@
       return graph;
     }
-
-//     /// The stl compatible pair iterator of the map.
-//     typedef MapIterator<ArrayMap> Iterator;
-//     /// The stl compatible const pair iterator of the map.
-//     typedef MapConstIterator<ArrayMap> ConstIterator;
-
-//     /** Returns the begin iterator of the map.
-//      */
-//     Iterator begin() {
-//       return Iterator(*this, KeyIt(*MapBase::getGraph()));
-//     }
-
-//     /** Returns the end iterator of the map.
-//      */
-//     Iterator end() {
-//       return Iterator(*this, INVALID);
-//     }
-
-//     /** Returns the begin ConstIterator of the map.
-//      */
-//     ConstIterator begin() const {
-//       return ConstIterator(*this, KeyIt(*MapBase::getGraph()));
-//     }
-
-//     /** Returns the end const_iterator of the map.
-//      */
-//     ConstIterator end() const {
-//       return ConstIterator(*this, INVALID);
-//     }
-
-//     /// The KeySet of the Map.
-//     typedef MapConstKeySet<ArrayMap> ConstKeySet;
-
-//     /// KeySet getter function.
-//     ConstKeySet keySet() const {
-//       return ConstKeySet(*this); 
-//     }
-
-//     /// The ConstValueSet of the Map.
-//     typedef MapConstValueSet<ArrayMap> ConstValueSet;
-
-//     /// ConstValueSet getter function.
-//     ConstValueSet valueSet() const {
-//       return ConstValueSet(*this);
-//     }
-
-//     /// The ValueSet of the Map.
-//     typedef MapValueSet<ArrayMap> ValueSet;
-
-//     /// ValueSet getter function.
-//     ValueSet valueSet() {
-//       return ValueSet(*this);
-//     }
 
   private: