Changeset 2031:080d51024ac5 in lemon-0.x for lemon/bits

Timestamp:

04/03/06 11:45:23 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Correcting the structure of the graph's and adaptor's map.
The template assign operators and map iterators can be used for adaptors also.

Some bugfix in the adaptors

New class SwapBpUGraphAdaptor which swaps the two nodeset of the graph.

Location:

lemon/bits

Files:

• array_map.h (modified) (3 diffs)
• base_extender.h (modified) (1 diff)
• default_map.h (modified) (1 diff)
• edge_set_extender.h (modified) (9 diffs)
• graph_adaptor_extender.h (modified) (23 diffs)
• graph_extender.h (modified) (18 diffs)
• map_extender.h (modified) (5 diffs)
• vector_map.h (modified) (2 diffs)

lemon/bits/array_map.h

@@ -24 +24 @@
 #include <lemon/bits/traits.h>
 #include <lemon/bits/alteration_notifier.h>
+#include <lemon/concept_check.h>
+#include <lemon/concept/maps.h>
 
 /// \ingroup graphbits
@@ -120 +122 @@
     }
 
+    /// \brief Assign operator.
+    ///
+    /// This operator assigns for each item in the map the
+    /// value mapped to the same item in the copied map.  
+    /// The parameter map should be indiced with the same
+    /// itemset because this assign operator does not change
+    /// the container of the map. 
+    ArrayMap& operator=(const ArrayMap& cmap) {
+      return operator=<ArrayMap>(cmap);
+    }
+
+
+    /// \brief Template assign operator.
+    ///
+    /// The given parameter should be conform to the ReadMap
+    /// concecpt and could be indiced by the current item set of
+    /// the NodeMap. In this case the value for each item
+    /// is assigned by the value of the given ReadMap. 
+    template <typename CMap>
+    ArrayMap& operator=(const CMap& cmap) {
+      checkConcept<concept::ReadMap<Key, _Value>, CMap>();
+      const typename Parent::Notifier* notifier = Parent::getNotifier();
+      Item it;
+      for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        set(it, cmap[it]);
+      }
+      return *this;
+    }
+
     /// \brief The destructor of the map.
     ///     
@@ -130 +161 @@
     }
                 
-  private:
-
-    ArrayMap& operator=(const ArrayMap&);
-
   protected:
 

lemon/bits/base_extender.h

@@ -467 +467 @@
       return Edge(edge, direction);
     }
+
+    int edgeNum() const {
+      return 2 * Parent::edgeNum();
+    }
+
+    int uEdgeNum() const {
+      return Parent::edgeNum();
+    }
+
   };
 

lemon/bits/default_map.h

@@ -164 +164 @@
       : Parent(graph, value) {}
 
+    DefaultMap& operator=(const DefaultMap& cmap) {
+      return operator=<DefaultMap>(cmap);
+    }
+
+    template <typename CMap>
+    DefaultMap& operator=(const CMap& cmap) {
+      Parent::operator=(cmap);
+      return *this;
+    }
+
   };
 

lemon/bits/edge_set_extender.h

@@ -102 +102 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
+        _graph.first(static_cast<Node&>(*this));
       }
 
@@ -125 +125 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
+        _graph.first(static_cast<Edge&>(*this));
       }
 
@@ -236 +236 @@
       template <typename CMap>
       EdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        Edge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
+
     };
 
@@ -365 +361 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
+        _graph.first(static_cast<Node&>(*this));
       }
 
@@ -388 +384 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
+        _graph.first(static_cast<Edge&>(*this));
       }
 
@@ -459 +455 @@
 
       explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<UEdge*>(this));
+        _graph.first(static_cast<UEdge&>(*this));
       }
 
@@ -557 +553 @@
       template <typename CMap>
       EdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        Edge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
+
     };
 
@@ -577 +569 @@
       UEdgeMap(const Graph& _g) 
         : Parent(_g) {}
+
       UEdgeMap(const Graph& _g, const _Value& _v) 
         : Parent(_g, _v) {}
