COIN-OR::LEMON - Graph Library

Changeset 78:c46b3453455f in lemon


Ignore:
Timestamp:
02/28/08 17:06:02 (11 years ago)
Author:
Balazs Dezso <deba@…>
Branch:
default
Children:
84:8161012eaa61, 92:5d4decd1b870
Phase:
public
Message:

Renaming types and variables

Location:
lemon
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lemon/bits/graph_extender.h

    r77 r78  
    6565    }
    6666
    67     Node oppositeNode(const Node &n, const Arc &e) const {
    68       if (n == Parent::source(e))
    69         return Parent::target(e);
    70       else if(n==Parent::target(e))
    71         return Parent::source(e);
     67    Node oppositeNode(const Node &node, const Arc &arc) const {
     68      if (node == Parent::source(arc))
     69        return Parent::target(arc);
     70      else if(node == Parent::target(arc))
     71        return Parent::source(arc);
    7272      else
    7373        return INVALID;
     
    9696
    9797    class NodeIt : public Node {
    98       const Digraph* digraph;
     98      const Digraph* _digraph;
    9999    public:
    100100
     
    103103      NodeIt(Invalid i) : Node(i) { }
    104104
    105       explicit NodeIt(const Digraph& _digraph) : digraph(&_digraph) {
    106         _digraph.first(static_cast<Node&>(*this));
    107       }
    108 
    109       NodeIt(const Digraph& _digraph, const Node& node)
    110         : Node(node), digraph(&_digraph) {}
     105      explicit NodeIt(const Digraph& digraph) : _digraph(&digraph) {
     106        _digraph->first(static_cast<Node&>(*this));
     107      }
     108
     109      NodeIt(const Digraph& digraph, const Node& node)
     110        : Node(node), _digraph(&digraph) {}
    111111
    112112      NodeIt& operator++() {
    113         digraph->next(*this);
     113        _digraph->next(*this);
    114114        return *this;
    115115      }
     
    119119
    120120    class ArcIt : public Arc {
    121       const Digraph* digraph;
     121      const Digraph* _digraph;
    122122    public:
    123123
     
    126126      ArcIt(Invalid i) : Arc(i) { }
    127127
    128       explicit ArcIt(const Digraph& _digraph) : digraph(&_digraph) {
    129         _digraph.first(static_cast<Arc&>(*this));
    130       }
    131 
    132       ArcIt(const Digraph& _digraph, const Arc& e) :
    133         Arc(e), digraph(&_digraph) { }
     128      explicit ArcIt(const Digraph& digraph) : _digraph(&digraph) {
     129        _digraph->first(static_cast<Arc&>(*this));
     130      }
     131
     132      ArcIt(const Digraph& digraph, const Arc& arc) :
     133        Arc(arc), _digraph(&digraph) { }
    134134
    135135      ArcIt& operator++() {
    136         digraph->next(*this);
     136        _digraph->next(*this);
    137137        return *this;
    138138      }
     
    142142
    143143    class OutArcIt : public Arc {
    144       const Digraph* digraph;
     144      const Digraph* _digraph;
    145145    public:
    146146
     
    149149      OutArcIt(Invalid i) : Arc(i) { }
    150150
    151       OutArcIt(const Digraph& _digraph, const Node& node)
    152         : digraph(&_digraph) {
    153         _digraph.firstOut(*this, node);
    154       }
    155 
    156       OutArcIt(const Digraph& _digraph, const Arc& arc)
    157         : Arc(arc), digraph(&_digraph) {}
     151      OutArcIt(const Digraph& digraph, const Node& node)
     152        : _digraph(&digraph) {
     153        _digraph->firstOut(*this, node);
     154      }
     155
     156      OutArcIt(const Digraph& digraph, const Arc& arc)
     157        : Arc(arc), _digraph(&digraph) {}
    158158
    159159      OutArcIt& operator++() {
    160         digraph->nextOut(*this);
     160        _digraph->nextOut(*this);
    161161        return *this;
    162162      }
     
    166166
    167167    class InArcIt : public Arc {
    168       const Digraph* digraph;
     168      const Digraph* _digraph;
    169169    public:
    170170
     
    173173      InArcIt(Invalid i) : Arc(i) { }
    174174
    175       InArcIt(const Digraph& _digraph, const Node& node)
    176         : digraph(&_digraph) {
    177         _digraph.firstIn(*this, node);
    178       }
    179 
    180       InArcIt(const Digraph& _digraph, const Arc& arc) :
    181         Arc(arc), digraph(&_digraph) {}
     175      InArcIt(const Digraph& digraph, const Node& node)
     176        : _digraph(&digraph) {
     177        _digraph->firstIn(*this, node);
     178      }
     179
     180      InArcIt(const Digraph& digraph, const Arc& arc) :
     181        Arc(arc), _digraph(&digraph) {}
    182182
    183183      InArcIt& operator++() {
    184         digraph->nextIn(*this);
     184        _digraph->nextIn(*this);
    185185        return *this;
    186186      }
     
    191191    ///
    192192    /// Returns the base node (i.e. the source in this case) of the iterator
    193     Node baseNode(const OutArcIt &e) const {
    194       return Parent::source(e);
     193    Node baseNode(const OutArcIt &arc) const {
     194      return Parent::source(arc);
    195195    }
    196196    /// \brief Running node of the iterator
     
    198198    /// Returns the running node (i.e. the target in this case) of the
    199199    /// iterator
    200     Node runningNode(const OutArcIt &e) const {
    201       return Parent::target(e);
     200    Node runningNode(const OutArcIt &arc) const {
     201      return Parent::target(arc);
    202202    }
    203203
     
    205205    ///
    206206    /// Returns the base node (i.e. the target in this case) of the iterator
    207     Node baseNode(const InArcIt &e) const {
    208       return Parent::target(e);
     207    Node baseNode(const InArcIt &arc) const {
     208      return Parent::target(arc);
    209209    }
    210210    /// \brief Running node of the iterator
     
    212212    /// Returns the running node (i.e. the source in this case) of the
    213213    /// iterator
    214     Node runningNode(const InArcIt &e) const {
    215       return Parent::source(e);
     214    Node runningNode(const InArcIt &arc) const {
     215      return Parent::source(arc);
    216216    }
    217217
     
    325325  };
    326326
    327   /// \ingroup graphbits
     327  /// \ingroup _graphbits
    328328  ///
    329329  /// \brief Extender for the Graphs
     
    333333   
    334334    typedef Base Parent;
    335     typedef GraphExtender Digraph;
     335    typedef GraphExtender Graph;
    336336
    337337    typedef True UndirectedTag;
     
    376376    }
    377377
    378     Arc oppositeArc(const Arc &e) const {
    379       return Parent::direct(e, !Parent::direction(e));
     378    Arc oppositeArc(const Arc &arc) const {
     379      return Parent::direct(arc, !Parent::direction(arc));
    380380    }
    381381
    382382    using Parent::direct;
    383     Arc direct(const Edge &ue, const Node &s) const {
    384       return Parent::direct(ue, Parent::source(ue) == s);
     383    Arc direct(const Edge &edge, const Node &node) const {
     384      return Parent::direct(edge, Parent::source(edge) == node);
    385385    }
    386386
     
    415415
    416416    class NodeIt : public Node {
    417       const Digraph* digraph;
     417      const Graph* _graph;
    418418    public:
    419419
     
    422422      NodeIt(Invalid i) : Node(i) { }
    423423
    424       explicit NodeIt(const Digraph& _digraph) : digraph(&_digraph) {
    425         _digraph.first(static_cast<Node&>(*this));
    426       }
    427 
    428       NodeIt(const Digraph& _digraph, const Node& node)
    429         : Node(node), digraph(&_digraph) {}
     424      explicit NodeIt(const Graph& graph) : _graph(&graph) {
     425        _graph->first(static_cast<Node&>(*this));
     426      }
     427
     428      NodeIt(const Graph& graph, const Node& node)
     429        : Node(node), _graph(&graph) {}
    430430
    431431      NodeIt& operator++() {
    432         digraph->next(*this);
     432        _graph->next(*this);
    433433        return *this;
    434434      }
     
    438438
    439439    class ArcIt : public Arc {
    440       const Digraph* digraph;
     440      const Graph* _graph;
    441441    public:
    442442
     
    445445      ArcIt(Invalid i) : Arc(i) { }
    446446
    447       explicit ArcIt(const Digraph& _digraph) : digraph(&_digraph) {
    448         _digraph.first(static_cast<Arc&>(*this));
    449       }
    450 
    451       ArcIt(const Digraph& _digraph, const Arc& e) :
    452         Arc(e), digraph(&_digraph) { }
     447      explicit ArcIt(const Graph& graph) : _graph(&graph) {
     448        _graph->first(static_cast<Arc&>(*this));
     449      }
     450
     451      ArcIt(const Graph& graph, const Arc& arc) :
     452        Arc(arc), _graph(&graph) { }
    453453
    454454      ArcIt& operator++() {
    455         digraph->next(*this);
     455        _graph->next(*this);
    456456        return *this;
    457457      }
     
    461461
    462462    class OutArcIt : public Arc {
    463       const Digraph* digraph;
     463      const Graph* _graph;
    464464    public:
    465465
     
    468468      OutArcIt(Invalid i) : Arc(i) { }
    469469
    470       OutArcIt(const Digraph& _digraph, const Node& node)
    471         : digraph(&_digraph) {
    472         _digraph.firstOut(*this, node);
    473       }
    474 
    475       OutArcIt(const Digraph& _digraph, const Arc& arc)
    476         : Arc(arc), digraph(&_digraph) {}
     470      OutArcIt(const Graph& graph, const Node& node)
     471        : _graph(&graph) {
     472        _graph->firstOut(*this, node);
     473      }
     474
     475      OutArcIt(const Graph& graph, const Arc& arc)
     476        : Arc(arc), _graph(&graph) {}
    477477
    478478      OutArcIt& operator++() {
    479         digraph->nextOut(*this);
     479        _graph->nextOut(*this);
    480480        return *this;
    481481      }
     
    485485
    486486    class InArcIt : public Arc {
    487       const Digraph* digraph;
     487      const Graph* _graph;
    488488    public:
    489489
     
    492492      InArcIt(Invalid i) : Arc(i) { }
    493493
    494       InArcIt(const Digraph& _digraph, const Node& node)
    495         : digraph(&_digraph) {
    496         _digraph.firstIn(*this, node);
    497       }
    498 
    499       InArcIt(const Digraph& _digraph, const Arc& arc) :
    500         Arc(arc), digraph(&_digraph) {}
     494      InArcIt(const Graph& graph, const Node& node)
     495        : _graph(&graph) {
     496        _graph->firstIn(*this, node);
     497      }
     498
     499      InArcIt(const Graph& graph, const Arc& arc) :
     500        Arc(arc), _graph(&graph) {}
    501501
    502502      InArcIt& operator++() {
    503         digraph->nextIn(*this);
     503        _graph->nextIn(*this);
    504504        return *this;
    505505      }
     
    509509
    510510    class EdgeIt : public Parent::Edge {
    511       const Digraph* digraph;
     511      const Graph* _graph;
    512512    public:
    513513
     
    516516      EdgeIt(Invalid i) : Edge(i) { }
    517517
    518       explicit EdgeIt(const Digraph& _digraph) : digraph(&_digraph) {
    519         _digraph.first(static_cast<Edge&>(*this));
    520       }
    521 
    522       EdgeIt(const Digraph& _digraph, const Edge& e) :
    523         Edge(e), digraph(&_digraph) { }
     518      explicit EdgeIt(const Graph& graph) : _graph(&graph) {
     519        _graph->first(static_cast<Edge&>(*this));
     520      }
     521
     522      EdgeIt(const Graph& graph, const Edge& edge) :
     523        Edge(edge), _graph(&graph) { }
    524524
    525525      EdgeIt& operator++() {
    526         digraph->next(*this);
    527         return *this;
    528       }
    529 
    530     };
    531 
    532     class IncArcIt : public Parent::Edge {
     526        _graph->next(*this);
     527        return *this;
     528      }
     529
     530    };
     531
     532    class IncEdgeIt : public Parent::Edge {
    533533      friend class GraphExtender;
    534       const Digraph* digraph;
    535       bool direction;
    536     public:
    537 
    538       IncArcIt() { }
    539 
    540       IncArcIt(Invalid i) : Edge(i), direction(false) { }
    541 
    542       IncArcIt(const Digraph& _digraph, const Node &n) : digraph(&_digraph) {
    543         _digraph.firstInc(*this, direction, n);
    544       }
    545 
    546       IncArcIt(const Digraph& _digraph, const Edge &ue, const Node &n)
    547         : digraph(&_digraph), Edge(ue) {
    548         direction = (_digraph.source(ue) == n);
    549       }
    550 
    551       IncArcIt& operator++() {
    552         digraph->nextInc(*this, direction);
     534      const Graph* _graph;
     535      bool _direction;
     536    public:
     537
     538      IncEdgeIt() { }
     539
     540      IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
     541
     542      IncEdgeIt(const Graph& graph, const Node &node) : _graph(&graph) {
     543        _graph->firstInc(*this, _direction, node);
     544      }
     545
     546      IncEdgeIt(const Graph& graph, const Edge &edge, const Node &node)
     547        : _graph(&graph), Edge(edge) {
     548        _direction = (_graph->source(edge) == node);
     549      }
     550
     551      IncEdgeIt& operator++() {
     552        _graph->nextInc(*this, _direction);
    553553        return *this;
    554554      }
     
    558558    ///
    559559    /// Returns the base node (ie. the source in this case) of the iterator
    560     Node baseNode(const OutArcIt &e) const {
    561       return Parent::source(static_cast<const Arc&>(e));
     560    Node baseNode(const OutArcIt &arc) const {
     561      return Parent::source(static_cast<const Arc&>(arc));
    562562    }
    563563    /// \brief Running node of the iterator
     
    565565    /// Returns the running node (ie. the target in this case) of the
    566566    /// iterator
    567     Node runningNode(const OutArcIt &e) const {
    568       return Parent::target(static_cast<const Arc&>(e));
     567    Node runningNode(const OutArcIt &arc) const {
     568      return Parent::target(static_cast<const Arc&>(arc));
    569569    }
    570570
     
    572572    ///
    573573    /// Returns the base node (ie. the target in this case) of the iterator
    574     Node baseNode(const InArcIt &e) const {
    575       return Parent::target(static_cast<const Arc&>(e));
     574    Node baseNode(const InArcIt &arc) const {
     575      return Parent::target(static_cast<const Arc&>(arc));
    576576    }
    577577    /// \brief Running node of the iterator
     
    579579    /// Returns the running node (ie. the source in this case) of the
    580580    /// iterator
    581     Node runningNode(const InArcIt &e) const {
    582       return Parent::source(static_cast<const Arc&>(e));
     581    Node runningNode(const InArcIt &arc) const {
     582      return Parent::source(static_cast<const Arc&>(arc));
    583583    }
    584584
     
    586586    ///
    587587    /// Returns the base node of the iterator
    588     Node baseNode(const IncArcIt &e) const {
    589       return e.direction ? source(e) : target(e);
     588    Node baseNode(const IncEdgeIt &edge) const {
     589      return edge._direction ? source(edge) : target(edge);
    590590    }
    591591    /// Running node of the iterator
    592592    ///
    593593    /// Returns the running node of the iterator
    594     Node runningNode(const IncArcIt &e) const {
    595       return e.direction ? target(e) : source(e);
     594    Node runningNode(const IncEdgeIt &edge) const {
     595      return edge._direction ? target(edge) : source(edge);
    596596    }
    597597
     
    600600    template <typename _Value>
    601601    class NodeMap
    602       : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
    603     public:
    604       typedef GraphExtender Digraph;
    605       typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
    606 
    607       NodeMap(const Digraph& digraph)
    608         : Parent(digraph) {}
    609       NodeMap(const Digraph& digraph, const _Value& value)
    610         : Parent(digraph, value) {}
     602      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
     603    public:
     604      typedef GraphExtender Graph;
     605      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
     606
     607      NodeMap(const Graph& graph)
     608        : Parent(graph) {}
     609      NodeMap(const Graph& graph, const _Value& value)
     610        : Parent(graph, value) {}
    611611
    612612      NodeMap& operator=(const NodeMap& cmap) {
     
    624624    template <typename _Value>
    625625    class ArcMap
    626       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
    627     public:
    628       typedef GraphExtender Digraph;
    629       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
    630 
    631       ArcMap(const Digraph& digraph)
    632         : Parent(digraph) {}
    633       ArcMap(const Digraph& digraph, const _Value& value)
    634         : Parent(digraph, value) {}
     626      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
     627    public:
     628      typedef GraphExtender Graph;
     629      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
     630
     631      ArcMap(const Graph& graph)
     632        : Parent(graph) {}
     633      ArcMap(const Graph& graph, const _Value& value)
     634        : Parent(graph, value) {}
    635635
    636636      ArcMap& operator=(const ArcMap& cmap) {
     
    648648    template <typename _Value>
    649649    class EdgeMap
    650       : public MapExtender<DefaultMap<Digraph, Edge, _Value> > {
    651     public:
    652       typedef GraphExtender Digraph;
    653       typedef MapExtender<DefaultMap<Digraph, Edge, _Value> > Parent;
    654 
    655       EdgeMap(const Digraph& digraph)
    656         : Parent(digraph) {}
    657 
    658       EdgeMap(const Digraph& digraph, const _Value& value)
    659         : Parent(digraph, value) {}
     650      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
     651    public:
     652      typedef GraphExtender Graph;
     653      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     654
     655      EdgeMap(const Graph& graph)
     656        : Parent(graph) {}
     657
     658      EdgeMap(const Graph& graph, const _Value& value)
     659        : Parent(graph, value) {}
    660660
    661661      EdgeMap& operator=(const EdgeMap& cmap) {
     
    696696    }
    697697
    698     template <typename Digraph, typename NodeRefMap, typename EdgeRefMap>
    699     void build(const Digraph& digraph, NodeRefMap& nodeRef,
     698    template <typename Graph, typename NodeRefMap, typename EdgeRefMap>
     699    void build(const Graph& graph, NodeRefMap& nodeRef,
    700700               EdgeRefMap& edgeRef) {
    701       Parent::build(digraph, nodeRef, edgeRef);
     701      Parent::build(graph, nodeRef, edgeRef);
    702702      notifier(Node()).build();
    703703      notifier(Edge()).build();
     
    724724
    725725    void erase(const Edge& edge) {
    726       std::vector<Arc> ev;
    727       ev.push_back(Parent::direct(edge, true));
    728       ev.push_back(Parent::direct(edge, false));     
    729       notifier(Arc()).erase(ev);
     726      std::vector<Arc> av;
     727      av.push_back(Parent::direct(edge, true));
     728      av.push_back(Parent::direct(edge, false));     
     729      notifier(Arc()).erase(av);
    730730      notifier(Edge()).erase(edge);
    731731      Parent::erase(edge);
  • lemon/concepts/graph.h

    r61 r78  
    6464    /// the EdgeMap to map values for the edges. The InArcIt and
    6565    /// OutArcIt iterates on the same edges but with opposite
    66     /// direction. The IncArcIt iterates also on the same edges
     66    /// direction. The IncEdgeIt iterates also on the same edges
    6767    /// as the OutArcIt and InArcIt but it is not convertible to Arc just
    6868    /// to Edge. 
     
    271271      ///\code
    272272      /// int count=0;
    273       /// for(Graph::IncArcIt e(g, n); e!=INVALID; ++e) ++count;
     273      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    274274      ///\endcode
    275       class IncArcIt : public Edge {
    276       public:
    277         /// Default constructor
    278 
    279         /// @warning The default constructor sets the iterator
    280         /// to an undefined value.
    281         IncArcIt() { }
    282         /// Copy constructor.
    283 
    284         /// Copy constructor.
    285         ///
    286         IncArcIt(const IncArcIt& e) : Edge(e) { }
    287         /// Initialize the iterator to be invalid.
    288 
    289         /// Initialize the iterator to be invalid.
    290         ///
    291         IncArcIt(Invalid) { }
     275      class IncEdgeIt : public Edge {
     276      public:
     277        /// Default constructor
     278
     279        /// @warning The default constructor sets the iterator
     280        /// to an undefined value.
     281        IncEdgeIt() { }
     282        /// Copy constructor.
     283
     284        /// Copy constructor.
     285        ///
     286        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
     287        /// Initialize the iterator to be invalid.
     288
     289        /// Initialize the iterator to be invalid.
     290        ///
     291        IncEdgeIt(Invalid) { }
    292292        /// This constructor sets the iterator to first incident arc.
    293293   
    294294        /// This constructor set the iterator to the first incident arc of
    295295        /// the node.
    296         IncArcIt(const Graph&, const Node&) { }
    297         /// Edge -> IncArcIt conversion
     296        IncEdgeIt(const Graph&, const Node&) { }
     297        /// Edge -> IncEdgeIt conversion
    298298
    299299        /// Sets the iterator to the value of the trivial iterator \c e.
    300300        /// This feature necessitates that each time we
    301301        /// iterate the arc-set, the iteration order is the same.
    302         IncArcIt(const Graph&, const Edge&) { }
     302        IncEdgeIt(const Graph&, const Edge&) { }
    303303        /// Next incident arc
    304304
    305305        /// Assign the iterator to the next incident arc
    306306        /// of the corresponding node.
    307         IncArcIt& operator++() { return *this; }
     307        IncEdgeIt& operator++() { return *this; }
    308308      };
    309309
     
    721721      ///
    722722      /// Returns the base node of the iterator
    723       Node baseNode(IncArcIt) const {
     723      Node baseNode(IncEdgeIt) const {
    724724        return INVALID;
    725725      }
     
    728728      ///
    729729      /// Returns the running node of the iterator
    730       Node runningNode(IncArcIt) const {
     730      Node runningNode(IncEdgeIt) const {
    731731        return INVALID;
    732732      }
  • lemon/concepts/graph_components.h

    r57 r78  
    829829      /// This iterator goes trough the incident arcs of a certain
    830830      /// node of a graph.
    831       typedef GraphIncIt<Graph, Edge, Node, 'u'> IncArcIt;
     831      typedef GraphIncIt<Graph, Edge, Node, 'u'> IncEdgeIt;
    832832      /// \brief The base node of the iterator.
    833833      ///
    834834      /// Gives back the base node of the iterator.
    835       Node baseNode(const IncArcIt&) const { return INVALID; }
     835      Node baseNode(const IncEdgeIt&) const { return INVALID; }
    836836
    837837      /// \brief The running node of the iterator.
    838838      ///
    839839      /// Gives back the running node of the iterator.
    840       Node runningNode(const IncArcIt&) const { return INVALID; }
     840      Node runningNode(const IncEdgeIt&) const { return INVALID; }
    841841
    842842      /// @}
     
    866866              typename _Graph::EdgeIt >();
    867867            checkConcept<GraphIncIt<_Graph, typename _Graph::Edge,
    868               typename _Graph::Node, 'u'>, typename _Graph::IncArcIt>();
     868              typename _Graph::Node, 'u'>, typename _Graph::IncEdgeIt>();
    869869           
    870870            typename _Graph::Node n;
    871             typename _Graph::IncArcIt ueit(INVALID);
     871            typename _Graph::IncEdgeIt ueit(INVALID);
    872872            n = graph.baseNode(ueit);
    873873            n = graph.runningNode(ueit);
Note: See TracChangeset for help on using the changeset viewer.