Changeset 1999:2ff283124dfc in lemon-0.x for lemon/bits/graph_extender.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/graph_extender.h (modified) (26 diffs)

lemon/bits/graph_extender.h

@@ -23 +23 @@
 #include <lemon/error.h>
 
+#include <lemon/bits/map_extender.h>
 #include <lemon/bits/default_map.h>
+
+#include <lemon/concept_check.h>
+#include <lemon/concept/maps.h>
 
 ///\ingroup graphbits
@@ -72 +76 @@
     // Alterable extension
 
-    typedef AlterationNotifier<Node> NodeNotifier;
-    typedef AlterationNotifier<Edge> EdgeNotifier;
+    typedef AlterationNotifier<GraphExtender, Node> NodeNotifier;
+    typedef AlterationNotifier<GraphExtender, Edge> EdgeNotifier;
 
 
@@ -215 +219 @@
     template <typename _Value>
     class NodeMap 
-      : public IterableMapExtender<DefaultMap<Graph, Node, _Value> > {
+      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
     public:
       typedef GraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, Node, _Value> > Parent;
-
-      NodeMap(const Graph& _g) 
-        : Parent(_g) {}
-      NodeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
+
+      NodeMap(const Graph& graph) 
+        : Parent(graph) {}
+      NodeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
 
       NodeMap& operator=(const NodeMap& cmap) {
@@ -239 +243 @@
       NodeMap& operator=(const CMap& cmap) {
         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
         Node it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -251 +255 @@
     template <typename _Value>
     class EdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
+      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
     public:
       typedef GraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
-
-      EdgeMap(const Graph& _g) 
-        : Parent(_g) {}
-      EdgeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
+
+      EdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      EdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
 
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -268 +272 @@
       EdgeMap& operator=(const CMap& cmap) {
         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
         Edge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -320 +324 @@
     }
 
+    GraphExtender() {
+      node_notifier.setContainer(*this);
+      edge_notifier.setContainer(*this);
+    } 
+    
 
     ~GraphExtender() {
-      getNotifier(Edge()).clear();
-      getNotifier(Node()).clear();
+      edge_notifier.clear();
+      node_notifier.clear();
     }
   };
-
-  /// \ingroup graphbits
-  ///
-  /// \brief BaseExtender for the UGraphs
-  template <typename Base>
-  class UGraphBaseExtender : public Base {
-
-  public:
-
-    typedef Base Parent;
-    typedef typename Parent::Edge UEdge;
-    typedef typename Parent::Node Node;
-
-    typedef True UndirectedTag;
-
-    class Edge : public UEdge {
-      friend class UGraphBaseExtender;
-
-    protected:
-      bool forward;
-
-      Edge(const UEdge &ue, bool _forward) :
-        UEdge(ue), forward(_forward) {}
-
-    public:
-      Edge() {}
-
-      /// Invalid edge constructor
-      Edge(Invalid i) : UEdge(i), forward(true) {}
-
-      bool operator==(const Edge &that) const {
-        return forward==that.forward && UEdge(*this)==UEdge(that);
-      }
-      bool operator!=(const Edge &that) const {
-        return forward!=that.forward || UEdge(*this)!=UEdge(that);
-      }
-      bool operator<(const Edge &that) const {
-        return forward<that.forward ||
-          (!(that.forward<forward) && UEdge(*this)<UEdge(that));
-      }
-    };
-
-
-
-    using Parent::source;
-
-    /// Source of the given Edge.
-    Node source(const Edge &e) const {
-      return e.forward ? Parent::source(e) : Parent::target(e);
-    }
-
-    using Parent::target;
-
-    /// Target of the given Edge.
-    Node target(const Edge &e) const {
-      return e.forward ? Parent::target(e) : Parent::source(e);
-    }
-
-    /// \brief Directed edge from an undirected edge.
-    ///
-    /// Returns a directed edge corresponding to the specified UEdge.
-    /// If the given bool is true the given undirected edge and the
-    /// returned edge have the same source node.
-    static Edge direct(const UEdge &ue, bool d) {
-      return Edge(ue, d);
-    }
-
-    /// Returns whether the given directed edge is same orientation as the
-    /// corresponding undirected edge.
-    ///
-    /// \todo reference to the corresponding point of the undirected graph
-    /// concept. "What does the direction of an undirected edge mean?"
-    static bool direction(const Edge &e) { return e.forward; }
-
-
-    using Parent::first;
-    using Parent::next;
-
-    void first(Edge &e) const {
-      Parent::first(e);
-      e.forward=true;
-    }
-
-    void next(Edge &e) const {
-      if( e.forward ) {
-        e.forward = false;
-      }
-      else {
-        Parent::next(e);
-        e.forward = true;
-      }
-    }
-
-    void firstOut(Edge &e, const Node &n) const {
-      Parent::firstIn(e,n);
-      if( UEdge(e) != INVALID ) {
-        e.forward = false;
-      }
-      else {
-        Parent::firstOut(e,n);
-        e.forward = true;
-      }
-    }
-    void nextOut(Edge &e) const {
-      if( ! e.forward ) {
-        Node n = Parent::target(e);
-        Parent::nextIn(e);
-        if( UEdge(e) == INVALID ) {
-          Parent::firstOut(e, n);
-          e.forward = true;
-        }
-      }
-      else {
-        Parent::nextOut(e);
-      }
-    }
-
-    void firstIn(Edge &e, const Node &n) const {
-      Parent::firstOut(e,n);
-      if( UEdge(e) != INVALID ) {
-        e.forward = false;
-      }
-      else {
-        Parent::firstIn(e,n);
-        e.forward = true;
-      }
-    }
-    void nextIn(Edge &e) const {
-      if( ! e.forward ) {
-        Node n = Parent::source(e);
-        Parent::nextOut(e);
-        if( UEdge(e) == INVALID ) {
-          Parent::firstIn(e, n);
-          e.forward = true;
-        }
-      }
-      else {
-        Parent::nextIn(e);
-      }
-    }
-
-    void firstInc(UEdge &e, bool &d, const Node &n) const {
-      d = true;
-      Parent::firstOut(e, n);
-      if (e != INVALID) return;
-      d = false;
-      Parent::firstIn(e, n);
-    }
-
-    void nextInc(UEdge &e, bool &d) const {
-      if (d) {
-        Node s = Parent::source(e);
-        Parent::nextOut(e);
-        if (e != INVALID) return;
-        d = false;
-        Parent::firstIn(e, s);
-      } else {
-        Parent::nextIn(e);
-      }
-    }
-
-    Node nodeFromId(int id) const {
-      return Parent::nodeFromId(id);
-    }
-
-    Edge edgeFromId(int id) const {
-      return direct(Parent::edgeFromId(id >> 1), bool(id & 1));
-    }
-
-    UEdge uEdgeFromId(int id) const {
-      return Parent::edgeFromId(id >> 1);
-    }
-
-    int id(const Node &n) const {
-      return Parent::id(n);
-    }
-
-    int id(const UEdge &e) const {
-      return Parent::id(e);
-    }
-
-    int id(const Edge &e) const {
-      return 2 * Parent::id(e) + int(e.forward);
-    }
-
-    int maxNodeId() const {
-      return Parent::maxNodeId();
-    }
-
-    int maxEdgeId() const {
-      return 2 * Parent::maxEdgeId() + 1;
-    }
-
-    int maxUEdgeId() const {
-      return Parent::maxEdgeId();
-    }
-
-
-    int edgeNum() const {
-      return 2 * Parent::edgeNum();
-    }
-
-    int uEdgeNum() const {
-      return Parent::edgeNum();
-    }
-
-    Edge findEdge(Node source, Node target, Edge prev) const {
-      if (prev == INVALID) {
-        UEdge edge = Parent::findEdge(source, target);
-        if (edge != INVALID) return direct(edge, true);
-        edge = Parent::findEdge(target, source);
-        if (edge != INVALID) return direct(edge, false);
-      } else if (direction(prev)) {
-        UEdge edge = Parent::findEdge(source, target, prev);
-        if (edge != INVALID) return direct(edge, true);
-        edge = Parent::findEdge(target, source);
-        if (edge != INVALID) return direct(edge, false);        
-      } else {
-        UEdge edge = Parent::findEdge(target, source, prev);
-        if (edge != INVALID) return direct(edge, false);              
-      }
-      return INVALID;
-    }
-
-    UEdge findUEdge(Node source, Node target, UEdge prev) const {
-      if (prev == INVALID) {
-        UEdge edge = Parent::findEdge(source, target);
-        if (edge != INVALID) return edge;
-        edge = Parent::findEdge(target, source);
-        if (edge != INVALID) return edge;
-      } else if (Parent::source(prev) == source) {
-        UEdge edge = Parent::findEdge(source, target, prev);
-        if (edge != INVALID) return edge;
-        edge = Parent::findEdge(target, source);
-        if (edge != INVALID) return edge;       
-      } else {
-        UEdge edge = Parent::findEdge(target, source, prev);
-        if (edge != INVALID) return edge;             
-      }
-      return INVALID;
-    }
-  };
-
 
   /// \ingroup graphbits
@@ -630 +396 @@
     // Alterable extension
 
-    typedef AlterationNotifier<Node> NodeNotifier;
-    typedef AlterationNotifier<Edge> EdgeNotifier;
-    typedef AlterationNotifier<UEdge> UEdgeNotifier;
+    typedef AlterationNotifier<UGraphExtender, Node> NodeNotifier;
+    typedef AlterationNotifier<UGraphExtender, Edge> EdgeNotifier;
+    typedef AlterationNotifier<UGraphExtender, UEdge> UEdgeNotifier;
 
 
@@ -843 +609 @@
     template <typename _Value>
     class NodeMap 
-      : public IterableMapExtender<DefaultMap<Graph, Node, _Value> > {
+      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
     public:
       typedef UGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, Node, _Value> > Parent;
-
-      NodeMap(const Graph& _g) 
-        : Parent(_g) {}
-      NodeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
+
+      NodeMap(const Graph& graph) 
+        : Parent(graph) {}
+      NodeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
 
       NodeMap& operator=(const NodeMap& cmap) {
@@ -867 +633 @@
       NodeMap& operator=(const CMap& cmap) {
         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
         Node it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -879 +645 @@
     template <typename _Value>
     class EdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
+      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
     public:
       typedef UGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
-
-      EdgeMap(const Graph& _g) 
-        : Parent(_g) {}
-      EdgeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
+
+      EdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      EdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
 
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -896 +662 @@
       EdgeMap& operator=(const CMap& cmap) {
         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
         Edge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -908 +674 @@
     template <typename _Value>
     class UEdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
+      : public MapExtender<DefaultMap<Graph, UEdge, _Value> > {
     public:
       typedef UGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > Parent;
-
-      UEdgeMap(const Graph& _g) 
-        : Parent(_g) {}
-      UEdgeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, UEdge, _Value> > Parent;
+
+      UEdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      UEdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
 
       UEdgeMap& operator=(const UEdgeMap& cmap) {
@@ -925 +691 @@
       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)) {
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
+        Edge it;
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -982 +748 @@
     }
 
+    UGraphExtender() {
+      node_notifier.setContainer(*this); 
+      edge_notifier.setContainer(*this);
+      uedge_notifier.setContainer(*this);
+    } 
+
     ~UGraphExtender() {
-      getNotifier(Edge()).clear();
-      getNotifier(UEdge()).clear();
-      getNotifier(Node()).clear();
-    }
-
-  };
-
-
-  /// \ingroup graphbits
-  ///
-  /// \brief BaseExtender for the BpUGraphs
-  template <typename Base>
-  class BpUGraphBaseExtender : public Base {
-  public:
-    typedef Base Parent;
-    typedef BpUGraphBaseExtender Graph;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::Edge UEdge;
-
-
-    using Parent::first;
-    using Parent::next;
-
-    using Parent::id;
-
-    class ANode : public Node {
-      friend class BpUGraphBaseExtender;
-    public:
-      ANode() {}
-      ANode(const Node& node) : Node(node) {
-        LEMON_ASSERT(Parent::aNode(node) || node == INVALID, 
-                     typename Parent::NodeSetError());
-      }
-      ANode(Invalid) : Node(INVALID) {}
-    };
-
-    void first(ANode& node) const {
-      Parent::firstANode(static_cast<Node&>(node));
-    }
-    void next(ANode& node) const {
-      Parent::nextANode(static_cast<Node&>(node));
-    }
-
-    int id(const ANode& node) const {
-      return Parent::aNodeId(node);
-    }
-
-    class BNode : public Node {
-      friend class BpUGraphBaseExtender;
-    public:
-      BNode() {}
-      BNode(const Node& node) : Node(node) {
-        LEMON_ASSERT(Parent::bNode(node) || node == INVALID,
-                     typename Parent::NodeSetError());
-      }
-      BNode(Invalid) : Node(INVALID) {}
-    };
-
-    void first(BNode& node) const {
-      Parent::firstBNode(static_cast<Node&>(node));
-    }
-    void next(BNode& node) const {
-      Parent::nextBNode(static_cast<Node&>(node));
-    }
-  
-    int id(const BNode& node) const {
-      return Parent::aNodeId(node);
-    }
-
-    Node source(const UEdge& edge) const {
-      return aNode(edge);
-    }
-    Node target(const UEdge& edge) const {
-      return bNode(edge);
-    }
-
-    void firstInc(UEdge& edge, bool& direction, const Node& node) const {
-      if (Parent::aNode(node)) {
-        Parent::firstOut(edge, node);
-        direction = true;
-      } else {
-        Parent::firstIn(edge, node);
-        direction = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-    void nextInc(UEdge& edge, bool& direction) const {
-      if (direction) {
-        Parent::nextOut(edge);
-      } else {
-        Parent::nextIn(edge);
-        if (edge == INVALID) direction = true;
-      }
-    }
-
-    int maxUEdgeId() const {
-      return Parent::maxEdgeId();
-    }
-
-    UEdge uEdgeFromId(int id) const {
-      return Parent::edgeFromId(id);
-    }
-
-    class Edge : public UEdge {
-      friend class BpUGraphBaseExtender;
-    protected:
-      bool forward;
-
-      Edge(const UEdge& edge, bool _forward)
-        : UEdge(edge), forward(_forward) {}
-
-    public:
-      Edge() {}
-      Edge (Invalid) : UEdge(INVALID), forward(true) {}
-      bool operator==(const Edge& i) const {
-        return UEdge::operator==(i) && forward == i.forward;
-      }
-      bool operator!=(const Edge& i) const {
-        return UEdge::operator!=(i) || forward != i.forward;
-      }
-      bool operator<(const Edge& i) const {
-        return UEdge::operator<(i) || 
-          (!(i.forward<forward) && UEdge(*this)<UEdge(i));
-      }
-    };
-
-    void first(Edge& edge) const {
-      Parent::first(static_cast<UEdge&>(edge));
-      edge.forward = true;
-    }
-
-    void next(Edge& edge) const {
-      if (!edge.forward) {
-        Parent::next(static_cast<UEdge&>(edge));
-      }
-      edge.forward = !edge.forward;
-    }
-
-    void firstOut(Edge& edge, const Node& node) const {
-      if (Parent::aNode(node)) {
-        Parent::firstOut(edge, node);
-        edge.forward = true;
-      } else {
-        Parent::firstIn(edge, node);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-    void nextOut(Edge& edge) const {
-      if (edge.forward) {
-        Parent::nextOut(edge);
-      } else {
-        Parent::nextIn(edge);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-
-    void firstIn(Edge& edge, const Node& node) const {
-      if (Parent::bNode(node)) {
-        Parent::firstIn(edge, node);
-        edge.forward = true;    
-      } else {
-        Parent::firstOut(edge, node);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-    void nextIn(Edge& edge) const {
-      if (edge.forward) {
-        Parent::nextIn(edge);
-      } else {
-        Parent::nextOut(edge);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-
-    Node source(const Edge& edge) const {
-      return edge.forward ? Parent::aNode(edge) : Parent::bNode(edge);
-    }
-    Node target(const Edge& edge) const {
-      return edge.forward ? Parent::bNode(edge) : Parent::aNode(edge);
-    }
-
-    int id(const Edge& edge) const {
-      return (Parent::id(edge) << 1) + (edge.forward ? 0 : 1);
-    }
-    Edge edgeFromId(int id) const {
-      return Edge(Parent::fromId(id >> 1, UEdge()), (id & 1) == 0);
-    }
-    int maxEdgeId() const {
-      return (Parent::maxId(UEdge()) << 1) + 1;
-    }
-
-    bool direction(const Edge& edge) const {
-      return edge.forward;
-    }
-
-    Edge direct(const UEdge& edge, bool direction) const {
-      return Edge(edge, direction);
-    }
+      uedge_notifier.clear();
+      edge_notifier.clear();
+      node_notifier.clear(); 
+    } 
+
   };
 
@@ -1246 +825 @@
     }  
   
-    typedef AlterationNotifier<Node> NodeNotifier;
-    typedef AlterationNotifier<BNode> BNodeNotifier;
-    typedef AlterationNotifier<ANode> ANodeNotifier;
-    typedef AlterationNotifier<Edge> EdgeNotifier;
-    typedef AlterationNotifier<UEdge> UEdgeNotifier;
+    typedef AlterationNotifier<BpUGraphExtender, ANode> ANodeNotifier;
+    typedef AlterationNotifier<BpUGraphExtender, BNode> BNodeNotifier;
+    typedef AlterationNotifier<BpUGraphExtender, Node> NodeNotifier;
+    typedef AlterationNotifier<BpUGraphExtender, Edge> EdgeNotifier;
+    typedef AlterationNotifier<BpUGraphExtender, UEdge> UEdgeNotifier;
 
   protected:
 
-    mutable NodeNotifier nodeNotifier;
-    mutable BNodeNotifier bNodeNotifier;
-    mutable ANodeNotifier aNodeNotifier;
-    mutable EdgeNotifier edgeNotifier;
-    mutable UEdgeNotifier uEdgeNotifier;
+    mutable ANodeNotifier anode_notifier;
+    mutable BNodeNotifier bnode_notifier;
+    mutable NodeNotifier node_notifier;
+    mutable EdgeNotifier edge_notifier;
+    mutable UEdgeNotifier uedge_notifier;
 
   public:
 
     NodeNotifier& getNotifier(Node) const {
-      return nodeNotifier;
+      return node_notifier;
+    }
+
+    ANodeNotifier& getNotifier(ANode) const {
+      return anode_notifier;
     }
 
     BNodeNotifier& getNotifier(BNode) const {
-      return bNodeNotifier;
-    }
-
-    ANodeNotifier& getNotifier(ANode) const {
-      return aNodeNotifier;
+      return bnode_notifier;
     }
 
     EdgeNotifier& getNotifier(Edge) const {
-      return edgeNotifier;
+      return edge_notifier;
     }
 
     UEdgeNotifier& getNotifier(UEdge) const {
-      return uEdgeNotifier;
+      return uedge_notifier;
     }
 
@@ -1512 +1091 @@
     template <typename _Value>
     class ANodeMap 
-      : public IterableMapExtender<DefaultMap<Graph, ANode, _Value> > {
+      : public MapExtender<DefaultMap<Graph, ANode, _Value> > {
     public:
       typedef BpUGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, ANode, _Value> > 
-      Parent;
-    
-      ANodeMap(const Graph& _g) 
-        : Parent(_g) {}
-      ANodeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, ANode, _Value> > Parent;
+    
+      ANodeMap(const Graph& graph) 
+        : Parent(graph) {}
+      ANodeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
     
       ANodeMap& operator=(const ANodeMap& cmap) {
@@ -1549 +1127 @@
     template <typename _Value>
     class BNodeMap 
-      : public IterableMapExtender<DefaultMap<Graph, BNode, _Value> > {
+      : public MapExtender<DefaultMap<Graph, BNode, _Value> > {
     public:
       typedef BpUGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, BNode, _Value> > 
-      Parent;
-    
-      BNodeMap(const Graph& _g) 
-        : Parent(_g) {}
-      BNodeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, BNode, _Value> > Parent;
+    
+      BNodeMap(const Graph& graph) 
+        : Parent(graph) {}
+      BNodeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
     
       BNodeMap& operator=(const BNodeMap& cmap) {
@@ -1595 +1172 @@
 
       /// The reference type of the map;
-      typedef typename BNodeMap<_Value>::Reference Reference;
-      /// The pointer type of the map;
-      typedef typename BNodeMap<_Value>::Pointer Pointer;
-      
-      /// The const value type of the map.
-      typedef const Value ConstValue;
+      typedef typename ANodeMap<_Value>::Reference Reference;
       /// The const reference type of the map;
-      typedef typename BNodeMap<_Value>::ConstReference ConstReference;
-      /// The pointer type of the map;
-      typedef typename BNodeMap<_Value>::ConstPointer ConstPointer;
+      typedef typename ANodeMap<_Value>::ConstReference ConstReference;
 
       typedef True ReferenceMapTag;
 
-      NodeMapBase(const Graph& _g) 
-        : aNodeMap(_g), bNodeMap(_g) {}
-      NodeMapBase(const Graph& _g, const _Value& _v) 
-        : aNodeMap(_g, _v), bNodeMap(_g, _v) {}
+      NodeMapBase(const Graph& graph) 
+        : aNodeMap(graph), bNodeMap(graph) {}
+      NodeMapBase(const Graph& graph, const _Value& value) 
+        : aNodeMap(graph, value), bNodeMap(graph, value) {}
 
       ConstReference operator[](const Key& node) const {
@@ -1650 +1220 @@
     template <typename _Value>
     class NodeMap 
-      : public IterableMapExtender<NodeMapBase<_Value> > {
+      : public MapExtender<NodeMapBase<_Value> > {
     public:
       typedef BpUGraphExtender Graph;
-      typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
-    
-      NodeMap(const Graph& _g) 
-        : Parent(_g) {}
-      NodeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      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) {
@@ -1674 +1244 @@
       NodeMap& operator=(const CMap& cmap) {
         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        Node it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
+        Edge it;
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -1688 +1258 @@
     template <typename _Value>
     class EdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
+      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
     public:
       typedef BpUGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
-    
-      EdgeMap(const Graph& _g) 
-        : Parent(_g) {}
-      EdgeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
+    
+      EdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      EdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
     
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -1705 +1275 @@
       EdgeMap& operator=(const CMap& cmap) {
         checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
         Edge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -1716 +1286 @@
     template <typename _Value>
     class UEdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
+      : public MapExtender<DefaultMap<Graph, UEdge, _Value> > {
     public:
       typedef BpUGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > 
-      Parent;
-    
-      UEdgeMap(const Graph& _g) 
-        : Parent(_g) {}
-      UEdgeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
+      typedef MapExtender<DefaultMap<Graph, UEdge, _Value> > Parent;
+    
+      UEdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      UEdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
     
       UEdgeMap& operator=(const UEdgeMap& cmap) {
@@ -1734 +1303 @@
       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)) {
+        const typename Parent::Notifier* notifier = Parent::getNotifier();
+        Edge it;
+        for (notifier->first(it); it != INVALID; notifier->next(it)) {
           Parent::set(it, cmap[it]);
         }
@@ -1802 +1371 @@
 
 
+    BpUGraphExtender() {
+      anode_notifier.setContainer(*this); 
+      bnode_notifier.setContainer(*this); 
+      node_notifier.setContainer(*this); 
+      edge_notifier.setContainer(*this); 
+      uedge_notifier.setContainer(*this);
+    } 
+
     ~BpUGraphExtender() {
-      getNotifier(Edge()).clear();
-      getNotifier(UEdge()).clear();
-      getNotifier(Node()).clear();
-      getNotifier(BNode()).clear();
-      getNotifier(ANode()).clear();
+      uedge_notifier.clear();
+      edge_notifier.clear(); 
+      node_notifier.clear(); 
+      anode_notifier.clear(); 
+      bnode_notifier.clear(); 
     }