Changes in lemon/path.h [1270:dceba191c00d:1336:0759d974de81] in lemon

File:

• lemon/path.h (modified) (14 diffs)

lemon/path.h

@@ -31 +31 @@
 #include <lemon/core.h>
 #include <lemon/concepts/path.h>
+#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -140 +141 @@
       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.
@@ -346 +364 @@
     };
 
+    /// \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(); }
@@ -543 +578 @@
       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.
@@ -796 +848 @@
     ///
     /// 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);
     }
@@ -808 +860 @@
     /// 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);
     }
@@ -816 +868 @@
     /// Destructor of the path
     ~StaticPath() {
-      if (arcs) delete[] arcs;
+      if (_arcs) delete[] _arcs;
     }
 
@@ -883 +935 @@
       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.
@@ -888 +957 @@
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
-      return arcs[n];
+      return _arcs[n];
     }
 
@@ -905 +974 @@
     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];
     }
 
@@ -925 +994 @@
     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;
       }
@@ -936 +1005 @@
     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;
       }
     }
@@ -946 +1015 @@
   private:
     int len;
-    Arc* arcs;
+    Arc* _arcs;
   };
 
@@ -1158 +1227 @@
   };
 
+  /// \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);
+  }
+
   ///@}