@@ -586 +579 @@
       template <typename CMap>
       UEdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        UEdge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
+
     };
 

lemon/bits/graph_adaptor_extender.h

@@ -34 +34 @@
   ///
   /// \brief Extender for the GraphAdaptors
-  template <typename Base>
-  class GraphAdaptorExtender : public Base {
+  template <typename _Graph>
+  class GraphAdaptorExtender : public _Graph {
   public:
 
-    typedef Base Parent;
-    typedef GraphAdaptorExtender Graph;
+    typedef _Graph Parent;
+    typedef _Graph Graph;
+    typedef GraphAdaptorExtender Adaptor;
 
     // Base extensions
@@ -72 +73 @@
 
     class NodeIt : public Node { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -79 +80 @@
       NodeIt(Invalid i) : Node(i) { }
 
-      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node) 
+      explicit NodeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Adaptor& _graph, const Node& node) 
         : Node(node), graph(&_graph) {}
 
@@ -95 +96 @@
 
     class EdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -102 +103 @@
       EdgeIt(Invalid i) : Edge(i) { }
 
-      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) : 
+      explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Adaptor& _graph, const Edge& e) : 
         Edge(e), graph(&_graph) { }
 
@@ -118 +119 @@
 
     class OutEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -125 +126 @@
       OutEdgeIt(Invalid i) : Edge(i) { }
 
-      OutEdgeIt(const Graph& _graph, const Node& node) 
+      OutEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstOut(*this, node);
       }
 
-      OutEdgeIt(const Graph& _graph, const Edge& edge) 
+      OutEdgeIt(const Adaptor& _graph, const Edge& edge) 
         : Edge(edge), graph(&_graph) {}
 
@@ -142 +143 @@
 
     class InEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -149 +150 @@
       InEdgeIt(Invalid i) : Edge(i) { }
 
-      InEdgeIt(const Graph& _graph, const Node& node) 
+      InEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstIn(*this, node);
       }
 
-      InEdgeIt(const Graph& _graph, const Edge& edge) : 
+      InEdgeIt(const Adaptor& _graph, const Edge& edge) : 
         Edge(edge), graph(&_graph) {}
 
@@ -198 +199 @@
   ///
   /// \brief Extender for the UGraphAdaptors
-  template <typename Base> 
-  class UGraphAdaptorExtender : public Base {
+  template <typename _UGraph> 
+  class UGraphAdaptorExtender : public _UGraph {
   public:
     
-    typedef Base Parent;
-    typedef UGraphAdaptorExtender Graph;
+    typedef _UGraph Parent;
+    typedef _UGraph UGraph;
+    typedef UGraphAdaptorExtender Adaptor;
 
     typedef typename Parent::Node Node;
@@ -255 +257 @@
 
     class NodeIt : public Node { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -262 +264 @@
       NodeIt(Invalid i) : Node(i) { }
 
-      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node) 
+      explicit NodeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Adaptor& _graph, const Node& node) 
         : Node(node), graph(&_graph) {}
 
@@ -278 +280 @@
 
     class EdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -285 +287 @@
       EdgeIt(Invalid i) : Edge(i) { }
 
-      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) : 
+      explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Adaptor& _graph, const Edge& e) : 
         Edge(e), graph(&_graph) { }
 
@@ -301 +303 @@
 
     class OutEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -308 +310 @@
       OutEdgeIt(Invalid i) : Edge(i) { }
 
-      OutEdgeIt(const Graph& _graph, const Node& node) 
+      OutEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstOut(*this, node);
       }
 
-      OutEdgeIt(const Graph& _graph, const Edge& edge) 
+      OutEdgeIt(const Adaptor& _graph, const Edge& edge) 
         : Edge(edge), graph(&_graph) {}
 
@@ -325 +327 @@
 
     class InEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -332 +334 @@
       InEdgeIt(Invalid i) : Edge(i) { }
 
-      InEdgeIt(const Graph& _graph, const Node& node) 
+      InEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstIn(*this, node);
       }
 
