Changeset 1669:66ae78d29f1e in lemon-0.x for lemon/bits/array_map.h

Timestamp:

08/31/05 15:29:32 (19 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Template assign operator for graph maps.

Some naming and coding conventions.

File:

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

lemon/bits/array_map.h

@@ -20 +20 @@
 #include <memory>
 #include <lemon/bits/map_iterator.h>
-
-///\ingroup graphmapfactory
-///\file
-///\brief Graph maps that construates and destruates
-///their elements dynamically.
+#include <lemon/concept_check.h>
+#include <lemon/concept/maps.h>
+
+/// \ingroup graphmapfactory
+/// \file
+/// \brief Graph maps that construct and destruct
+/// their elements dynamically.
 
 namespace lemon {
 
-
-  /// \addtogroup graphmapfactory
-  /// @{
-        
+  /// \ingroup graphmapfactory
+  ///
+  /// \brief Graph map based on the array storage.
+  ///
   /// 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 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, 
@@ -70 +71 @@
 
     /// Graph and Registry initialized map constructor.
-     
     ArrayMap(const Graph& _g) : graph(&_g) {
       Item it;
@@ -111 +111 @@
     }
 
-    using Parent::attach;
-    using Parent::detach;
-    using Parent::attached;
-
-    /// Assign operator to copy a map of the same map type.
-     
-    ArrayMap& operator=(const ArrayMap& copy) {
-      if (&copy == this) return *this;
-      
-      if (graph != copy.graph) {
-        if (attached()) {
-          clear();
-          detach();
-        }
-        if (copy.attached()) {
-          attach(*copy.getRegistry());
-        }
-        capacity = copy.capacity;
-        if (capacity == 0) return *this;
-        values = allocator.allocate(capacity);      
-      }
-
-      Item it;
-      for (graph->first(it); it != INVALID; graph->next(it)) {
-        int id = graph->id(it);;
-        allocator.construct(&(values[id]), copy.values[id]);
-      }
-
-      return *this;
-    }
-
+    /// \brief The destructor of the map.
+    ///     
     /// The destructor of the map.
-     
     virtual ~ArrayMap() {      
       if (attached()) {
@@ -150 +120 @@
       }
     }
-        
-        
+                
+  private:
+
+    ArrayMap& operator=(const ArrayMap&);
+
+  protected:
+
+    using Parent::attach;
+    using Parent::detach;
+    using Parent::attached;
+
+    const Graph* getGraph() {
+      return graph;
+    }
+
+
+  public:
+
     ///The subscript operator. The map can be subscripted by the
     ///actual keys of the graph. 
@@ -175 +161 @@
       (*this)[key] = val;
     }
-                
+
+  protected:
+    
     /// Add a new key to the map. It called by the map registry.
      
@@ -275 +263 @@
     }
 
-    const Graph* getGraph() {
-      return graph;
-    }
-
   private:
       
@@ -302 +286 @@
   };            
 
-  template <typename _Base> 
-  class ArrayMappableGraphExtender : public _Base {
-  public:
-
-    typedef ArrayMappableGraphExtender<_Base> Graph;
-    typedef _Base Parent;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::NodeIt NodeIt;
-    typedef typename Parent::NodeNotifier NodeObserverRegistry;
-
-    typedef typename Parent::Edge Edge;
-    typedef typename Parent::EdgeIt EdgeIt;
-    typedef typename Parent::EdgeNotifier EdgeObserverRegistry;
-
-    
-
-    template <typename _Value>
-    class NodeMap 
-      : public IterableMapExtender<ArrayMap<Graph, Node, _Value> > {
-    public:
-      typedef ArrayMappableGraphExtender<_Base> Graph;
-
-      typedef typename Graph::Node Node;
-      typedef typename Graph::NodeIt NodeIt;
-
-      typedef IterableMapExtender<ArrayMap<Graph, Node, _Value> > Parent;
-
-      //typedef typename Parent::Graph Graph;
-      typedef typename Parent::Value Value;
-
-      NodeMap(const Graph& g) 
-        : Parent(g) {}
-      NodeMap(const Graph& g, const Value& v) 
-        : Parent(g, v) {}
-
-    };
-
-    template <typename _Value>
-    class EdgeMap 
-      : public IterableMapExtender<ArrayMap<Graph, Edge, _Value> > {
-    public:
-      typedef ArrayMappableGraphExtender<_Base> Graph;
-
-      typedef typename Graph::Edge Edge;
-      typedef typename Graph::EdgeIt EdgeIt;
-
-      typedef IterableMapExtender<ArrayMap<Graph, Edge, _Value> > Parent;
-
-      //typedef typename Parent::Graph Graph;
-      typedef typename Parent::Value Value;
-
-      EdgeMap(const Graph& g) 
-        : Parent(g) {}
-      EdgeMap(const Graph& g, const Value& v) 
-        : Parent(g, v) {}
-
-    };
-    
-  };
-
-/// @}
-
 }