COIN-OR::LEMON - Graph Library

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


Ignore:
Timestamp:
03/06/06 11:28:37 (14 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:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/bits/graph_extender.h

    r1996 r1999  
    2323#include <lemon/error.h>
    2424
     25#include <lemon/bits/map_extender.h>
    2526#include <lemon/bits/default_map.h>
     27
     28#include <lemon/concept_check.h>
     29#include <lemon/concept/maps.h>
    2630
    2731///\ingroup graphbits
     
    7276    // Alterable extension
    7377
    74     typedef AlterationNotifier<Node> NodeNotifier;
    75     typedef AlterationNotifier<Edge> EdgeNotifier;
     78    typedef AlterationNotifier<GraphExtender, Node> NodeNotifier;
     79    typedef AlterationNotifier<GraphExtender, Edge> EdgeNotifier;
    7680
    7781
     
    215219    template <typename _Value>
    216220    class NodeMap
    217       : public IterableMapExtender<DefaultMap<Graph, Node, _Value> > {
     221      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
    218222    public:
    219223      typedef GraphExtender Graph;
    220       typedef IterableMapExtender<DefaultMap<Graph, Node, _Value> > Parent;
    221 
    222       NodeMap(const Graph& _g)
    223         : Parent(_g) {}
    224       NodeMap(const Graph& _g, const _Value& _v)
    225         : Parent(_g, _v) {}
     224      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
     225
     226      NodeMap(const Graph& graph)
     227        : Parent(graph) {}
     228      NodeMap(const Graph& graph, const _Value& value)
     229        : Parent(graph, value) {}
    226230
    227231      NodeMap& operator=(const NodeMap& cmap) {
     
    239243      NodeMap& operator=(const CMap& cmap) {
    240244        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
    241         const typename Parent::Graph* graph = Parent::getGraph();
     245        const typename Parent::Notifier* notifier = Parent::getNotifier();
    242246        Node it;
    243         for (graph->first(it); it != INVALID; graph->next(it)) {
     247        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    244248          Parent::set(it, cmap[it]);
    245249        }
     
    251255    template <typename _Value>
    252256    class EdgeMap
    253       : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
     257      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
    254258    public:
    255259      typedef GraphExtender Graph;
    256       typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
    257 
    258       EdgeMap(const Graph& _g)
    259         : Parent(_g) {}
    260       EdgeMap(const Graph& _g, const _Value& _v)
    261         : Parent(_g, _v) {}
     260      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     261
     262      EdgeMap(const Graph& graph)
     263        : Parent(graph) {}
     264      EdgeMap(const Graph& graph, const _Value& value)
     265        : Parent(graph, value) {}
    262266
    263267      EdgeMap& operator=(const EdgeMap& cmap) {
     
    268272      EdgeMap& operator=(const CMap& cmap) {
    269273        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    270         const typename Parent::Graph* graph = Parent::getGraph();
     274        const typename Parent::Notifier* notifier = Parent::getNotifier();
    271275        Edge it;
    272         for (graph->first(it); it != INVALID; graph->next(it)) {
     276        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    273277          Parent::set(it, cmap[it]);
    274278        }
     
    320324    }
    321325
     326    GraphExtender() {
     327      node_notifier.setContainer(*this);
     328      edge_notifier.setContainer(*this);
     329    }
     330   
    322331
    323332    ~GraphExtender() {
    324       getNotifier(Edge()).clear();
    325       getNotifier(Node()).clear();
     333      edge_notifier.clear();
     334      node_notifier.clear();
    326335    }
    327336  };
    328 
    329   /// \ingroup graphbits
    330   ///
    331   /// \brief BaseExtender for the UGraphs
    332   template <typename Base>
    333   class UGraphBaseExtender : public Base {
    334 
    335   public:
    336 
    337     typedef Base Parent;
    338     typedef typename Parent::Edge UEdge;
    339     typedef typename Parent::Node Node;
    340 
    341     typedef True UndirectedTag;
    342 
    343     class Edge : public UEdge {
    344       friend class UGraphBaseExtender;
    345 
    346     protected:
    347       bool forward;
    348 
    349       Edge(const UEdge &ue, bool _forward) :
    350         UEdge(ue), forward(_forward) {}
    351 
    352     public:
    353       Edge() {}
    354 
    355       /// Invalid edge constructor
    356       Edge(Invalid i) : UEdge(i), forward(true) {}
    357 
    358       bool operator==(const Edge &that) const {
    359         return forward==that.forward && UEdge(*this)==UEdge(that);
    360       }
    361       bool operator!=(const Edge &that) const {
    362         return forward!=that.forward || UEdge(*this)!=UEdge(that);
    363       }
    364       bool operator<(const Edge &that) const {
    365         return forward<that.forward ||
    366           (!(that.forward<forward) && UEdge(*this)<UEdge(that));
    367       }
    368     };
    369 
    370 
    371 
    372     using Parent::source;
    373 
    374     /// Source of the given Edge.
    375     Node source(const Edge &e) const {
    376       return e.forward ? Parent::source(e) : Parent::target(e);
    377     }
    378 
    379     using Parent::target;
    380 
    381     /// Target of the given Edge.
    382     Node target(const Edge &e) const {
    383       return e.forward ? Parent::target(e) : Parent::source(e);
    384     }
    385 
    386     /// \brief Directed edge from an undirected edge.
    387     ///
    388     /// Returns a directed edge corresponding to the specified UEdge.
    389     /// If the given bool is true the given undirected edge and the
    390     /// returned edge have the same source node.
    391     static Edge direct(const UEdge &ue, bool d) {
    392       return Edge(ue, d);
    393     }
    394 
    395     /// Returns whether the given directed edge is same orientation as the
    396     /// corresponding undirected edge.
    397     ///
    398     /// \todo reference to the corresponding point of the undirected graph
    399     /// concept. "What does the direction of an undirected edge mean?"
    400     static bool direction(const Edge &e) { return e.forward; }
    401 
    402 
    403     using Parent::first;
    404     using Parent::next;
    405 
    406     void first(Edge &e) const {
    407       Parent::first(e);
    408       e.forward=true;
    409     }
    410 
    411     void next(Edge &e) const {
    412       if( e.forward ) {
    413         e.forward = false;
    414       }
    415       else {
    416         Parent::next(e);
    417         e.forward = true;
    418       }
    419     }
    420 
    421     void firstOut(Edge &e, const Node &n) const {
    422       Parent::firstIn(e,n);
    423       if( UEdge(e) != INVALID ) {
    424         e.forward = false;
    425       }
    426       else {
    427         Parent::firstOut(e,n);
    428         e.forward = true;
    429       }
    430     }
    431     void nextOut(Edge &e) const {
    432       if( ! e.forward ) {
    433         Node n = Parent::target(e);
    434         Parent::nextIn(e);
    435         if( UEdge(e) == INVALID ) {
    436           Parent::firstOut(e, n);
    437           e.forward = true;
    438         }
    439       }
    440       else {
    441         Parent::nextOut(e);
    442       }
    443     }
    444 
    445     void firstIn(Edge &e, const Node &n) const {
    446       Parent::firstOut(e,n);
    447       if( UEdge(e) != INVALID ) {
    448         e.forward = false;
    449       }
    450       else {
    451         Parent::firstIn(e,n);
    452         e.forward = true;
    453       }
    454     }
    455     void nextIn(Edge &e) const {
    456       if( ! e.forward ) {
    457         Node n = Parent::source(e);
    458         Parent::nextOut(e);
    459         if( UEdge(e) == INVALID ) {
    460           Parent::firstIn(e, n);
    461           e.forward = true;
    462         }
    463       }
    464       else {
    465         Parent::nextIn(e);
    466       }
    467     }
    468 
    469     void firstInc(UEdge &e, bool &d, const Node &n) const {
    470       d = true;
    471       Parent::firstOut(e, n);
    472       if (e != INVALID) return;
    473       d = false;
    474       Parent::firstIn(e, n);
    475     }
    476 
    477     void nextInc(UEdge &e, bool &d) const {
    478       if (d) {
    479         Node s = Parent::source(e);
    480         Parent::nextOut(e);
    481         if (e != INVALID) return;
    482         d = false;
    483         Parent::firstIn(e, s);
    484       } else {
    485         Parent::nextIn(e);
    486       }
    487     }
    488 
    489     Node nodeFromId(int id) const {
    490       return Parent::nodeFromId(id);
    491     }
    492 
    493     Edge edgeFromId(int id) const {
    494       return direct(Parent::edgeFromId(id >> 1), bool(id & 1));
    495     }
    496 
    497     UEdge uEdgeFromId(int id) const {
    498       return Parent::edgeFromId(id >> 1);
    499     }
    500 
    501     int id(const Node &n) const {
    502       return Parent::id(n);
    503     }
    504 
    505     int id(const UEdge &e) const {
    506       return Parent::id(e);
    507     }
    508 
    509     int id(const Edge &e) const {
    510       return 2 * Parent::id(e) + int(e.forward);
    511     }
    512 
    513     int maxNodeId() const {
    514       return Parent::maxNodeId();
    515     }
    516 
    517     int maxEdgeId() const {
    518       return 2 * Parent::maxEdgeId() + 1;
    519     }
    520 
    521     int maxUEdgeId() const {
    522       return Parent::maxEdgeId();
    523     }
    524 
    525 
    526     int edgeNum() const {
    527       return 2 * Parent::edgeNum();
    528     }
    529 
    530     int uEdgeNum() const {
    531       return Parent::edgeNum();
    532     }
    533 
    534     Edge findEdge(Node source, Node target, Edge prev) const {
    535       if (prev == INVALID) {
    536         UEdge edge = Parent::findEdge(source, target);
    537         if (edge != INVALID) return direct(edge, true);
    538         edge = Parent::findEdge(target, source);
    539         if (edge != INVALID) return direct(edge, false);
    540       } else if (direction(prev)) {
    541         UEdge edge = Parent::findEdge(source, target, prev);
    542         if (edge != INVALID) return direct(edge, true);
    543         edge = Parent::findEdge(target, source);
    544         if (edge != INVALID) return direct(edge, false);       
    545       } else {
    546         UEdge edge = Parent::findEdge(target, source, prev);
    547         if (edge != INVALID) return direct(edge, false);             
    548       }
    549       return INVALID;
    550     }
    551 
    552     UEdge findUEdge(Node source, Node target, UEdge prev) const {
    553       if (prev == INVALID) {
    554         UEdge edge = Parent::findEdge(source, target);
    555         if (edge != INVALID) return edge;
    556         edge = Parent::findEdge(target, source);
    557         if (edge != INVALID) return edge;
    558       } else if (Parent::source(prev) == source) {
    559         UEdge edge = Parent::findEdge(source, target, prev);
    560         if (edge != INVALID) return edge;
    561         edge = Parent::findEdge(target, source);
    562         if (edge != INVALID) return edge;       
    563       } else {
    564         UEdge edge = Parent::findEdge(target, source, prev);
    565         if (edge != INVALID) return edge;             
    566       }
    567       return INVALID;
    568     }
    569   };
    570 
    571337
    572338  /// \ingroup graphbits
     
    630396    // Alterable extension
    631397
    632     typedef AlterationNotifier<Node> NodeNotifier;
    633     typedef AlterationNotifier<Edge> EdgeNotifier;
    634     typedef AlterationNotifier<UEdge> UEdgeNotifier;
     398    typedef AlterationNotifier<UGraphExtender, Node> NodeNotifier;
     399    typedef AlterationNotifier<UGraphExtender, Edge> EdgeNotifier;
     400    typedef AlterationNotifier<UGraphExtender, UEdge> UEdgeNotifier;
    635401
    636402
     
    843609    template <typename _Value>
    844610    class NodeMap
    845       : public IterableMapExtender<DefaultMap<Graph, Node, _Value> > {
     611      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
    846612    public:
    847613      typedef UGraphExtender Graph;
    848       typedef IterableMapExtender<DefaultMap<Graph, Node, _Value> > Parent;
    849 
    850       NodeMap(const Graph& _g)
    851         : Parent(_g) {}
    852       NodeMap(const Graph& _g, const _Value& _v)
    853         : Parent(_g, _v) {}
     614      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
     615
     616      NodeMap(const Graph& graph)
     617        : Parent(graph) {}
     618      NodeMap(const Graph& graph, const _Value& value)
     619        : Parent(graph, value) {}
    854620
    855621      NodeMap& operator=(const NodeMap& cmap) {
     
    867633      NodeMap& operator=(const CMap& cmap) {
    868634        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
    869         const typename Parent::Graph* graph = Parent::getGraph();
     635        const typename Parent::Notifier* notifier = Parent::getNotifier();
    870636        Node it;
    871         for (graph->first(it); it != INVALID; graph->next(it)) {
     637        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    872638          Parent::set(it, cmap[it]);
    873639        }
     
    879645    template <typename _Value>
    880646    class EdgeMap
    881       : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
     647      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
    882648    public:
    883649      typedef UGraphExtender Graph;
    884       typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
    885 
    886       EdgeMap(const Graph& _g)
    887         : Parent(_g) {}
    888       EdgeMap(const Graph& _g, const _Value& _v)
    889         : Parent(_g, _v) {}
     650      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     651
     652      EdgeMap(const Graph& graph)
     653        : Parent(graph) {}
     654      EdgeMap(const Graph& graph, const _Value& value)
     655        : Parent(graph, value) {}
    890656
    891657      EdgeMap& operator=(const EdgeMap& cmap) {
     
    896662      EdgeMap& operator=(const CMap& cmap) {
    897663        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    898         const typename Parent::Graph* graph = Parent::getGraph();
     664        const typename Parent::Notifier* notifier = Parent::getNotifier();
    899665        Edge it;
    900         for (graph->first(it); it != INVALID; graph->next(it)) {
     666        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    901667          Parent::set(it, cmap[it]);
    902668        }
     
    908674    template <typename _Value>
    909675    class UEdgeMap
    910       : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
     676      : public MapExtender<DefaultMap<Graph, UEdge, _Value> > {
    911677    public:
    912678      typedef UGraphExtender Graph;
    913       typedef IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > Parent;
    914 
    915       UEdgeMap(const Graph& _g)
    916         : Parent(_g) {}
    917       UEdgeMap(const Graph& _g, const _Value& _v)
    918         : Parent(_g, _v) {}
     679      typedef MapExtender<DefaultMap<Graph, UEdge, _Value> > Parent;
     680
     681      UEdgeMap(const Graph& graph)
     682        : Parent(graph) {}
     683      UEdgeMap(const Graph& graph, const _Value& value)
     684        : Parent(graph, value) {}
    919685
    920686      UEdgeMap& operator=(const UEdgeMap& cmap) {
     
    925691      UEdgeMap& operator=(const CMap& cmap) {
    926692        checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
    927         const typename Parent::Graph* graph = Parent::getGraph();
    928         UEdge it;
    929         for (graph->first(it); it != INVALID; graph->next(it)) {
     693        const typename Parent::Notifier* notifier = Parent::getNotifier();
     694        Edge it;
     695        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    930696          Parent::set(it, cmap[it]);
    931697        }
     
    982748    }
    983749
     750    UGraphExtender() {
     751      node_notifier.setContainer(*this);
     752      edge_notifier.setContainer(*this);
     753      uedge_notifier.setContainer(*this);
     754    }
     755
    984756    ~UGraphExtender() {
    985       getNotifier(Edge()).clear();
    986       getNotifier(UEdge()).clear();
    987       getNotifier(Node()).clear();
    988     }
    989 
    990   };
    991 
    992 
    993   /// \ingroup graphbits
    994   ///
    995   /// \brief BaseExtender for the BpUGraphs
    996   template <typename Base>
    997   class BpUGraphBaseExtender : public Base {
    998   public:
    999     typedef Base Parent;
    1000     typedef BpUGraphBaseExtender Graph;
    1001 
    1002     typedef typename Parent::Node Node;
    1003     typedef typename Parent::Edge UEdge;
    1004 
    1005 
    1006     using Parent::first;
    1007     using Parent::next;
    1008 
    1009     using Parent::id;
    1010 
    1011     class ANode : public Node {
    1012       friend class BpUGraphBaseExtender;
    1013     public:
    1014       ANode() {}
    1015       ANode(const Node& node) : Node(node) {
    1016         LEMON_ASSERT(Parent::aNode(node) || node == INVALID,
    1017                      typename Parent::NodeSetError());
    1018       }
    1019       ANode(Invalid) : Node(INVALID) {}
    1020     };
    1021 
    1022     void first(ANode& node) const {
    1023       Parent::firstANode(static_cast<Node&>(node));
    1024     }
    1025     void next(ANode& node) const {
    1026       Parent::nextANode(static_cast<Node&>(node));
    1027     }
    1028 
    1029     int id(const ANode& node) const {
    1030       return Parent::aNodeId(node);
    1031     }
    1032 
    1033     class BNode : public Node {
    1034       friend class BpUGraphBaseExtender;
    1035     public:
    1036       BNode() {}
    1037       BNode(const Node& node) : Node(node) {
    1038         LEMON_ASSERT(Parent::bNode(node) || node == INVALID,
    1039                      typename Parent::NodeSetError());
    1040       }
    1041       BNode(Invalid) : Node(INVALID) {}
    1042     };
    1043 
    1044     void first(BNode& node) const {
    1045       Parent::firstBNode(static_cast<Node&>(node));
    1046     }
    1047     void next(BNode& node) const {
    1048       Parent::nextBNode(static_cast<Node&>(node));
    1049     }
    1050  
    1051     int id(const BNode& node) const {
    1052       return Parent::aNodeId(node);
    1053     }
    1054 
    1055     Node source(const UEdge& edge) const {
    1056       return aNode(edge);
    1057     }
    1058     Node target(const UEdge& edge) const {
    1059       return bNode(edge);
    1060     }
    1061 
    1062     void firstInc(UEdge& edge, bool& direction, const Node& node) const {
    1063       if (Parent::aNode(node)) {
    1064         Parent::firstOut(edge, node);
    1065         direction = true;
    1066       } else {
    1067         Parent::firstIn(edge, node);
    1068         direction = static_cast<UEdge&>(edge) == INVALID;
    1069       }
    1070     }
    1071     void nextInc(UEdge& edge, bool& direction) const {
    1072       if (direction) {
    1073         Parent::nextOut(edge);
    1074       } else {
    1075         Parent::nextIn(edge);
    1076         if (edge == INVALID) direction = true;
    1077       }
    1078     }
    1079 
    1080     int maxUEdgeId() const {
    1081       return Parent::maxEdgeId();
    1082     }
    1083 
    1084     UEdge uEdgeFromId(int id) const {
    1085       return Parent::edgeFromId(id);
    1086     }
    1087 
    1088     class Edge : public UEdge {
    1089       friend class BpUGraphBaseExtender;
    1090     protected:
    1091       bool forward;
    1092 
    1093       Edge(const UEdge& edge, bool _forward)
    1094         : UEdge(edge), forward(_forward) {}
    1095 
    1096     public:
    1097       Edge() {}
    1098       Edge (Invalid) : UEdge(INVALID), forward(true) {}
    1099       bool operator==(const Edge& i) const {
    1100         return UEdge::operator==(i) && forward == i.forward;
    1101       }
    1102       bool operator!=(const Edge& i) const {
    1103         return UEdge::operator!=(i) || forward != i.forward;
    1104       }
    1105       bool operator<(const Edge& i) const {
    1106         return UEdge::operator<(i) ||
    1107           (!(i.forward<forward) && UEdge(*this)<UEdge(i));
    1108       }
    1109     };
    1110 
    1111     void first(Edge& edge) const {
    1112       Parent::first(static_cast<UEdge&>(edge));
    1113       edge.forward = true;
    1114     }
    1115 
    1116     void next(Edge& edge) const {
    1117       if (!edge.forward) {
    1118         Parent::next(static_cast<UEdge&>(edge));
    1119       }
    1120       edge.forward = !edge.forward;
    1121     }
    1122 
    1123     void firstOut(Edge& edge, const Node& node) const {
    1124       if (Parent::aNode(node)) {
    1125         Parent::firstOut(edge, node);
    1126         edge.forward = true;
    1127       } else {
    1128         Parent::firstIn(edge, node);
    1129         edge.forward = static_cast<UEdge&>(edge) == INVALID;
    1130       }
    1131     }
    1132     void nextOut(Edge& edge) const {
    1133       if (edge.forward) {
    1134         Parent::nextOut(edge);
    1135       } else {
    1136         Parent::nextIn(edge);
    1137         edge.forward = static_cast<UEdge&>(edge) == INVALID;
    1138       }
    1139     }
    1140 
    1141     void firstIn(Edge& edge, const Node& node) const {
    1142       if (Parent::bNode(node)) {
    1143         Parent::firstIn(edge, node);
    1144         edge.forward = true;   
    1145       } else {
    1146         Parent::firstOut(edge, node);
    1147         edge.forward = static_cast<UEdge&>(edge) == INVALID;
    1148       }
    1149     }
    1150     void nextIn(Edge& edge) const {
    1151       if (edge.forward) {
    1152         Parent::nextIn(edge);
    1153       } else {
    1154         Parent::nextOut(edge);
    1155         edge.forward = static_cast<UEdge&>(edge) == INVALID;
    1156       }
    1157     }
    1158 
    1159     Node source(const Edge& edge) const {
    1160       return edge.forward ? Parent::aNode(edge) : Parent::bNode(edge);
    1161     }
    1162     Node target(const Edge& edge) const {
    1163       return edge.forward ? Parent::bNode(edge) : Parent::aNode(edge);
    1164     }
    1165 
    1166     int id(const Edge& edge) const {
    1167       return (Parent::id(edge) << 1) + (edge.forward ? 0 : 1);
    1168     }
    1169     Edge edgeFromId(int id) const {
    1170       return Edge(Parent::fromId(id >> 1, UEdge()), (id & 1) == 0);
    1171     }
    1172     int maxEdgeId() const {
    1173       return (Parent::maxId(UEdge()) << 1) + 1;
    1174     }
    1175 
    1176     bool direction(const Edge& edge) const {
    1177       return edge.forward;
    1178     }
    1179 
    1180     Edge direct(const UEdge& edge, bool direction) const {
    1181       return Edge(edge, direction);
    1182     }
     757      uedge_notifier.clear();
     758      edge_notifier.clear();
     759      node_notifier.clear();
     760    }
     761
    1183762  };
    1184763
     
    1246825    } 
    1247826 
    1248     typedef AlterationNotifier<Node> NodeNotifier;
    1249     typedef AlterationNotifier<BNode> BNodeNotifier;
    1250     typedef AlterationNotifier<ANode> ANodeNotifier;
    1251     typedef AlterationNotifier<Edge> EdgeNotifier;
    1252     typedef AlterationNotifier<UEdge> UEdgeNotifier;
     827    typedef AlterationNotifier<BpUGraphExtender, ANode> ANodeNotifier;
     828    typedef AlterationNotifier<BpUGraphExtender, BNode> BNodeNotifier;
     829    typedef AlterationNotifier<BpUGraphExtender, Node> NodeNotifier;
     830    typedef AlterationNotifier<BpUGraphExtender, Edge> EdgeNotifier;
     831    typedef AlterationNotifier<BpUGraphExtender, UEdge> UEdgeNotifier;
    1253832
    1254833  protected:
    1255834
    1256     mutable NodeNotifier nodeNotifier;
    1257     mutable BNodeNotifier bNodeNotifier;
    1258     mutable ANodeNotifier aNodeNotifier;
    1259     mutable EdgeNotifier edgeNotifier;
    1260     mutable UEdgeNotifier uEdgeNotifier;
     835    mutable ANodeNotifier anode_notifier;
     836    mutable BNodeNotifier bnode_notifier;
     837    mutable NodeNotifier node_notifier;
     838    mutable EdgeNotifier edge_notifier;
     839    mutable UEdgeNotifier uedge_notifier;
    1261840
    1262841  public:
    1263842
    1264843    NodeNotifier& getNotifier(Node) const {
    1265       return nodeNotifier;
     844      return node_notifier;
     845    }
     846
     847    ANodeNotifier& getNotifier(ANode) const {
     848      return anode_notifier;
    1266849    }
    1267850
    1268851    BNodeNotifier& getNotifier(BNode) const {
    1269       return bNodeNotifier;
    1270     }
    1271 
    1272     ANodeNotifier& getNotifier(ANode) const {
    1273       return aNodeNotifier;
     852      return bnode_notifier;
    1274853    }
    1275854
    1276855    EdgeNotifier& getNotifier(Edge) const {
    1277       return edgeNotifier;
     856      return edge_notifier;
    1278857    }
    1279858
    1280859    UEdgeNotifier& getNotifier(UEdge) const {
    1281       return uEdgeNotifier;
     860      return uedge_notifier;
    1282861    }
    1283862
     
    15121091    template <typename _Value>
    15131092    class ANodeMap
    1514       : public IterableMapExtender<DefaultMap<Graph, ANode, _Value> > {
     1093      : public MapExtender<DefaultMap<Graph, ANode, _Value> > {
    15151094    public:
    15161095      typedef BpUGraphExtender Graph;
    1517       typedef IterableMapExtender<DefaultMap<Graph, ANode, _Value> >
    1518       Parent;
    1519    
    1520       ANodeMap(const Graph& _g)
    1521         : Parent(_g) {}
    1522       ANodeMap(const Graph& _g, const _Value& _v)
    1523         : Parent(_g, _v) {}
     1096      typedef MapExtender<DefaultMap<Graph, ANode, _Value> > Parent;
     1097   
     1098      ANodeMap(const Graph& graph)
     1099        : Parent(graph) {}
     1100      ANodeMap(const Graph& graph, const _Value& value)
     1101        : Parent(graph, value) {}
    15241102   
    15251103      ANodeMap& operator=(const ANodeMap& cmap) {
     
    15491127    template <typename _Value>
    15501128    class BNodeMap
    1551       : public IterableMapExtender<DefaultMap<Graph, BNode, _Value> > {
     1129      : public MapExtender<DefaultMap<Graph, BNode, _Value> > {
    15521130    public:
    15531131      typedef BpUGraphExtender Graph;
    1554       typedef IterableMapExtender<DefaultMap<Graph, BNode, _Value> >
    1555       Parent;
    1556    
    1557       BNodeMap(const Graph& _g)
    1558         : Parent(_g) {}
    1559       BNodeMap(const Graph& _g, const _Value& _v)
    1560         : Parent(_g, _v) {}
     1132      typedef MapExtender<DefaultMap<Graph, BNode, _Value> > Parent;
     1133   
     1134      BNodeMap(const Graph& graph)
     1135        : Parent(graph) {}
     1136      BNodeMap(const Graph& graph, const _Value& value)
     1137        : Parent(graph, value) {}
    15611138   
    15621139      BNodeMap& operator=(const BNodeMap& cmap) {
     
    15951172
    15961173      /// The reference type of the map;
    1597       typedef typename BNodeMap<_Value>::Reference Reference;
    1598       /// The pointer type of the map;
    1599       typedef typename BNodeMap<_Value>::Pointer Pointer;
    1600      
    1601       /// The const value type of the map.
    1602       typedef const Value ConstValue;
     1174      typedef typename ANodeMap<_Value>::Reference Reference;
    16031175      /// The const reference type of the map;
    1604       typedef typename BNodeMap<_Value>::ConstReference ConstReference;
    1605       /// The pointer type of the map;
    1606       typedef typename BNodeMap<_Value>::ConstPointer ConstPointer;
     1176      typedef typename ANodeMap<_Value>::ConstReference ConstReference;
    16071177
    16081178      typedef True ReferenceMapTag;
    16091179
    1610       NodeMapBase(const Graph& _g)
    1611         : aNodeMap(_g), bNodeMap(_g) {}
    1612       NodeMapBase(const Graph& _g, const _Value& _v)
    1613         : aNodeMap(_g, _v), bNodeMap(_g, _v) {}
     1180      NodeMapBase(const Graph& graph)
     1181        : aNodeMap(graph), bNodeMap(graph) {}
     1182      NodeMapBase(const Graph& graph, const _Value& value)
     1183        : aNodeMap(graph, value), bNodeMap(graph, value) {}
    16141184
    16151185      ConstReference operator[](const Key& node) const {
     
    16501220    template <typename _Value>
    16511221    class NodeMap
    1652       : public IterableMapExtender<NodeMapBase<_Value> > {
     1222      : public MapExtender<NodeMapBase<_Value> > {
    16531223    public:
    16541224      typedef BpUGraphExtender Graph;
    1655       typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
    1656    
    1657       NodeMap(const Graph& _g)
    1658         : Parent(_g) {}
    1659       NodeMap(const Graph& _g, const _Value& _v)
    1660         : Parent(_g, _v) {}
     1225      typedef MapExtender< NodeMapBase<_Value> > Parent;
     1226   
     1227      NodeMap(const Graph& graph)
     1228        : Parent(graph) {}
     1229      NodeMap(const Graph& graph, const _Value& value)
     1230        : Parent(graph, value) {}
    16611231   
    16621232      NodeMap& operator=(const NodeMap& cmap) {
     
    16741244      NodeMap& operator=(const CMap& cmap) {
    16751245        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
    1676         const typename Parent::Graph* graph = Parent::getGraph();
    1677         Node it;
    1678         for (graph->first(it); it != INVALID; graph->next(it)) {
     1246        const typename Parent::Notifier* notifier = Parent::getNotifier();
     1247        Edge it;
     1248        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    16791249          Parent::set(it, cmap[it]);
    16801250        }
     
    16881258    template <typename _Value>
    16891259    class EdgeMap
    1690       : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
     1260      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
    16911261    public:
    16921262      typedef BpUGraphExtender Graph;
    1693       typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
    1694    
    1695       EdgeMap(const Graph& _g)
    1696         : Parent(_g) {}
    1697       EdgeMap(const Graph& _g, const _Value& _v)
    1698         : Parent(_g, _v) {}
     1263      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     1264   
     1265      EdgeMap(const Graph& graph)
     1266        : Parent(graph) {}
     1267      EdgeMap(const Graph& graph, const _Value& value)
     1268        : Parent(graph, value) {}
    16991269   
    17001270      EdgeMap& operator=(const EdgeMap& cmap) {
     
    17051275      EdgeMap& operator=(const CMap& cmap) {
    17061276        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
    1707         const typename Parent::Graph* graph = Parent::getGraph();
     1277        const typename Parent::Notifier* notifier = Parent::getNotifier();
    17081278        Edge it;
    1709         for (graph->first(it); it != INVALID; graph->next(it)) {
     1279        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    17101280          Parent::set(it, cmap[it]);
    17111281        }
     
    17161286    template <typename _Value>
    17171287    class UEdgeMap
    1718       : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
     1288      : public MapExtender<DefaultMap<Graph, UEdge, _Value> > {
    17191289    public:
    17201290      typedef BpUGraphExtender Graph;
    1721       typedef IterableMapExtender<DefaultMap<Graph, UEdge, _Value> >
    1722       Parent;
    1723    
    1724       UEdgeMap(const Graph& _g)
    1725         : Parent(_g) {}
    1726       UEdgeMap(const Graph& _g, const _Value& _v)
    1727         : Parent(_g, _v) {}
     1291      typedef MapExtender<DefaultMap<Graph, UEdge, _Value> > Parent;
     1292   
     1293      UEdgeMap(const Graph& graph)
     1294        : Parent(graph) {}
     1295      UEdgeMap(const Graph& graph, const _Value& value)
     1296        : Parent(graph, value) {}
    17281297   
    17291298      UEdgeMap& operator=(const UEdgeMap& cmap) {
     
    17341303      UEdgeMap& operator=(const CMap& cmap) {
    17351304        checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
    1736         const typename Parent::Graph* graph = Parent::getGraph();
    1737         UEdge it;
    1738         for (graph->first(it); it != INVALID; graph->next(it)) {
     1305        const typename Parent::Notifier* notifier = Parent::getNotifier();
     1306        Edge it;
     1307        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    17391308          Parent::set(it, cmap[it]);
    17401309        }
     
    18021371
    18031372
     1373    BpUGraphExtender() {
     1374      anode_notifier.setContainer(*this);
     1375      bnode_notifier.setContainer(*this);
     1376      node_notifier.setContainer(*this);
     1377      edge_notifier.setContainer(*this);
     1378      uedge_notifier.setContainer(*this);
     1379    }
     1380
    18041381    ~BpUGraphExtender() {
    1805       getNotifier(Edge()).clear();
    1806       getNotifier(UEdge()).clear();
    1807       getNotifier(Node()).clear();
    1808       getNotifier(BNode()).clear();
    1809       getNotifier(ANode()).clear();
     1382      uedge_notifier.clear();
     1383      edge_notifier.clear();
     1384      node_notifier.clear();
     1385      anode_notifier.clear();
     1386      bnode_notifier.clear();
    18101387    }
    18111388
Note: See TracChangeset for help on using the changeset viewer.