-      InEdgeIt(const Graph& _graph, const Edge& edge) : 
+      InEdgeIt(const Adaptor& _graph, const Edge& edge) : 
         Edge(edge), graph(&_graph) {}
 
@@ -348 +350 @@
 
     class UEdgeIt : public Parent::UEdge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -355 +357 @@
       UEdgeIt(Invalid i) : UEdge(i) { }
 
-      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<UEdge*>(this));
-      }
-
-      UEdgeIt(const Graph& _graph, const UEdge& e) : 
+      explicit UEdgeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<UEdge&>(*this));
+      }
+
+      UEdgeIt(const Adaptor& _graph, const UEdge& e) : 
         UEdge(e), graph(&_graph) { }
 
@@ -371 +373 @@
     class IncEdgeIt : public Parent::UEdge { 
       friend class UGraphAdaptorExtender;
-      const Graph* graph;
+      const Adaptor* graph;
       bool direction;
     public:
@@ -379 +381 @@
       IncEdgeIt(Invalid i) : UEdge(i), direction(false) { }
 
-      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
+      IncEdgeIt(const Adaptor& _graph, const Node &n) : graph(&_graph) {
         _graph.firstInc(static_cast<UEdge&>(*this), direction, n);
       }
 
-      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+      IncEdgeIt(const Adaptor& _graph, const UEdge &ue, const Node &n)
         : graph(&_graph), UEdge(ue) {
         direction = (_graph.source(ue) == n);
@@ -437 +439 @@
   };
 
+  /// \ingroup graphbits
+  ///
+  /// \brief Extender for the BpUGraphAdaptors
+  template <typename Base>
+  class BpUGraphAdaptorExtender : public Base {
+  public:
+    typedef Base Parent;
+    typedef BpUGraphAdaptorExtender Graph;
+
+    typedef typename Parent::Node Node;
+    typedef typename Parent::BNode BNode;
+    typedef typename Parent::ANode ANode;
+    typedef typename Parent::Edge Edge;
+    typedef typename Parent::UEdge UEdge;
+
+    Node oppositeNode(const UEdge& edge, const Node& node) const {
+      return source(edge) == node ? 
+        target(edge) : source(edge);
+    }
+
+
+    int maxId(Node) const {
+      return Parent::maxNodeId();
+    }
+    int maxId(BNode) const {
+      return Parent::maxBNodeId();
+    }
+    int maxId(ANode) const {
+      return Parent::maxANodeId();
+    }
+    int maxId(Edge) const {
+      return Parent::maxEdgeId();
+    }
+    int maxId(UEdge) const {
+      return Parent::maxUEdgeId();
+    }
+
+
+    Node fromId(int id, Node) const {
+      return Parent::nodeFromId(id);
+    }
+    ANode fromId(int id, ANode) const {
+      return Parent::fromANodeId(id);
+    }
+    BNode fromId(int id, BNode) const {
+      return Parent::fromBNodeId(id);
+    }
+    Edge fromId(int id, Edge) const {
+      return Parent::edgeFromId(id);
+    }
+    UEdge fromId(int id, UEdge) const {
+      return Parent::uEdgeFromId(id);
+    }  
+  
+    class NodeIt : public Node { 
+      const Graph* graph;
+    public:
+    
+      NodeIt() { }
+    
+      NodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
+        graph->first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Graph& _graph, const Node& node) 
+        : Node(node), graph(&_graph) { }
+    
+      NodeIt& operator++() { 
+        graph->next(*this);
+        return *this; 
+      }
+
+    };
+
+    class ANodeIt : public Node { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      ANodeIt() { }
+    
+      ANodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit ANodeIt(const Graph& _graph) : graph(&_graph) {
+        graph->firstANode(static_cast<Node&>(*this));
+      }
+
+      ANodeIt(const Graph& _graph, const Node& node) 
+        : Node(node), graph(&_graph) {}
+    
+      ANodeIt& operator++() { 
+        graph->nextANode(*this);
+        return *this; 
+      }
+    };
+
+    class BNodeIt : public Node { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      BNodeIt() { }
+    
+      BNodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit BNodeIt(const Graph& _graph) : graph(&_graph) {
+        graph->firstBNode(static_cast<Node&>(*this));
+      }
+
+      BNodeIt(const Graph& _graph, const Node& node) 
+        : Node(node), graph(&_graph) {}
+    
+      BNodeIt& operator++() { 
+        graph->nextBNode(*this);
+        return *this; 
+      }
+    };
+
+    class EdgeIt : public Edge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      EdgeIt() { }
+    
+      EdgeIt(Invalid i) : Edge(INVALID) { }
+    
+      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
+        graph->first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Graph& _graph, const Edge& edge) 
+        : Edge(edge), graph(&_graph) { }
+    
+      EdgeIt& operator++() { 
+        graph->next(*this);
+        return *this; 
+      }
+
+    };
+
+    class UEdgeIt : public UEdge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      UEdgeIt() { }
+    
+      UEdgeIt(Invalid i) : UEdge(INVALID) { }
+    
+      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
+        graph->first(static_cast<UEdge&>(*this));
+      }
+
+      UEdgeIt(const Graph& _graph, const UEdge& edge) 
+        : UEdge(edge), graph(&_graph) { }
+    
+      UEdgeIt& operator++() { 
+        graph->next(*this);
+        return *this; 
+      }
+    };
+
+    class OutEdgeIt : public Edge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      OutEdgeIt() { }
+    
+      OutEdgeIt(Invalid i) : Edge(i) { }
+    
+      OutEdgeIt(const Graph& _graph, const Node& node) 
+        : graph(&_graph) {
+        graph->firstOut(*this, node);
+      }
+    
+      OutEdgeIt(const Graph& _graph, const Edge& edge) 
+        : Edge(edge), graph(&_graph) {}
+    
+      OutEdgeIt& operator++() { 
+        graph->nextOut(*this);
+        return *this; 
+      }
+
+    };
+
+
+    class InEdgeIt : public Edge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      InEdgeIt() { }
+    
+      InEdgeIt(Invalid i) : Edge(i) { }
+    
+      InEdgeIt(const Graph& _graph, const Node& node) 
+        : graph(&_graph) {
+        graph->firstIn(*this, node);
+      }
+    
+      InEdgeIt(const Graph& _graph, const Edge& edge) : 
+        Edge(edge), graph(&_graph) {}
+    
+      InEdgeIt& operator++() { 
+        graph->nextIn(*this);
+        return *this; 
+      }
+
+    };
+  
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the source in this case) of the iterator
+    Node baseNode(const OutEdgeIt &e) const {
+      return Parent::source((Edge&)e);
+    }
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the target in this case) of the
+    /// iterator
+    Node runningNode(const OutEdgeIt &e) const {
+      return Parent::target((Edge&)e);
+    }
+  
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the target in this case) of the iterator
+    Node baseNode(const InEdgeIt &e) const {
+      return Parent::target((Edge&)e);
+    }
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the source in this case) of the
+    /// iterator
+    Node runningNode(const InEdgeIt &e) const {
+      return Parent::source((Edge&)e);
+    }
+  
+    class IncEdgeIt : public Parent::UEdge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+      bool direction;
+    public:
+    
+      IncEdgeIt() { }
+    
+      IncEdgeIt(Invalid i) : UEdge(i), direction(true) { }
+    
+      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
+        graph->firstInc(*this, direction, n);
+      }
+
+      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+        : graph(&_graph), UEdge(ue) {
+        direction = (graph->source(ue) == n);
+      }
+
+      IncEdgeIt& operator++() {
+        graph->nextInc(*this, direction);
+        return *this; 
+      }
+    };
+  
+
+    /// Base node of the iterator
+    ///
+    /// Returns the base node of the iterator
+    Node baseNode(const IncEdgeIt &e) const {
+      return e.direction ? source(e) : target(e);
+    }
+
+    /// Running node of the iterator
+    ///
+    /// Returns the running node of the iterator
+    Node runningNode(const IncEdgeIt &e) const {
+      return e.direction ? target(e) : source(e);
+    }
+
+  };
+
 
 }

