Ticket #325: stl-iterators-paths-fe4d0623659c.patch

contrib/stlit_test/stlit_test.cc

@@ -6 +6 @@
 #include <lemon/bits/stl_iterators.h>
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
+#include <lemon/path.h>
+#include <lemon/bfs.h>
 
 
 using namespace std;
@@ -125 +127 @@
   for(auto u: g3.blueNodes())
       cout<<g3.id(u)<<endl;
 
+  cout<<endl;
+
+  {
+    SmartGraph g4;
+    auto u1 = g4.addNode(), u2 = g4.addNode();
+    g4.addEdge(u1, u2);
+    Path<SmartGraph> p;
+    bfs(g4).path(p).run(u1,u2);
+    for(auto u: pathNodes(g4, p))
+      cout<<g4.id(u)<<endl;
+    for(auto a: p.arcs())
+      cout<<g4.id(g4.target(a))<<endl;
+  }
+
   return 0;
 }

lemon/concepts/path.h

@@ -115 +115 @@
 
       };
 
+      /// \brief Gets the collection of the arcs of the path.
+      ///
+      /// This function can be used for iterating on the
+      /// arcs of the path. It returns a wrapped
+      /// ArcIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example you can write:
+      ///\code
+      /// for(auto a: p.arcs())
+      ///   doSomething(a);
+      ///\endcode
+      LemonRangeWrapper1<ArcIt, Path> arcs() const {
+        return LemonRangeWrapper1<ArcIt, Path>(*this);
+      }
+
+
       template <typename _Path>
       struct Constraints {
         void constraints() {
@@ -264 +281 @@
 
       };
 
+      /// \brief Gets the collection of the arcs of the path.
+      ///
+      /// This function can be used for iterating on the
+      /// arcs of the path. It returns a wrapped
+      /// ArcIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example you can write:
+      ///\code
+      /// for(auto a: p.arcs())
+      ///   doSomething(a);
+      ///\endcode
+      LemonRangeWrapper1<ArcIt, PathDumper> arcs() const {
+        return LemonRangeWrapper1<ArcIt, PathDumper>(*this);
+      }
+
+
       /// \brief LEMON style iterator for enumerating the arcs of a path
       /// in reverse direction.
       ///
@@ -293 +327 @@
 
       };
 
+      /// \brief Gets the collection of the arcs of the path
+      /// in reverse direction.
+      ///
+      /// This function can be used for iterating on the
+      /// arcs of the path in reverse direction. It returns a wrapped
+      /// RevArcIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example you can write:
+      ///\code
+      /// for(auto a: p.revArcs())
+      ///   doSomething(a);
+      ///\endcode
+      LemonRangeWrapper1<RevArcIt, PathDumper> revArcs() const {
+        return LemonRangeWrapper1<RevArcIt, PathDumper>(*this);
+      }
+
+
       template <typename _Path>
       struct Constraints {
         void constraints() {

lemon/path.h

@@ -140 +140 @@
       int idx;
     };
 
+    /// \brief Gets the collection of the arcs of the path.
+    ///
+    /// This function can be used for iterating on the
+    /// arcs of the path. It returns a wrapped
+    /// ArcIt, which looks like an STL container
+    /// (by having begin() and end()) which you can use in range-based
+    /// for loops, stl algorithms, etc.
+    /// For example you can write:
+    ///\code
+    /// for(auto a: p.arcs())
+    ///   doSomething(a);
+    ///\endcode
+    LemonRangeWrapper1<ArcIt, Path> arcs() const {
+      return LemonRangeWrapper1<ArcIt, Path>(*this);
+    }
+
+
     /// \brief Length of the path.
     int length() const { return head.size() + tail.size(); }
     /// \brief Return whether the path is empty.
@@ -345 +362 @@
       int idx;
     };
 
+    /// \brief Gets the collection of the arcs of the path.
+    ///
+    /// This function can be used for iterating on the
+    /// arcs of the path. It returns a wrapped
+    /// ArcIt, which looks like an STL container
+    /// (by having begin() and end()) which you can use in range-based
+    /// for loops, stl algorithms, etc.
+    /// For example you can write:
+    ///\code
+    /// for(auto a: p.arcs())
+    ///   doSomething(a);
+    ///\endcode
+    LemonRangeWrapper1<ArcIt, SimplePath> arcs() const {
+      return LemonRangeWrapper1<ArcIt, SimplePath>(*this);
+    }
+
+
     /// \brief Length of the path.
     int length() const { return data.size(); }
     /// \brief Return true if the path is empty.
@@ -543 +577 @@
       Node *node;
     };
 
