COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • lemon/bits/edge_set_extender.h

    r968 r664  
    1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
     1/* -*- C++ -*-
    22 *
    3  * This file is a part of LEMON, a generic C++ optimization library.
     3 * This file is a part of LEMON, a generic C++ optimization library
    44 *
    5  * Copyright (C) 2003-2010
     5 * Copyright (C) 2003-2008
    66 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    77 * (Egervary Research Group on Combinatorial Optimization, EGRES).
    … …  
    6464    Node oppositeNode(const Node &n, const Arc &e) const {
    6565      if (n == Parent::source(e))
    66         return Parent::target(e);
     66        return Parent::target(e);
    6767      else if(n==Parent::target(e))
    68         return Parent::source(e);
     68        return Parent::source(e);
    6969      else
    70         return INVALID;
     70        return INVALID;
    7171    }
    7272
    … …  
    9292    // Iterable extensions
    9393
    94     class NodeIt : public Node {
     94    class NodeIt : public Node { 
    9595      const Digraph* digraph;
    9696    public:
    … …  
    101101
    102102      explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
    103         _graph.first(static_cast<Node&>(*this));
    104       }
    105 
    106       NodeIt(const Digraph& _graph, const Node& node)
    107         : Node(node), digraph(&_graph) {}
    108 
    109       NodeIt& operator++() {
    110         digraph->next(*this);
    111         return *this;
    112       }
    113 
    114     };
    115 
    116 
    117     class ArcIt : public Arc {
     103        _graph.first(static_cast<Node&>(*this));
     104      }
     105
     106      NodeIt(const Digraph& _graph, const Node& node) 
     107        : Node(node), digraph(&_graph) {}
     108
     109      NodeIt& operator++() { 
     110        digraph->next(*this);
     111        return *this;
     112      }
     113
     114    };
     115
     116
     117    class ArcIt : public Arc { 
    118118      const Digraph* digraph;
    119119    public:
    … …  
    124124
    125125      explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
    126         _graph.first(static_cast<Arc&>(*this));
    127       }
    128 
    129       ArcIt(const Digraph& _graph, const Arc& e) :
    130         Arc(e), digraph(&_graph) { }
    131 
    132       ArcIt& operator++() {
    133         digraph->next(*this);
    134         return *this;
    135       }
    136 
    137     };
    138 
    139 
    140     class OutArcIt : public Arc {
     126        _graph.first(static_cast<Arc&>(*this));
     127      }
     128
     129      ArcIt(const Digraph& _graph, const Arc& e) : 
     130        Arc(e), digraph(&_graph) { }
     131
     132      ArcIt& operator++() { 
     133        digraph->next(*this);
     134        return *this;
     135      }
     136
     137    };
     138
     139
     140    class OutArcIt : public Arc { 
    141141      const Digraph* digraph;
    142142    public:
    … …  
    146146      OutArcIt(Invalid i) : Arc(i) { }
    147147
    148       OutArcIt(const Digraph& _graph, const Node& node)
    149         : digraph(&_graph) {
    150         _graph.firstOut(*this, node);
    151       }
    152 
    153       OutArcIt(const Digraph& _graph, const Arc& arc)
    154         : Arc(arc), digraph(&_graph) {}
    155 
    156       OutArcIt& operator++() {
    157         digraph->nextOut(*this);
    158         return *this;
    159       }
    160 
    161     };
    162 
    163 
    164     class InArcIt : public Arc {
     148      OutArcIt(const Digraph& _graph, const Node& node) 
     149        : digraph(&_graph) {
     150        _graph.firstOut(*this, node);
     151      }
     152
     153      OutArcIt(const Digraph& _graph, const Arc& arc) 
     154        : Arc(arc), digraph(&_graph) {}
     155
     156      OutArcIt& operator++() { 
     157        digraph->nextOut(*this);
     158        return *this;
     159      }
     160
     161    };
     162
     163
     164    class InArcIt : public Arc { 
    165165      const Digraph* digraph;
    166166    public:
    … …  
    170170      InArcIt(Invalid i) : Arc(i) { }
    171171
    172       InArcIt(const Digraph& _graph, const Node& node)
    173         : digraph(&_graph) {
    174         _graph.firstIn(*this, node);
    175       }
    176 
    177       InArcIt(const Digraph& _graph, const Arc& arc) :
    178         Arc(arc), digraph(&_graph) {}
    179 
    180       InArcIt& operator++() {
    181         digraph->nextIn(*this);
    182         return *this;
     172      InArcIt(const Digraph& _graph, const Node& node) 
     173        : digraph(&_graph) {
     174        _graph.firstIn(*this, node);
     175      }
     176
     177      InArcIt(const Digraph& _graph, const Arc& arc) : 
     178        Arc(arc), digraph(&_graph) {}
     179
     180      InArcIt& operator++() { 
     181        digraph->nextIn(*this);
     182        return *this;
    183183      }
    184184
    … …  
    216216
    217217    // Mappable extension
    218 
     218   
    219219    template <typename _Value>
    220     class ArcMap
     220    class ArcMap 
    221221      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
    222222      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
    223223
    224224    public:
    225       explicit ArcMap(const Digraph& _g)
    226         : Parent(_g) {}
    227       ArcMap(const Digraph& _g, const _Value& _v)
    228         : Parent(_g, _v) {}
     225      explicit ArcMap(const Digraph& _g) 
     226        : Parent(_g) {}
     227      ArcMap(const Digraph& _g, const _Value& _v) 
     228        : Parent(_g, _v) {}
    229229
    230230      ArcMap& operator=(const ArcMap& cmap) {
    231         return operator=<ArcMap>(cmap);
     231        return operator=<ArcMap>(cmap);
    232232      }
    233233
    … …  
    235235      ArcMap& operator=(const CMap& cmap) {
    236236        Parent::operator=(cmap);
    237         return *this;
     237        return *this;
    238238      }
    239239
    … …  
    248248      return arc;
    249249    }
    250 
     250   
    251251    void clear() {
    252252      notifier(Arc()).clear();
    … …  
    281281    typedef EdgeSetExtender Graph;
    282282
    283     typedef True UndirectedTag;
    284 
    285283    typedef typename Parent::Node Node;
    286284    typedef typename Parent::Arc Arc;
    … …  
    313311    Node oppositeNode(const Node &n, const Edge &e) const {
    314312      if( n == Parent::u(e))
    315         return Parent::v(e);
     313        return Parent::v(e);
    316314      else if( n == Parent::v(e))
    317         return Parent::u(e);
     315        return Parent::u(e);
    318316      else
    319         return INVALID;
     317        return INVALID;
    320318    }
    321319
    … …  
    341339
    342340    using Parent::notifier;
    343 
     341   
    344342    ArcNotifier& notifier(Arc) const {
    345343      return arc_notifier;
    … …  
    351349
    352350
    353     class NodeIt : public Node {
     351    class NodeIt : public Node { 
    354352      const Graph* graph;
    355353    public:
    … …  
    360358
    361359      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
    362         _graph.first(static_cast<Node&>(*this));
    363       }
    364 
    365       NodeIt(const Graph& _graph, const Node& node)
    366         : Node(node), graph(&_graph) {}
    367 
    368       NodeIt& operator++() {
    369         graph->next(*this);
    370         return *this;
    371       }
    372 
    373     };
    374 
    375 
    376     class ArcIt : public Arc {
     360        _graph.first(static_cast<Node&>(*this));
     361      }
     362
     363      NodeIt(const Graph& _graph, const Node& node) 
     364        : Node(node), graph(&_graph) {}
     365
     366      NodeIt& operator++() { 
     367        graph->next(*this);
     368        return *this;
     369      }
     370
     371    };
     372
     373
     374    class ArcIt : public Arc { 
    377375      const Graph* graph;
    378376    public:
    … …  
    383381
    384382      explicit ArcIt(const Graph& _graph) : graph(&_graph) {
    385         _graph.first(static_cast<Arc&>(*this));
    386       }
    387 
    388       ArcIt(const Graph& _graph, const Arc& e) :
    389         Arc(e), graph(&_graph) { }
    390 
    391       ArcIt& operator++() {
    392         graph->next(*this);
    393         return *this;
    394       }
    395 
    396     };
    397 
    398 
    399     class OutArcIt : public Arc {
     383        _graph.first(static_cast<Arc&>(*this));
     384      }
     385
     386      ArcIt(const Graph& _graph, const Arc& e) : 
     387        Arc(e), graph(&_graph) { }
     388
     389      ArcIt& operator++() { 
     390        graph->next(*this);
     391        return *this;
     392      }
     393
     394    };
     395
     396
     397    class OutArcIt : public Arc { 
    400398      const Graph* graph;
    401399    public:
    … …  
    405403      OutArcIt(Invalid i) : Arc(i) { }
    406404
    407       OutArcIt(const Graph& _graph, const Node& node)
    408         : graph(&_graph) {
    409         _graph.firstOut(*this, node);
    410       }
    411 
    412       OutArcIt(const Graph& _graph, const Arc& arc)
    413         : Arc(arc), graph(&_graph) {}
    414 
    415       OutArcIt& operator++() {
    416         graph->nextOut(*this);
    417         return *this;
    418       }
    419 
    420     };
    421 
    422 
    423     class InArcIt : public Arc {
     405      OutArcIt(const Graph& _graph, const Node& node) 
     406        : graph(&_graph) {
     407        _graph.firstOut(*this, node);
     408      }
     409
     410      OutArcIt(const Graph& _graph, const Arc& arc) 
     411        : Arc(arc), graph(&_graph) {}
     412
     413      OutArcIt& operator++() { 
     414        graph->nextOut(*this);
     415        return *this;
     416      }
     417
     418    };
     419
     420
     421    class InArcIt : public Arc { 
    424422      const Graph* graph;
    425423    public:
    … …  
    429427      InArcIt(Invalid i) : Arc(i) { }
    430428
    431       InArcIt(const Graph& _graph, const Node& node)
    432         : graph(&_graph) {
    433         _graph.firstIn(*this, node);
    434       }
    435 
    436       InArcIt(const Graph& _graph, const Arc& arc) :
    437         Arc(arc), graph(&_graph) {}
    438 
    439       InArcIt& operator++() {
    440         graph->nextIn(*this);
    441         return *this;
    442       }
    443 
    444     };
    445 
    446 
    447     class EdgeIt : public Parent::Edge {
     429      InArcIt(const Graph& _graph, const Node& node) 
     430        : graph(&_graph) {
     431        _graph.firstIn(*this, node);
     432      }
     433
     434      InArcIt(const Graph& _graph, const Arc& arc) : 
     435        Arc(arc), graph(&_graph) {}
     436
     437      InArcIt& operator++() { 
     438        graph->nextIn(*this);
     439        return *this;
     440      }
     441
     442    };
     443
     444
     445    class EdgeIt : public Parent::Edge { 
    448446      const Graph* graph;
    449447    public:
    … …  
    454452
    455453      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
    456         _graph.first(static_cast<Edge&>(*this));
    457       }
    458 
    459       EdgeIt(const Graph& _graph, const Edge& e) :
    460         Edge(e), graph(&_graph) { }
    461 
    462       EdgeIt& operator++() {
    463         graph->next(*this);
    464         return *this;
     454        _graph.first(static_cast<Edge&>(*this));
     455      }
     456
     457      EdgeIt(const Graph& _graph, const Edge& e) : 
     458        Edge(e), graph(&_graph) { }
     459
     460      EdgeIt& operator++() { 
     461        graph->next(*this);
     462        return *this;
    465463      }
    466464
    … …  
    478476
    479477      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
    480         _graph.firstInc(*this, direction, n);
     478        _graph.firstInc(*this, direction, n);
    481479      }
    482480
    483481      IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
    484         : graph(&_graph), Edge(ue) {
    485         direction = (_graph.source(ue) == n);
     482        : graph(&_graph), Edge(ue) {
     483        direction = (_graph.source(ue) == n);
    486484      }
    487485
    488486      IncEdgeIt& operator++() {
    489         graph->nextInc(*this, direction);
    490         return *this;
     487        graph->nextInc(*this, direction);
     488        return *this;
    491489      }
    492490    };
    … …  
    535533
    536534    template <typename _Value>
    537     class ArcMap
     535    class ArcMap 
    538536      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
    539537      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
    540538
    541539    public:
    542       explicit ArcMap(const Graph& _g)
    543         : Parent(_g) {}
    544       ArcMap(const Graph& _g, const _Value& _v)
    545         : Parent(_g, _v) {}
     540      ArcMap(const Graph& _g)
     541        : Parent(_g) {}
     542      ArcMap(const Graph& _g, const _Value& _v) 
     543        : Parent(_g, _v) {}
    546544
    547545      ArcMap& operator=(const ArcMap& cmap) {
    548         return operator=<ArcMap>(cmap);
     546        return operator=<ArcMap>(cmap);
    549547      }
    550548
    … …  
    552550      ArcMap& operator=(const CMap& cmap) {
    553551        Parent::operator=(cmap);
    554         return *this;
     552        return *this;
    555553      }
    556554
    … …  
    559557
    560558    template <typename _Value>
    561     class EdgeMap
     559    class EdgeMap 
    562560      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
    563561      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
    564562
    565563    public:
    566       explicit EdgeMap(const Graph& _g)
    567         : Parent(_g) {}
    568 
    569       EdgeMap(const Graph& _g, const _Value& _v)
    570         : Parent(_g, _v) {}
     564      EdgeMap(const Graph& _g)
     565        : Parent(_g) {}
     566
     567      EdgeMap(const Graph& _g, const _Value& _v) 
     568        : Parent(_g, _v) {}
    571569
    572570      EdgeMap& operator=(const EdgeMap& cmap) {
    573         return operator=<EdgeMap>(cmap);
     571        return operator=<EdgeMap>(cmap);
    574572      }
    575573
    … …  
    577575      EdgeMap& operator=(const CMap& cmap) {
    578576        Parent::operator=(cmap);
    579         return *this;
     577        return *this;
    580578      }
    581579
    … …  
    594592      return edge;
    595593    }
    596 
     594   
    597595    void clear() {
    598596      notifier(Arc()).clear();
    … …  
    620618      arc_notifier.clear();
    621619    }
    622 
     620   
    623621  };
    624622
Note: See TracChangeset for help on using the changeset viewer.