lemon/bits/graph_extender.h

@@ -104 +104 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
+        _graph.first(static_cast<Node&>(*this));
       }
 
@@ -127 +127 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
+        _graph.first(static_cast<Edge&>(*this));
       }
 
@@ -233 +233 @@
       }
 
-
-      /// \brief Template assign operator.
-      ///
-      /// The given parameter should be conform to the ReadMap
-      /// concecpt and could be indiced by the current item set of
-      /// the NodeMap. In this case the value for each item
-      /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
       NodeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Node it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -271 +259 @@
       template <typename CMap>
       EdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Edge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -432 +415 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
+        _graph.first(static_cast<Node&>(*this));
       }
 
@@ -455 +438 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
+        _graph.first(static_cast<Edge&>(*this));
       }
 
@@ -526 +509 @@
 
       explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<UEdge*>(this));
+        _graph.first(static_cast<UEdge&>(*this));
       }
 
@@ -623 +606 @@
       }
 
-
-      /// \brief Template assign operator.
-      ///
-      /// The given parameter should be conform to the ReadMap
-      /// concecpt and could be indiced by the current item set of
-      /// the NodeMap. In this case the value for each item
-      /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
       NodeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Node it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -661 +632 @@
       template <typename CMap>
       EdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Edge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -681 +647 @@
       UEdgeMap(const Graph& graph) 
         : Parent(graph) {}
