COIN-OR::LEMON - Graph Library

Changeset 78:c46b3453455f in lemon


Ignore:
Timestamp:
02/28/08 17:06:02 (10 years ago)
Author:
Balazs Dezso <deba@…>
Branch:
default
Children:
84:8161012eaa61, 92:5d4decd1b870
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.