37 #ifndef VIGRA_ADJACENCY_LIST_GRAPH_HXX
38 #define VIGRA_ADJACENCY_LIST_GRAPH_HXX
45 #include "multi_array.hxx"
46 #include "multi_gridgraph.hxx"
48 #include "tinyvector.hxx"
49 #include "random_access_set.hxx"
50 #include "graph_maps.hxx"
51 #include "iteratorfacade.hxx"
53 #include "algorithm.hxx"
54 #include "graph_item_impl.hxx"
63 namespace detail_adjacency_list_graph{
65 template<
class G,
class ITEM>
67 :
public ForwardIteratorFacade<
68 ItemIter<G,ITEM>,ITEM,true
72 typedef vigra::GraphItemHelper<G,ITEM> ItemHelper;
73 typedef typename G::index_type index_type;
76 ItemIter(
const lemon::Invalid & = lemon::INVALID)
86 item_(ItemHelper::itemFromId(*graph_,id_))
88 while( !isEnd() && item_==lemon::INVALID ){
90 item_ = ItemHelper::itemFromId(*graph_,id_);
94 ItemIter(
const G & g,
const ITEM & item)
104 friend class vigra::IteratorFacadeCoreAccess;
106 return graph_==NULL || ItemHelper::itemNum(*graph_)==0 || id_>ItemHelper::maxItemId(*graph_);
108 bool isBegin( )
const{
109 return graph_!=NULL && id_ == 0 ;
112 bool equal(
const ItemIter & other)
const{
113 return (isEnd() && other.isEnd() ) || (isEnd()==other.isEnd() && (id_ == other.id_) );
118 item_ = ItemHelper::itemFromId(*graph_,id_);
119 while( !isEnd() && item_==lemon::INVALID ){
121 item_ = ItemHelper::itemFromId(*graph_,id_);
124 const ITEM & dereference()
const{
134 template<
class GRAPH>
136 :
public ForwardIteratorFacade<
138 typename GRAPH::Arc,true
143 typedef typename Graph::Arc Arc;
144 typedef typename Graph::Edge Edge;
145 typedef typename Graph::EdgeIt EdgeIt;
146 ArcIt(
const lemon::Invalid = lemon::INVALID )
153 ArcIt(
const GRAPH & g )
157 veryEnd_( g.edgeNum()==0 ? true : false),
161 ArcIt(
const GRAPH & g ,
const Arc & arc )
163 pos_(g,arc.edgeId()),
164 inFirstHalf_(g.id(arc)<=g.maxEdgeId()),
169 friend class vigra::IteratorFacadeCoreAccess;
171 return veryEnd_ || graph_==NULL;
175 return graph_!=NULL && veryEnd_==
false && pos_ == EdgeIt(*graph_);
180 if(pos_ == lemon::INVALID ) {
181 pos_ = EdgeIt(*graph_);
188 if(pos_ == lemon::INVALID){
196 bool equal(ArcIt
const& other)
const{
199 isEnd()==other.isEnd() &&
200 inFirstHalf_==other.inFirstHalf_
202 (isEnd() || graph_==NULL || pos_==other.pos_ )
207 const Arc & dereference()
const {
209 arc_ = graph_->direct(*pos_,inFirstHalf_);
214 const GRAPH * graph_;
232 typedef Int64 index_type;
236 typedef detail::GenericNodeImpl<index_type,false> NodeStorage;
237 typedef detail::GenericEdgeImpl<index_type > EdgeStorage;
238 typedef detail::NeighborNodeFilter<GraphType> NnFilter;
239 typedef detail::IncEdgeFilter<GraphType> IncFilter;
240 typedef detail::IsInFilter<GraphType> InFlter;
241 typedef detail::IsOutFilter<GraphType> OutFilter;
242 typedef detail::IsBackOutFilter<GraphType> BackOutFilter;
247 typedef detail::GenericNode<index_type>
Node;
249 typedef detail::GenericEdge<index_type>
Edge;
251 typedef detail::GenericArc<index_type>
Arc;
253 typedef detail_adjacency_list_graph::ItemIter<GraphType,Edge>
EdgeIt;
255 typedef detail_adjacency_list_graph::ItemIter<GraphType,Node>
NodeIt;
257 typedef detail_adjacency_list_graph::ArcIt<GraphType>
ArcIt;
260 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,IncFilter >
IncEdgeIt;
262 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,InFlter >
InArcIt;
264 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,OutFilter >
OutArcIt;
266 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,NnFilter > NeighborNodeIt;
270 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,BackOutFilter >
OutBackArcIt;
275 typedef directed_tag directed_category;
277 typedef NeighborNodeIt adjacency_iterator;
278 typedef EdgeIt edge_iterator;
279 typedef NodeIt vertex_iterator;
284 typedef size_t degree_size_type;
285 typedef size_t edge_size_type;
286 typedef size_t vertex_size_type;
288 typedef Edge edge_descriptor;
289 typedef Node vertex_descriptor;
294 struct EdgeMap : DenseEdgeReferenceMap<GraphType,T> {
295 EdgeMap(): DenseEdgeReferenceMap<GraphType,T>(){
298 : DenseEdgeReferenceMap<GraphType,T>(g){
301 : DenseEdgeReferenceMap<GraphType,T>(g,val){
307 struct NodeMap : DenseNodeReferenceMap<GraphType,T> {
308 NodeMap(): DenseNodeReferenceMap<GraphType,T>(){
311 : DenseNodeReferenceMap<GraphType,T>(g){
314 : DenseNodeReferenceMap<GraphType,T>(g,val){
320 struct ArcMap : DenseArcReferenceMap<GraphType,T> {
321 ArcMap(): DenseArcReferenceMap<GraphType,T>(){
324 : DenseArcReferenceMap<GraphType,T>(g){
327 : DenseArcReferenceMap<GraphType,T>(g,val){
416 index_type
id(
const Node & node)
const;
422 index_type
id(
const Arc & arc )
const;
454 Node addNode(
const index_type
id);
460 void assignNodeRange(
const index_type beginId,
const index_type endId);
472 Edge addEdge(
const index_type
u ,
const index_type
v);
475 size_t maxDegree()
const{
477 for(
NodeIt it(*
this);it!=lemon::INVALID;++it){
478 std::max(md,
size_t( degree(*it) ) );
489 vertex_iterator get_vertex_iterator()
const;
490 vertex_iterator get_vertex_end_iterator()
const ;
491 edge_iterator get_edge_iterator()
const;
492 edge_iterator get_edge_end_iterator()
const ;
493 degree_size_type degree(
const vertex_descriptor & node)
const{
494 return nodeImpl(node).numberOfEdges();
497 static const bool is_directed =
false;
501 void reserveMaxNodeId(
const index_type mxid ){
503 nodes_.reserve(mxid+1);
506 void reserveEdges(
const size_t size ){
508 edges_.reserve(size);
518 size_t serializationSize()
const{
528 for(
NodeIt iter(*
this); iter!= lemon::INVALID ; ++iter){
529 size+= 2+this->degree(*iter)*2;
536 void serialize(ITER outIter)
const {
539 *outIter =
nodeNum(); ++outIter;
540 *outIter =
edgeNum(); ++outIter;
545 for(
EdgeIt iter(*
this); iter!=lemon::INVALID; ++iter){
547 const size_t ui = this->
id(this->
u(e));
548 const size_t vi = this->
id(this->
v(e));
549 *outIter = ui; ++outIter;
550 *outIter = vi; ++outIter;
556 for(
NodeIt iter(*
this); iter!= lemon::INVALID ; ++iter){
559 *outIter = this->
id(*iter); ++outIter;
560 *outIter = this->degree(*iter); ++outIter;
562 for(
OutArcIt eIter(*
this,n); eIter!=lemon::INVALID; ++eIter){
563 const Edge e(*eIter);
566 const size_t ei = this->
id(e);
567 const size_t oni = this->
id(oNode);
569 *outIter = ei; ++outIter;
570 *outIter = oni; ++outIter;
577 void deserialize(ITER begin, ITER){
580 nodeNum_ = *begin; ++begin;
581 edgeNum_ = *begin; ++begin;
582 const size_t maxNid = *begin; ++begin;
583 const size_t maxEid = *begin; ++begin;
587 nodes_.resize(maxNid+1, NodeStorage());
588 edges_.resize(maxEid+1, EdgeStorage());
591 for(
size_t eid=0; eid<edgeNum_; ++eid){
592 const size_t u = *begin; ++begin;
593 const size_t v = *begin; ++begin;
596 edges_[eid]=EdgeStorage(u,v,eid);
600 for(
size_t i=0; i<nodeNum_; ++i){
602 const size_t id = *begin; ++begin;
603 const size_t nodeDegree=*begin; ++begin;
605 NodeStorage & nodeImpl = nodes_[
id];
607 for(
size_t d=0; d<nodeDegree; ++d){
608 const size_t ei = *begin; ++begin;
609 const size_t oni = *begin; ++begin;
610 nodeImpl.insert(oni, ei);
617 typedef std::vector<NodeStorage> NodeVector;
618 typedef std::vector<EdgeStorage> EdgeVector;
622 template<
class G,
class NIMPL,
class FILT>
623 friend class detail::GenericIncEdgeIt;
626 friend struct detail::NeighborNodeFilter;
628 friend struct detail::IncEdgeFilter;
630 friend struct detail::BackEdgeFilter;
632 friend struct detail::IsOutFilter;
634 friend struct detail::IsBackOutFilter;
636 friend struct detail::IsInFilter;
639 friend class detail_adjacency_list_graph::ItemIter<GraphType,
Node>;
640 friend class detail_adjacency_list_graph::ItemIter<GraphType,
Edge>;
643 const NodeStorage & nodeImpl(
const Node & node)
const{
644 return nodes_[node.id()];
647 NodeStorage & nodeImpl(
const Node & node){
648 return nodes_[node.id()];
665 #ifndef DOXYGEN // doxygen doesn't like out-of-line definitions
668 const size_t reserveNodes,
669 const size_t reserveEdges
676 nodes_.reserve(reserveNodes);
677 edges_.reserve(reserveEdges);
682 AdjacencyListGraph::addNode(){
683 const index_type
id = nodes_.size();
684 nodes_.push_back(NodeStorage(
id));
690 AdjacencyListGraph::addNode(
const AdjacencyListGraph::index_type
id){
691 if((std::size_t)
id == nodes_.size()){
692 nodes_.push_back(NodeStorage(
id));
696 else if((std::size_t)
id < nodes_.size()){
698 if(node==lemon::INVALID){
699 nodes_[
id]=NodeStorage(
id);
709 while(nodes_.size() < (std::size_t)
id){
710 nodes_.push_back(NodeStorage(lemon::INVALID));
712 nodes_.push_back(NodeStorage(
id));
720 AdjacencyListGraph::assignNodeRange(
const AdjacencyListGraph::index_type beginId,
const AdjacencyListGraph::index_type endId){
724 nodeNum_ = endId - beginId;
725 nodes_.resize(endId);
726 for(index_type i=beginId; i<endId; ++i)
727 nodes_[i]=NodeStorage(i);
733 AdjacencyListGraph::addEdge(
738 if(foundEdge!=lemon::INVALID){
741 else if(u==lemon::INVALID || v==lemon::INVALID){
742 return Edge(lemon::INVALID);
745 const index_type eid = edges_.size();
746 const index_type uid = u.id();
747 const index_type vid = v.id();
748 edges_.push_back(EdgeStorage(uid,vid,eid));
749 nodeImpl(u).insert(vid,eid);
750 nodeImpl(v).insert(uid,eid);
757 AdjacencyListGraph::addEdge(
758 const AdjacencyListGraph::index_type u ,
759 const AdjacencyListGraph::index_type v
761 const Node uu = addNode(u);
762 const Node vv = addNode(v);
763 return addEdge(uu,vv);
773 if(edge!=lemon::INVALID){
775 return Arc(
id(edge),
id(edge));
780 return Arc(lemon::INVALID);
790 return Arc(
id(edge),
id(edge));
792 else if(
v(edge)==node){
796 return Arc(lemon::INVALID);
813 return Node(edges_[
id(edge)].
u());
821 return Node(edges_[
id(edge)].
v());
830 const index_type arcIndex =
id(arc);
832 const index_type edgeIndex = arc.edgeId();
837 const index_type edgeIndex = arcIndex;
849 const index_type arcIndex =
id(arc);
851 const index_type edgeIndex = arc.edgeId();
856 const index_type edgeIndex = arcIndex;
867 const Node uNode =
u(e);
868 const Node vNode =
v(e);
869 if(
id(uNode)==
id(n)){
872 else if(
id(vNode)==
id(n)){
915 inline AdjacencyListGraph::index_type
921 inline AdjacencyListGraph::index_type
927 inline AdjacencyListGraph::index_type
933 inline AdjacencyListGraph::index_type
935 return edges_.back().id();
939 inline AdjacencyListGraph::index_type
941 return nodes_.back().id();
945 inline AdjacencyListGraph::index_type
952 inline AdjacencyListGraph::index_type
960 inline AdjacencyListGraph::index_type
968 inline AdjacencyListGraph::index_type
979 const AdjacencyListGraph::index_type
id
981 if((std::size_t)
id < edges_.size() && edges_[
id].id() != -1)
982 return Edge(edges_[
id].
id());
984 return Edge(lemon::INVALID);
990 const AdjacencyListGraph::index_type
id
992 if((std::size_t)
id < nodes_.size() && nodes_[
id].id() != -1)
993 return Node(nodes_[
id].
id());
995 return Node(lemon::INVALID);
1001 const AdjacencyListGraph::index_type
id
1005 return Arc(lemon::INVALID);
1010 const index_type edgeId =
id - (
maxEdgeId() + 1);
1012 return Arc(lemon::INVALID);
1014 return Arc(
id,edgeId);
1025 std::pair<index_type,bool> res = nodes_[
id(a)].findEdge(
id(b));
1027 return Edge(res.first);
1030 return Edge(lemon::INVALID);
1041 if(e==lemon::INVALID){
1042 return Arc(lemon::INVALID);
1055 inline AdjacencyListGraph::vertex_iterator
1056 AdjacencyListGraph::get_vertex_iterator()
const{
1061 inline AdjacencyListGraph::vertex_iterator
1062 AdjacencyListGraph::get_vertex_end_iterator()
const{
1068 inline AdjacencyListGraph::edge_iterator
1069 AdjacencyListGraph::get_edge_iterator()
const{
1074 inline AdjacencyListGraph::edge_iterator
1075 AdjacencyListGraph::get_edge_end_iterator()
const{
1092 inline vigra::AdjacencyListGraph::vertex_size_type
1096 inline vigra::AdjacencyListGraph::edge_size_type
1106 inline vigra::AdjacencyListGraph::degree_size_type
1111 inline vigra::AdjacencyListGraph::degree_size_type
1116 inline vigra::AdjacencyListGraph::degree_size_type
1125 inline vigra::AdjacencyListGraph::vertex_descriptor
1130 inline vigra::AdjacencyListGraph::vertex_descriptor
1138 inline std::pair< vigra::AdjacencyListGraph::vertex_iterator, vigra::AdjacencyListGraph::vertex_iterator >
1140 return std::pair< vigra::AdjacencyListGraph::vertex_iterator, vigra::AdjacencyListGraph::vertex_iterator >(
1141 g.get_vertex_iterator(), g.get_vertex_end_iterator());
1143 inline std::pair< vigra::AdjacencyListGraph::edge_iterator, vigra::AdjacencyListGraph::edge_iterator >
1145 return std::pair< vigra::AdjacencyListGraph::edge_iterator, vigra::AdjacencyListGraph::edge_iterator >(
1146 g.get_edge_iterator(),g.get_edge_end_iterator());
1150 inline std::pair< vigra::AdjacencyListGraph::in_edge_iterator, vigra::AdjacencyListGraph::in_edge_iterator >
1152 return std::pair< vigra::AdjacencyListGraph::in_edge_iterator, vigra::AdjacencyListGraph::in_edge_iterator >(
1153 vigra::AdjacencyListGraph::in_edge_iterator(g,v),vigra::AdjacencyListGraph::in_edge_iterator(lemon::INVALID)
1156 inline std::pair< vigra::AdjacencyListGraph::out_edge_iterator, vigra::AdjacencyListGraph::out_edge_iterator >
1158 return std::pair< vigra::AdjacencyListGraph::out_edge_iterator, vigra::AdjacencyListGraph::out_edge_iterator >(
1159 vigra::AdjacencyListGraph::out_edge_iterator(g,v),vigra::AdjacencyListGraph::out_edge_iterator(lemon::INVALID)
vigra::GridGraph< N, DirectedTag >::degree_size_type degree(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return total number of edges (incoming and outgoing) of vertex v (API: boost).
Definition: multi_gridgraph.hxx:2828
vigra::GridGraph< N, DirectedTag >::edges_size_type num_edges(vigra::GridGraph< N, DirectedTag > const &g)
Return the number of edges in graph g (API: boost).
Definition: multi_gridgraph.hxx:2976
Edge edgeFromId(const index_type id) const
Get edge descriptor for given node ID i (API: LEMON). Return Edge(lemon::INVALID) when the ID does no...
default node map
Definition: adjacency_list_graph.hxx:307
vigra::GridGraph< N, DirectedTag >::vertex_descriptor target(typename vigra::GridGraph< N, DirectedTag >::edge_descriptor const &e, vigra::GridGraph< N, DirectedTag > const &g)
Get a vertex descriptor for the end vertex of edge e in graph g (API: boost).
Definition: multi_gridgraph.hxx:2954
vigra::GridGraph< N, DirectedTag >::degree_size_type out_degree(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return number of outgoing edges of vertex v (API: boost).
Definition: multi_gridgraph.hxx:2806
index_type id(const Node &node) const
Get the ID for node desciptor v (API: LEMON).
Node nodeFromId(const index_type id) const
Get node descriptor for given node ID i (API: LEMON). Return Node(lemon::INVALID) when the ID does no...
detail::GenericIncEdgeIt< GraphType, NodeStorage, OutFilter > OutArcIt
outgoing arc iterator
Definition: adjacency_list_graph.hxx:264
detail::GenericEdge< index_type > Edge
edge descriptor
Definition: adjacency_list_graph.hxx:249
index_type maxEdgeId() const
Get the maximum ID of any edge in this graph (API: LEMON).
detail::GenericArc< index_type > Arc
arc descriptor
Definition: adjacency_list_graph.hxx:251
default arc map
Definition: adjacency_list_graph.hxx:320
vigra::GridGraph< N, DirectedTag >::degree_size_type in_degree(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return number of incoming edges of vertex v (API: boost).
Definition: multi_gridgraph.hxx:2817
std::pair< typename vigra::GridGraph< N, DirectedTag >::out_edge_iterator, typename vigra::GridGraph< N, DirectedTag >::out_edge_iterator > out_edges(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the outgoing edges of vertex v in graph g (API: boost)...
Definition: multi_gridgraph.hxx:2903
index_type maxNodeId() const
Get the maximum ID of any node in this graph (API: LEMON).
undirected adjacency list graph in the LEMON API
Definition: adjacency_list_graph.hxx:227
Arc direct(const Edge &edge, const bool forward) const
Create an arc for the given edge e, oriented along the edge's natural (forward = true) or reversed (f...
Node oppositeNode(Node const &n, const Edge &e) const
Return the opposite node of the given node n along edge e (API: LEMON), or return lemon::INVALID if t...
detail::SelectIntegerType< 64, detail::SignedIntTypes >::type Int64
64-bit signed int
Definition: sized_int.hxx:177
default edge map
Definition: adjacency_list_graph.hxx:294
index_type maxArcId() const
Get the maximum ID of any edge in arc graph (API: LEMON).
detail_adjacency_list_graph::ItemIter< GraphType, Node > NodeIt
node iterator
Definition: adjacency_list_graph.hxx:255
AdjacencyListGraph(const size_t nodes=0, const size_t edges=0)
Constructor.
std::pair< typename vigra::GridGraph< N, DirectedTag >::in_edge_iterator, typename vigra::GridGraph< N, DirectedTag >::in_edge_iterator > in_edges(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the incoming edges of vertex v in graph g (API: boost)...
Definition: multi_gridgraph.hxx:2931
bool direction(const Arc &arc) const
Return true when the arc is looking on the underlying edge in its natural (i.e. forward) direction...
vigra::GridGraph< N, DirectedTag >::vertices_size_type num_vertices(vigra::GridGraph< N, DirectedTag > const &g)
Return the number of vertices in graph g (API: boost).
Definition: multi_gridgraph.hxx:2851
detail::GenericIncEdgeIt< GraphType, NodeStorage, BackOutFilter > OutBackArcIt
outgoing back arc iterator
Definition: adjacency_list_graph.hxx:270
std::pair< typename vigra::GridGraph< N, DirectedTag >::vertex_iterator, typename vigra::GridGraph< N, DirectedTag >::vertex_iterator > vertices(vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the vertices of graph g (API: boost).
Definition: multi_gridgraph.hxx:2840
Node baseNode(const IncEdgeIt &iter) const
Return the start node of the edge the given iterator is referring to (API: LEMON).
vigra::GridGraph< N, DirectedTag >::vertex_descriptor source(typename vigra::GridGraph< N, DirectedTag >::edge_descriptor const &e, vigra::GridGraph< N, DirectedTag > const &g)
Get a vertex descriptor for the start vertex of edge e in graph g (API: boost).
Definition: multi_gridgraph.hxx:2943
std::pair< typename vigra::GridGraph< N, DirectedTag >::edge_iterator, typename vigra::GridGraph< N, DirectedTag >::edge_iterator > edges(vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the edges of graph g (API: boost).
Definition: multi_gridgraph.hxx:2966
detail::GenericIncEdgeIt< GraphType, NodeStorage, IncFilter > IncEdgeIt
incident edge iterator
Definition: adjacency_list_graph.hxx:260
detail_adjacency_list_graph::ArcIt< GraphType > ArcIt
arc iterator
Definition: adjacency_list_graph.hxx:257
index_type nodeNum() const
Get the number of nodes in this graph (API: LEMON).
std::pair< typename vigra::GridGraph< N, DirectedTag >::edge_descriptor, bool > edge(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &u, typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return the pair (edge_descriptor, true) when an edge between vertices u and v exists, or (lemon::INVALID, false) otherwise (API: boost).
Definition: multi_gridgraph.hxx:2990
index_type arcNum() const
Get the number of arcs in this graph (API: LEMON).
Arc arcFromId(const index_type id) const
Get arc descriptor for given node ID i (API: LEMON). Return Arc(lemon::INVALID) when the ID does not ...
Node v(const Edge &edge) const
Get the end node of the given edge e (API: LEMON, the boost::graph API provides the free function bo...
Edge findEdge(const Node &a, const Node &b) const
Get a descriptor for the edge connecting vertices u and v, or lemon::INVALID if no such edge exists (...
Node source(const Arc &arc) const
Get the start node of the given arc a (API: LEMON).
detail::GenericNode< index_type > Node
node descriptor
Definition: adjacency_list_graph.hxx:247
Node target(const Arc &arc) const
Get the end node of the given arc a (API: LEMON).
index_type edgeNum() const
Get the number of edges in this graph (API: LEMON).
Arc findArc(const Node &u, const Node &v) const
Get a descriptor for the arc connecting vertices u and v, or lemon::INVALID if no such edge exists (A...
Node u(const Edge &edge) const
Get the start node of the given edge e (API: LEMON, the boost::graph API provides the free function ...
detail::GenericIncEdgeIt< GraphType, NodeStorage, InFlter > InArcIt
incoming arc iterator
Definition: adjacency_list_graph.hxx:262
Node runningNode(const IncEdgeIt &iter) const
Return the end node of the edge the given iterator is referring to (API: LEMON).
detail_adjacency_list_graph::ItemIter< GraphType, Edge > EdgeIt
edge iterator
Definition: adjacency_list_graph.hxx:253