+
       UEdgeMap(const Graph& graph, const _Value& value) 
         : Parent(graph, value) {}
@@ -690 +657 @@
       template <typename CMap>
       UEdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Edge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
+
     };
 
@@ -1105 +1068 @@
       }
     
-
-      /// \brief Template assign operator.
-      ///
-      /// The given parameter should be conform to the ReadMap
-      /// concept and could be indiced by the current item set of
-      /// the ANodeMap. In this case the value for each item
-      /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
       ANodeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<ANode, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        ANode it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -1141 +1092 @@
       }
     
-
-      /// \brief Template assign operator.
-      ///
-      /// The given parameter should be conform to the ReadMap
-      /// concept and could be indiced by the current item set of
-      /// the BNodeMap. In this case the value for each item
-      /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
       BNodeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<BNode, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        BNode it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -1161 +1100 @@
     };
 
-  protected:
+  public:
 
     template <typename _Value>
-    class NodeMapBase {
+    class NodeMap {
     public:
       typedef BpUGraphExtender Graph;
@@ -1178 +1117 @@
       typedef True ReferenceMapTag;
 
-      NodeMapBase(const Graph& graph) 
-        : aNodeMap(graph), bNodeMap(graph) {}
-      NodeMapBase(const Graph& graph, const _Value& value) 
-        : aNodeMap(graph, value), bNodeMap(graph, value) {}
+      NodeMap(const Graph& _graph) 
+        : graph(_graph), aNodeMap(_graph), bNodeMap(_graph) {}
+      NodeMap(const Graph& _graph, const _Value& _value) 
+        : graph(_graph), aNodeMap(_graph, _value), bNodeMap(_graph, _value) {}
+
+      NodeMap& operator=(const NodeMap& cmap) {
+        return operator=<NodeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      NodeMap& operator=(const CMap& cmap) {
+        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
+        Edge it;
+        for (graph.first(it); it != INVALID; graph.next(it)) {
+          Parent::set(it, cmap[it]);
+        }
+        return *this;
+      }
 
       ConstReference operator[](const Key& node) const {
@@ -1207 +1161 @@
       }
 
-      const Graph* getGraph() const {
-        return aNodeMap.getGraph();
-      }
-
+      class MapIt : public NodeIt {
+      public:
+
+        typedef NodeIt Parent;
+        
+        explicit MapIt(NodeMap& _map) 
+          : Parent(_map.graph), map(_map) {}
+        
+        typename MapTraits<NodeMap>::ConstReturnValue operator*() const {
+          return map[*this];
+        }
+        
+        typename MapTraits<NodeMap>::ReturnValue operator*() {
+          return map[*this];
+        }
+        
+        void set(const Value& value) {
+          map.set(*this, value);
+        }
+
+      private:
+        NodeMap& map;
+      };
+
+      class ConstMapIt : public NodeIt {
+      public:
+
+        typedef NodeIt Parent;
+        
+        explicit ConstMapIt(const NodeMap& _map) 
+          : Parent(_map.graph), map(_map) {}
+        
+        typename MapTraits<NodeMap>::ConstReturnValue operator*() const {
+          return map[*this];
+        }
+        
+      private:
+        const NodeMap& map;
+      };
+
+      class ItemIt : public NodeIt {
+      public:
+
+        typedef NodeIt Parent;
+
+        explicit ItemIt(const NodeMap& _map)
+          : Parent(_map.graph) {}
+        
+      };
+      
     private:
+      const Graph& graph;
       ANodeMap<_Value> aNodeMap;
       BNodeMap<_Value> bNodeMap;
     };
     
-  public:
-
-    template <typename _Value>
-    class NodeMap 
-      : public MapExtender<NodeMapBase<_Value> > {
-    public:
-      typedef BpUGraphExtender Graph;
-      typedef MapExtender< NodeMapBase<_Value> > Parent;
-    
-      NodeMap(const Graph& graph) 
-        : Parent(graph) {}
-      NodeMap(const Graph& graph, const _Value& value) 
-        : Parent(graph, value) {}
-    
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-    
-
-      /// \brief Template assign operator.
-      ///
-      /// The given parameter should be conform to the ReadMap
-      /// concept and could be indiced by the current item set of
-      /// the NodeMap. In this case the value for each item
-      /// is assigned by the value of the given ReadMap. 
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Edge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
-        return *this;
-      }
-    
-    };
-
-
 
     template <typename _Value>
@@ -1274 +1236 @@
       template <typename CMap>
       EdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Edge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -1302 +1259 @@
       template <typename CMap>
       UEdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Edge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }

