lemon-0.x: comparison src/work/peter/path/path.h

equal deleted inserted replaced

-:bb8f06548d9d
+:03cf4578ff9a
 /// \brief Starting point of the path.
 ///
 /// Starting point of the path.
 /// Returns INVALID if the path is empty.
 GraphNode from() const {
-return empty() ? INVALID : gr->tail(edges[0]);
+return empty() ? INVALID : gr->source(edges[0]);
 }
 /// \brief End point of the path.
 ///
 /// End point of the path.
 /// Returns INVALID if the path is empty.
 GraphNode to() const {
-return empty() ? INVALID : gr->head(edges[length()-1]);
+return empty() ? INVALID : gr->target(edges[length()-1]);
 }
 /// \brief Initializes node or edge iterator to point to the first
 /// node or edge.
 ///
 if( DM::range_check && !e.valid() )
 	fault("DirPath::next() on invalid iterator");
 return ++e;
 }
-/// \brief Returns node iterator pointing to the head node of the
+/// \brief Returns node iterator pointing to the target node of the
 /// given edge iterator.
-NodeIt head(const EdgeIt& e) const {
+NodeIt target(const EdgeIt& e) const {
 if( DM::range_check && !e.valid() )
-	fault("DirPath::head() on invalid iterator");
+	fault("DirPath::target() on invalid iterator");
 return NodeIt(*this, e.idx+1);
 }
-/// \brief Returns node iterator pointing to the tail node of the
+/// \brief Returns node iterator pointing to the source node of the
 /// given edge iterator.
-NodeIt tail(const EdgeIt& e) const {
+NodeIt source(const EdgeIt& e) const {
 if( DM::range_check && !e.valid() )
-	fault("DirPath::tail() on invalid iterator");
+	fault("DirPath::source() on invalid iterator");
 return NodeIt(*this, e.idx);
 }
 /* Iterator classes */
 ///Conversion to Graph::Node
 operator const GraphNode& () const {
 	if(idx >= p->length())
 	  return p->to();
 	else if(idx >= 0)
-	  return p->gr->tail(p->edges[idx]);
+	  return p->gr->source(p->edges[idx]);
 	else
 	  return INVALID;
 }
 /// Next node
 NodeIt& operator++() { ++idx; validate(); return *this; }
 ///Push a new edge to the front of the path
 ///Push a new edge to the front of the path.
 ///\sa setStartNode
 void pushFront(const GraphEdge& e) {
-	if( DM::consistensy_check && !empty() && P.gr->head(e)!=from() ) {
+	if( DM::consistensy_check && !empty() && P.gr->target(e)!=from() ) {
 	  fault("DirPath::Builder::pushFront: nonincident edge");
 	}
 	front.push_back(e);
 }
 ///Push a new edge to the back of the path
 ///Push a new edge to the back of the path.
 ///\sa setStartNode
 void pushBack(const GraphEdge& e) {
-	if( DM::consistensy_check && !empty() && P.gr->tail(e)!=to() ) {
+	if( DM::consistensy_check && !empty() && P.gr->source(e)!=to() ) {
 	  fault("DirPath::Builder::pushBack: nonincident edge");
 	}
 	back.push_back(e);
 }
 	return front.empty() && back.empty() && P.empty();
 }
 GraphNode from() const {
 	if( ! front.empty() )
-	  return P.gr->tail(front[front.size()-1]);
+	  return P.gr->source(front[front.size()-1]);
 	else if( ! P.empty() )
-	  return P.gr->tail(P.edges[0]);
+	  return P.gr->source(P.edges[0]);
 	else if( ! back.empty() )
-	  return P.gr->tail(back[0]);
+	  return P.gr->source(back[0]);
 	else
 	  return INVALID;
 }
 GraphNode to() const {
 	if( ! back.empty() )
-	  return P.gr->head(back[back.size()-1]);
+	  return P.gr->target(back[back.size()-1]);
 	else if( ! P.empty() )
-	  return P.gr->head(P.edges[P.length()-1]);
+	  return P.gr->target(P.edges[P.length()-1]);
 	else if( ! front.empty() )
-	  return P.gr->head(front[0]);
+	  return P.gr->target(front[0]);
 	else
 	  return INVALID;
 }
 };
 /// \brief Starting point of the path.
 ///
 /// Starting point of the path.
 /// Returns INVALID if the path is empty.
 GraphNode from() const {
-return empty() ? INVALID : gr->tail(edges[0]);
+return empty() ? INVALID : gr->source(edges[0]);
 }
 /// \brief End point of the path.
 ///
 /// End point of the path.
 /// Returns INVALID if the path is empty.
 GraphNode to() const {
-return empty() ? INVALID : gr->head(edges[length()-1]);
+return empty() ? INVALID : gr->target(edges[length()-1]);
 }
 /// \brief Initializes node or edge iterator to point to the first
 /// node or edge.
 ///
 if( DM::range_check && !e.valid() )
 	fault("UndirPath::next() on invalid iterator");
 return ++e;
 }
-/// \brief Returns node iterator pointing to the head node of the
+/// \brief Returns node iterator pointing to the target node of the
 /// given edge iterator.
-NodeIt head(const EdgeIt& e) const {
+NodeIt target(const EdgeIt& e) const {
 if( DM::range_check && !e.valid() )
-	fault("UndirPath::head() on invalid iterator");
+	fault("UndirPath::target() on invalid iterator");
 return NodeIt(*this, e.idx+1);
 }
-/// \brief Returns node iterator pointing to the tail node of the
+/// \brief Returns node iterator pointing to the source node of the
 /// given edge iterator.
-NodeIt tail(const EdgeIt& e) const {
+NodeIt source(const EdgeIt& e) const {
 if( DM::range_check && !e.valid() )
-	fault("UndirPath::tail() on invalid iterator");
+	fault("UndirPath::source() on invalid iterator");
 return NodeIt(*this, e.idx);
 }
 ///Conversion to Graph::Node
 operator const GraphNode& () const {
 	if(idx >= p->length())
 	  return p->to();
 	else if(idx >= 0)
-	  return p->gr->tail(p->edges[idx]);
+	  return p->gr->source(p->edges[idx]);
 	else
 	  return INVALID;
 }
 /// Next node
 NodeIt& operator++() { ++idx; validate(); return *this; }
 ///Push a new edge to the front of the path
 ///Push a new edge to the front of the path.
 ///\sa setStartNode
 void pushFront(const GraphEdge& e) {
-	if( DM::consistensy_check && !empty() && P.gr->head(e)!=from() ) {
+	if( DM::consistensy_check && !empty() && P.gr->target(e)!=from() ) {
 	  fault("UndirPath::Builder::pushFront: nonincident edge");
 	}
 	front.push_back(e);
 }
 ///Push a new edge to the back of the path
 ///Push a new edge to the back of the path.
 ///\sa setStartNode
 void pushBack(const GraphEdge& e) {
-	if( DM::consistensy_check && !empty() && P.gr->tail(e)!=to() ) {
+	if( DM::consistensy_check && !empty() && P.gr->source(e)!=to() ) {
 	  fault("UndirPath::Builder::pushBack: nonincident edge");
 	}
 	back.push_back(e);
 }
 	return front.empty() && back.empty() && P.empty();
 }
 GraphNode from() const {
 	if( ! front.empty() )
-	  return P.gr->tail(front[front.size()-1]);
+	  return P.gr->source(front[front.size()-1]);
 	else if( ! P.empty() )
-	  return P.gr->tail(P.edges[0]);
+	  return P.gr->source(P.edges[0]);
 	else if( ! back.empty() )
-	  return P.gr->tail(back[0]);
+	  return P.gr->source(back[0]);
 	else
 	  return INVALID;
 }
 GraphNode to() const {
 	if( ! back.empty() )
-	  return P.gr->head(back[back.size()-1]);
+	  return P.gr->target(back[back.size()-1]);
 	else if( ! P.empty() )
-	  return P.gr->head(P.edges[P.length()-1]);
+	  return P.gr->target(P.edges[P.length()-1]);
 	else if( ! front.empty() )
-	  return P.gr->head(front[0]);
+	  return P.gr->target(front[0]);
 	else
 	  return INVALID;
 }
 };
 bool pushFront(const GraphEdge &e);
 bool pushBack(const GraphEdge &e);
 bool setFrom(const GraphNode &n);
 bool setTo(const GraphNode &n);
-// WARNING: these two functions return the head/tail of an edge with
+// WARNING: these two functions return the target/source of an edge with
 // respect to the direction of the path!
-// So G.head(P.graphEdge(e)) == P.graphNode(P.head(e)) holds only if
+// So G.target(P.graphEdge(e)) == P.graphNode(P.target(e)) holds only if
 // P.forward(e) is true (or the edge is a loop)!
-NodeIt head(const EdgeIt& e) const;
+NodeIt target(const EdgeIt& e) const;
-NodeIt tail(const EdgeIt& e) const;
+NodeIt source(const EdgeIt& e) const;
 // FIXME: ezeknek valami jobb nev kellene!!!
 GraphEdge graphEdge(const EdgeIt& e) const;
 GraphNode graphNode(const NodeIt& n) const;
 class NodeIt {
 friend class DynamicPath;
 size_t idx;
-bool tail;  // Is this node the tail of the edge with same idx?
+bool source;  // Is this node the source of the edge with same idx?
 public:
 // FIXME: jarna neki ilyen is...
 // NodeIt(Invalid);
 typename DynamicPath<Gr>::EdgeIt&
 DynamicPath<Gr>::next(DynamicPath::EdgeIt &e) const {
 if( e.it == edges.end() )
 return e;
-GraphNode common_node = ( e.forw ? G.head(*e.it) : G.tail(*e.it) );
+GraphNode common_node = ( e.forw ? G.target(*e.it) : G.source(*e.it) );
 ++e.it;
 // Invalid edgeit is always forward :)
 if( e.it == edges.end() ) {
 e.forw = true;
 return e;
 }
-e.forw = ( G.tail(*e.it) == common_node );
+e.forw = ( G.source(*e.it) == common_node );
 return e;
 }
 template<typename Gr>
 typename DynamicPath<Gr>::NodeIt& DynamicPath<Gr>::next(NodeIt &n) const {
 n.idx = length()+1;
 return n;
 }
-GraphNode next_node = ( n.tail ? G.head(edges[n.idx]) :
+GraphNode next_node = ( n.source ? G.target(edges[n.idx]) :
-			      G.tail(edges[n.idx]) );
+			      G.source(edges[n.idx]) );
 ++n.idx;
 if( n.idx < length() ) {
-n.tail = ( next_node == G.tail(edges[n.idx]) );
+n.source = ( next_node == G.source(edges[n.idx]) );
 }
 else {
-n.tail = true;
+n.source = true;
 }
 return n;
 }
 template<typename Gr>
 bool DynamicPath<Gr>::edgeIncident(const GraphEdge &e, const GraphNode &a,
 			  GraphNode &b) {
-if( G.tail(e) == a ) {
+if( G.source(e) == a ) {
-b=G.head(e);
+b=G.target(e);
 return true;
 }
-if( G.head(e) == a ) {
+if( G.target(e) == a ) {
-b=G.tail(e);
+b=G.source(e);
 return true;
 }
 return false;
 }
 template<typename Gr>
 bool DynamicPath<Gr>::connectTwoEdges(const GraphEdge &e,
 			     const GraphEdge &f) {
-if( edgeIncident(f, G.tail(e), _last) ) {
+if( edgeIncident(f, G.source(e), _last) ) {
-_first = G.head(e);
+_first = G.target(e);
 return true;
 }
-if( edgeIncident(f, G.head(e), _last) ) {
+if( edgeIncident(f, G.target(e), _last) ) {
-_first = G.tail(e);
+_first = G.source(e);
 return true;
 }
 return false;
 }
 }
 template<typename Gr>
 typename DynamicPath<Gr>::NodeIt
-DynamicPath<Gr>::tail(const EdgeIt& e) const {
+DynamicPath<Gr>::source(const EdgeIt& e) const {
 NodeIt n;
 if( e.it == edges.end() ) {
 // FIXME: invalid-> invalid
 n.idx = length() + 1;
-n.tail = true;
+n.source = true;
 return n;
 }
 n.idx = e.it-edges.begin();
-n.tail = e.forw;
+n.source = e.forw;
 return n;
 }
 template<typename Gr>
 typename DynamicPath<Gr>::NodeIt
-DynamicPath<Gr>::head(const EdgeIt& e) const {
+DynamicPath<Gr>::target(const EdgeIt& e) const {
 if( e.it == edges.end()-1 ) {
 return _last;
 }
 EdgeIt next_edge = e;
 next(next_edge);
-return tail(next_edge);
+return source(next_edge);
 }
 template<typename Gr>
 typename DynamicPath<Gr>::GraphEdge
 DynamicPath<Gr>::graphEdge(const EdgeIt& e) const {
 template<typename Gr>
 typename DynamicPath<Gr>::GraphNode
 DynamicPath<Gr>::graphNode(const NodeIt& n) const {
 if( n.idx < length() ) {
-return n.tail ? G.tail(edges[n.idx]) : G.head(edges[n.idx]);
+return n.source ? G.source(edges[n.idx]) : G.target(edges[n.idx]);
 }
 else if( n.idx == length() ) {
 return _last;
 }
 else {
 return e;
 }
 e.it = edges.begin()+k;
 if(k==0) {
-e.forw = ( G.tail(*e.it) == _first );
+e.forw = ( G.source(*e.it) == _first );
 }
 else {
-e.forw = ( G.tail(*e.it) == G.tail(edges[k-1]) ||
+e.forw = ( G.source(*e.it) == G.source(edges[k-1]) ||
-		 G.tail(*e.it) == G.head(edges[k-1]) );
+		 G.source(*e.it) == G.target(edges[k-1]) );
 }
 return e;
 }
 template<typename Gr>
 typename DynamicPath<Gr>::NodeIt&
 DynamicPath<Gr>::nth(NodeIt &n, size_t k) const {
 if( k>length() ) {
 // FIXME: invalid NodeIt
 n.idx = length()+1;
-n.tail = true;
+n.source = true;
 return n;
 }
 if( k==length() ) {
 n.idx = length();
-n.tail = true;
+n.source = true;
 return n;
 }
-n = tail(nth<EdgeIt>(k));
+n = source(nth<EdgeIt>(k));
 return n;
 }
 // Reszut konstruktorok:
 DynamicPath<Gr>::DynamicPath(const DynamicPath &P, const EdgeIt &a,
 			       const EdgeIt &b) :
 G(P.G), edges(a.it, b.it)    // WARNING: if b.it < a.it this will blow up!
 {
 if( G.valid(P._first) && a.it < P.edges.end() ) {
-_first = ( a.forw ? G.tail(*a.it) : G.head(*a.it) );
+_first = ( a.forw ? G.source(*a.it) : G.target(*a.it) );
 if( b.it < P.edges.end() ) {
-	_last = ( b.forw ? G.tail(*b.it) : G.head(*b.it) );
+	_last = ( b.forw ? G.source(*b.it) : G.target(*b.it) );
 }
 else {
 	_last = P._last;
 }
 }

changeset 1062	8226427845bc
parent 959	c80ef5912903