+    /// \brief Gets the collection of the arcs of the path.
+    ///
+    /// This function can be used for iterating on the
+    /// arcs of the path. It returns a wrapped
+    /// ArcIt, which looks like an STL container
+    /// (by having begin() and end()) which you can use in range-based
+    /// for loops, stl algorithms, etc.
+    /// For example you can write:
+    ///\code
+    /// for(auto a: p.arcs())
+    ///   doSomething(a);
+    ///\endcode
+    LemonRangeWrapper1<ArcIt, ListPath> arcs() const {
+      return LemonRangeWrapper1<ArcIt, ListPath>(*this);
+    }
+
+
     /// \brief The n-th arc.
     ///
     /// This function looks for the n-th arc in O(n) time.
@@ -795 +846 @@
     /// \brief Default constructor
     ///
     /// Default constructor
-    StaticPath() : len(0), arcs(0) {}
+    StaticPath() : len(0), _arcs(0) {}
 
     /// \brief Copy constructor
     ///
-    StaticPath(const StaticPath& cpath) : arcs(0) {
+    StaticPath(const StaticPath& cpath) : _arcs(0) {
       pathCopy(cpath, *this);
     }
 
@@ -807 +858 @@
     ///
     /// This path can be initialized from any other path type.
     template <typename CPath>
-    StaticPath(const CPath& cpath) : arcs(0) {
+    StaticPath(const CPath& cpath) : _arcs(0) {
       pathCopy(cpath, *this);
     }
 
@@ -815 +866 @@
     ///
     /// Destructor of the path
     ~StaticPath() {
-      if (arcs) delete[] arcs;
+      if (_arcs) delete[] _arcs;
     }
 
     /// \brief Copy assignment
@@ -882 +933 @@
       const StaticPath *path;
       int idx;
     };
+    
+    /// \brief Gets the collection of the arcs of the path.
+    ///
+    /// This function can be used for iterating on the
+    /// arcs of the path. It returns a wrapped
+    /// ArcIt, which looks like an STL container
+    /// (by having begin() and end()) which you can use in range-based
+    /// for loops, stl algorithms, etc.
+    /// For example you can write:
+    ///\code
+    /// for(auto a: p.arcs())
+    ///   doSomething(a);
+    ///\endcode
+    LemonRangeWrapper1<ArcIt, StaticPath> arcs() const {
+      return LemonRangeWrapper1<ArcIt, StaticPath>(*this);
+    }
+    
 
     /// \brief The n-th arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
-      return arcs[n];
+      return _arcs[n];
     }
 
     /// \brief The arc iterator pointing to the n-th arc.
@@ -904 +972 @@
     /// \brief Erase all arcs in the digraph.
     void clear() {
       len = 0;
-      if (arcs) delete[] arcs;
-      arcs = 0;
+      if (_arcs) delete[] _arcs;
+      _arcs = 0;
     }
 
     /// \brief The first arc of the path.
     const Arc& front() const {
-      return arcs[0];
+      return _arcs[0];
     }
 
     /// \brief The last arc of the path.
     const Arc& back() const {
-      return arcs[len - 1];
+      return _arcs[len - 1];
     }
 
 
@@ -924 +992 @@
     template <typename CPath>
     void build(const CPath& path) {
       len = path.length();
-      arcs = new Arc[len];
+      _arcs = new Arc[len];
       int index = 0;
       for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
-        arcs[index] = it;
+        _arcs[index] = it;
         ++index;
       }
     }
@@ -935 +1003 @@
     template <typename CPath>
     void buildRev(const CPath& path) {
       len = path.length();
-      arcs = new Arc[len];
+      _arcs = new Arc[len];
       int index = len;
       for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
         --index;
-        arcs[index] = it;
+        _arcs[index] = it;
       }
     }
 
   private:
     int len;
-    Arc* arcs;
+    Arc* _arcs;
   };
 
   ///////////////////////////////////////////////////////////////////////
@@ -1157 +1225 @@
 
   };
 
+  /// \brief Gets the collection of the nodes of the path.
+  ///
+  /// This function can be used for iterating on the
+  /// nodes of the path. It returns a wrapped
+  /// PathNodeIt, which looks like an STL container
+  /// (by having begin() and end()) which you can use in range-based
+  /// for loops, stl algorithms, etc.
+  /// For example you can write:
+  ///\code
+  /// for(auto u: pathNodes(g,p))
+  ///   doSomething(u);
+  ///\endcode
+  template<typename Path>
+  LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>
+      pathNodes(const typename Path::Digraph &g, const Path &p) {
+    return
+        LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>(g,p);
+  }
+
   ///@}
 
 } // namespace lemon