lemon/bits/map_extender.h

@@ -23 +23 @@
 
 #include <lemon/bits/traits.h>
+
+#include <lemon/concept_check.h>
+#include <lemon/concept/maps.h>
 
 ///\file
@@ -60 +63 @@
       : Parent(graph, value) {}
 
+    MapExtender& operator=(const MapExtender& cmap) {
+      return operator=<MapExtender>(cmap);
+    }
+
+    template <typename CMap>
+    MapExtender& operator=(const CMap& cmap) {
+      Parent::operator=(cmap);
+      return *this;
+    } 
 
     class MapIt : public Item {
@@ -131 +143 @@
     };
 
-    class ItemIt : Item {
+    class ItemIt : public Item {
     public:
       
@@ -141 +153 @@
 
       explicit ItemIt(Map& _map) : map(_map) {
-        map->getNotifier()->first(*this);
+        map.getNotifier()->first(*this);
       }
 
@@ -158 +170 @@
   };
 
+  /// \ingroup graphbits
+  /// 
+  /// \brief Extender for maps which use a subset of the items.
+  template <typename _Graph, typename _Map>
+  class SubMapExtender : public _Map {
+  public:
+
+    typedef _Map Parent;
+    typedef SubMapExtender Map;
+
+    typedef _Graph Graph;
+
+    typedef typename Parent::Key Item;
+
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    class MapIt;
+    class ConstMapIt;
+
+    friend class MapIt;
+    friend class ConstMapIt;
+
+  public:
+
+    SubMapExtender(const Graph& _graph) 
+      : Parent(_graph), graph(_graph) {}
+
+    SubMapExtender(const Graph& _graph, const Value& _value) 
+      : Parent(_graph, _value), graph(_graph) {}
+
+    SubMapExtender& operator=(const SubMapExtender& cmap) {
+      return operator=<MapExtender>(cmap);
+    }
+
+    template <typename CMap>
+    SubMapExtender& operator=(const CMap& cmap) {
+      checkConcept<concept::ReadMap<Key, Value>, CMap>();
+      Item it;
+      for (graph.first(it); it != INVALID; graph.next(it)) {
+        Parent::set(it, cmap[it]);
+      }
+      return *this;
+    } 
+
+    class MapIt : public Item {
+    public:
+      
+      typedef Item Parent;
+      typedef typename Map::Value Value;
+      
+      MapIt() {}
+
+      MapIt(Invalid i) : Parent(i) { }
+
+      explicit MapIt(Map& _map) : map(_map) {
+        map.graph.first(*this);
+      }
+
+      MapIt(const Map& _map, const Item& item) 
+        : Parent(item), map(_map) {}
+
+      MapIt& operator++() { 
+        map.graph.next(*this);
+        return *this; 
+      }
+      
+      typename MapTraits<Map>::ConstReturnValue operator*() const {
+        return map[*this];
+      }
+
+      typename MapTraits<Map>::ReturnValue operator*() {
+        return map[*this];
+      }
+      
+      void set(const Value& value) {
+        map.set(*this, value);
+      }
+      
+    protected:
+      Map& map;
+      
+    };
+
+    class ConstMapIt : public Item {
+    public:
+
+      typedef Item Parent;
+
+      typedef typename Map::Value Value;
+      
+      ConstMapIt() {}
+
+      ConstMapIt(Invalid i) : Parent(i) { }
+
+      explicit ConstMapIt(Map& _map) : map(_map) {
+        map.graph.first(*this);
+      }
+
+      ConstMapIt(const Map& _map, const Item& item) 
+        : Parent(item), map(_map) {}
+
+      ConstMapIt& operator++() { 
+        map.graph.next(*this);
+        return *this; 
+      }
+
+      typename MapTraits<Map>::ConstReturnValue operator*() const {
+        return map[*this];
+      }
+
+    protected:
+      const Map& map;
+    };
+
+    class ItemIt : public Item {
+    public:
+      
+      typedef Item Parent;
+      
+      ItemIt() {}
+
+      ItemIt(Invalid i) : Parent(i) { }
+
+      explicit ItemIt(Map& _map) : map(_map) {
+        map.graph.first(*this);
+      }
+
+      ItemIt(const Map& _map, const Item& item) 
+        : Parent(item), map(_map) {}
+
+      ItemIt& operator++() { 
+        map.graph.next(*this);
+        return *this; 
+      }
+
+    protected:
+      const Map& map;
+      
+    };
+    
+  private:
+
+    const Graph& graph;
+    
+  };
+
 }
 

