Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 2335)
+++ lemon/bits/path_dump.h	(revision 2357)
@@ -1,2 +1,3 @@
+
 /* -*- C++ -*-
  *
@@ -50,9 +51,9 @@
     }
 
-    class RevIt {
+    class RevEdgeIt {
     public:
-      RevIt() {}
-      RevIt(Invalid) : path(0), current(INVALID) {}
-      RevIt(const PredMapPath& _path) 
+      RevEdgeIt() {}
+      RevEdgeIt(Invalid) : path(0), current(INVALID) {}
+      RevEdgeIt(const PredMapPath& _path) 
         : path(&_path), current(_path.target) {}
 
@@ -61,5 +62,5 @@
       }
 
-      RevIt& operator++() {
+      RevEdgeIt& operator++() {
         current = path->graph.source(path->predMap[current]);
         if (path->predMap[current] == INVALID) current = INVALID;
@@ -67,13 +68,13 @@
       }
 
-      bool operator==(const RevIt& e) const { 
+      bool operator==(const RevEdgeIt& e) const { 
         return current == e.current; 
       }
 
-      bool operator!=(const RevIt& e) const {
+      bool operator!=(const RevEdgeIt& e) const {
         return current != e.current; 
       }
 
-      bool operator<(const RevIt& e) const { 
+      bool operator<(const RevEdgeIt& e) const { 
         return current < e.current; 
       }
@@ -122,9 +123,9 @@
     }
 
-    class RevIt {
+    class RevEdgeIt {
     public:
-      RevIt() {}
-      RevIt(Invalid) : path(0), current(INVALID) {}
-      RevIt(const PredMatrixMapPath& _path) 
+      RevEdgeIt() {}
+      RevEdgeIt(Invalid) : path(0), current(INVALID) {}
+      RevEdgeIt(const PredMatrixMapPath& _path) 
         : path(&_path), current(_path.target) {}
 
@@ -133,5 +134,5 @@
       }
 
-      RevIt& operator++() {
+      RevEdgeIt& operator++() {
         current = 
           path->graph.source(path->predMatrixMap(path->source, current));
@@ -141,13 +142,13 @@
       }
 
-      bool operator==(const RevIt& e) const { 
+      bool operator==(const RevEdgeIt& e) const { 
         return current == e.current; 
       }
 
-      bool operator!=(const RevIt& e) const {
+      bool operator!=(const RevEdgeIt& e) const {
         return current != e.current; 
       }
 
-      bool operator<(const RevIt& e) const { 
+      bool operator<(const RevEdgeIt& e) const { 
         return current < e.current; 
       }
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 2335)
+++ lemon/concepts/path.h	(revision 2357)
@@ -172,5 +172,5 @@
           int e = p.empty();
 
-          typename _Path::RevIt id, ii(INVALID), i(p);
+          typename _Path::RevEdgeIt id, ii(INVALID), i(p);
 
           ++i;
@@ -233,7 +233,7 @@
       ///
       /// If the RevPathTag is defined and true then reverse dumping
-      /// is provided in the path proxy. In this case instead of the
-      /// EdgeIt the RevIt iterator should be implemented in the
-      /// proxy.
+      /// is provided in the path dumper. In this case instead of the
+      /// EdgeIt the RevEdgeIt iterator should be implemented in the
+      /// dumper.
       typedef False RevPathTag;
 
@@ -269,12 +269,12 @@
       /// This class is used to iterate on the edges of the paths in
       /// reverse direction.
-      class RevIt {
+      class RevEdgeIt {
       public:
 	/// Default constructor
-	RevIt() {}
+	RevEdgeIt() {}
 	/// Invalid constructor
-	RevIt(Invalid) {}
+	RevEdgeIt(Invalid) {}
 	/// Constructor for first edge
-	RevIt(const PathDumper &) {}
+	RevEdgeIt(const PathDumper &) {}
 
         /// Conversion to Edge
@@ -282,12 +282,12 @@
 
 	/// Next edge
-	RevIt& operator++() {return *this;}
-
-	/// Comparison operator
-	bool operator==(const RevIt&) const {return true;}
-	/// Comparison operator
-	bool operator!=(const RevIt&) const {return true;}
+	RevEdgeIt& operator++() {return *this;}
+
+	/// Comparison operator
+	bool operator==(const RevEdgeIt&) const {return true;}
+	/// Comparison operator
+	bool operator!=(const RevEdgeIt&) const {return true;}
  	/// Comparison operator
- 	bool operator<(const RevIt&) const {return false;}
+ 	bool operator<(const RevEdgeIt&) const {return false;}
 
       };
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 2336)
+++ lemon/path.h	(revision 2357)
@@ -218,5 +218,5 @@
       int len = path.length();
       head.reserve(len);
-      for (typename CPath::RevIt it(path); it != INVALID; ++it) {
+      for (typename CPath::RevEdgeIt it(path); it != INVALID; ++it) {
         head.push_back(it);
       }
@@ -376,5 +376,5 @@
       data.resize(len);
       int index = len;
-      for (typename CPath::RevIt it(path); it != INVALID; ++it) {
+      for (typename CPath::RevEdgeIt it(path); it != INVALID; ++it) {
         --index;
         data[index] = it;;
@@ -721,5 +721,5 @@
     template <typename CPath>
     void buildRev(const CPath& path) {
-      for (typename CPath::RevIt it(path); it != INVALID; ++it) {
+      for (typename CPath::RevEdgeIt it(path); it != INVALID; ++it) {
         addFront(it);
       }
@@ -882,5 +882,5 @@
       edges = new Edge[len];
       int index = len;
-      for (typename CPath::RevIt it(path); it != INVALID; ++it) {
+      for (typename CPath::RevEdgeIt it(path); it != INVALID; ++it) {
         --index;
         edges[index] = it;
Index: lemon/path_utils.h
===================================================================
--- lemon/path_utils.h	(revision 2350)
+++ lemon/path_utils.h	(revision 2357)
@@ -49,5 +49,5 @@
     struct PathCopySelector {
       static void copy(Target& target, const Source& source) {
-        source.clear();
+        target.clear();
         for (typename Source::EdgeIt it(source); it != INVALID; ++it) {
           target.addBack(it);
@@ -61,6 +61,6 @@
       typename enable_if<typename Source::RevPathTag, void>::type> {
       static void copy(Target& target, const Source& source) {
-        source.clear();
-        for (typename Source::RevIt it(source); it != INVALID; ++it) {
+        target.clear();
+        for (typename Source::RevEdgeIt it(source); it != INVALID; ++it) {
           target.addFront(it);
         }