lemon/bits/vector_map.h

@@ -27 +27 @@
 
 #include <lemon/bits/alteration_notifier.h>
+
+#include <lemon/concept_check.h>
+#include <lemon/concept/maps.h>
 
 ///\ingroup graphbits
@@ -113 +116 @@
     }
 
-  private:
-
-    VectorMap& operator=(const VectorMap&);
-
+    /// \brief Assign operator.
+    ///
+    /// This operator assigns for each item in the map the
+    /// value mapped to the same item in the copied map.  
+    /// The parameter map should be indiced with the same
+    /// itemset because this assign operator does not change
+    /// the container of the map. 
+    VectorMap& operator=(const VectorMap& cmap) {
+      return operator=<VectorMap>(cmap);
+    }
+
+
+    /// \brief Template assign operator.
+    ///
+    /// The given parameter should be conform to the ReadMap
+    /// concecpt and could be indiced by the current item set of
+    /// the NodeMap. In this case the value for each item
+    /// is assigned by the value of the given ReadMap. 
+    template <typename CMap>
+    VectorMap& operator=(const CMap& cmap) {
+      checkConcept<concept::ReadMap<Key, _Value>, CMap>();
+      const typename Parent::Notifier* notifier = Parent::getNotifier();
+      Item it;
+      for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        set(it, cmap[it]);
+      }
+      return *this;
+    }
+    
   public: