Index: lemon/path.h
===================================================================
--- lemon/path.h (revision 1130)
+++ lemon/path.h (revision 1201)
@@ -44,8 +44,8 @@
/// \tparam GR The digraph type in which the path is.
///
- /// In a sense, the path can be treated as a list of arcs. The
- /// LEMON path type stores just this list. As a consequence, it
- /// cannot enumerate the nodes of the path and the source node of
- /// a zero length path is undefined.
+ /// In a sense, a path can be treated as a list of arcs. The
+ /// LEMON path type simply stores this list. As a consequence, it
+ /// cannot enumerate the nodes in the path, and the source node of
+ /// a zero-length path is undefined.
///
/// This implementation is a back and front insertable and erasable
@@ -169,5 +169,6 @@
/// \brief The n-th arc.
///
- /// \pre \c n is in the `[0..length() - 1]` range.
+ /// Gives back the n-th arc. This function runs in O(1) time.
+ /// \pre \c n is in the range `[0..length() - 1]`.
const Arc& nth(int n) const {
return n < int(head.size()) ? *(head.rbegin() + n) :
@@ -262,13 +263,13 @@
/// \tparam GR The digraph type in which the path is.
///
- /// In a sense, the path can be treated as a list of arcs. The
- /// LEMON path type stores just this list. As a consequence it
- /// cannot enumerate the nodes in the path and the zero length paths
- /// cannot store the source.
+ /// In a sense, a path can be treated as a list of arcs. The
+ /// LEMON path type simply stores this list. As a consequence, it
+ /// cannot enumerate the nodes in the path, and the source node of
+ /// a zero-length path is undefined.
///
/// This implementation is a just back insertable and erasable path
/// type. It can be indexed in O(1) time. The back insertion and
/// erasure is amortized O(1) time. This implementation is faster
- /// then the \c Path type because it use just one vector for the
+ /// than the \c Path type because it use just one vector for the
/// arcs.
template
@@ -391,5 +392,6 @@
/// \brief The n-th arc.
///
- /// \pre \c n is in the `[0..length() - 1]` range.
+ /// Gives back the n-th arc. This function runs in O(1) time.
+ /// \pre \c n is in the range `[0..length() - 1]`.
const Arc& nth(int n) const {
return data[n];
@@ -456,8 +458,8 @@
/// \tparam GR The digraph type in which the path is.
///
- /// In a sense, the path can be treated as a list of arcs. The
- /// LEMON path type stores just this list. As a consequence it
- /// cannot enumerate the nodes in the path and the zero length paths
- /// cannot store the source.
+ /// In a sense, a path can be treated as a list of arcs. The
+ /// LEMON path type simply stores this list. As a consequence, it
+ /// cannot enumerate the nodes in the path, and the source node of
+ /// a zero-length path is undefined.
///
/// This implementation is a back and front insertable and erasable
@@ -599,5 +601,5 @@
///
/// This function looks for the n-th arc in O(n) time.
- /// \pre \c n is in the `[0..length() - 1]` range.
+ /// \pre \c n is in the range `[0..length() - 1]`.
const Arc& nth(int n) const {
Node *node = first;
@@ -785,5 +787,5 @@
/// \c it will put into \c tpath. If \c tpath have arcs
/// before the operation they are removed first. The time
- /// complexity of this function is O(1) plus the the time of emtying
+ /// complexity of this function is O(1) plus the time of emtying
/// \c tpath. If \c it is \c INVALID then it just clears \c tpath
void split(ArcIt it, ListPath& tpath) {
@@ -826,8 +828,8 @@
/// \tparam GR The digraph type in which the path is.
///
- /// In a sense, the path can be treated as a list of arcs. The
- /// LEMON path type stores just this list. As a consequence it
- /// cannot enumerate the nodes in the path and the source node of
- /// a zero length path is undefined.
+ /// In a sense, a path can be treated as a list of arcs. The
+ /// LEMON path type simply stores this list. As a consequence, it
+ /// cannot enumerate the nodes in the path, and the source node of
+ /// a zero-length path is undefined.
///
/// This implementation is completly static, i.e. it can be copy constucted
@@ -835,7 +837,6 @@
/// modified.
///
- /// Being the the most memory efficient path type in LEMON,
- /// it is intented to be
- /// used when you want to store a large number of paths.
+ /// Being the most memory-efficient path type in LEMON, it is
+ /// intented to be used when you want to store a large number of paths.
template
class StaticPath {
@@ -955,5 +956,6 @@
/// \brief The n-th arc.
///
- /// \pre \c n is in the `[0..length() - 1]` range.
+ /// Gives back the n-th arc. This function runs in O(1) time.
+ /// \pre \c n is in the range `[0..length() - 1]`.
const Arc& nth(int n) const {
return _arcs[n];
@@ -971,5 +973,5 @@
int empty() const { return len == 0; }
- /// \brief Erase all arcs in the digraph.
+ /// \brief Reset the path to an empty one.
void clear() {
len = 0;
@@ -1161,13 +1163,15 @@
}
- /// \brief Class which helps to iterate through the nodes of a path
- ///
- /// In a sense, the path can be treated as a list of arcs. The
- /// LEMON path type stores only this list. As a consequence, it
- /// cannot enumerate the nodes in the path and the zero length paths
- /// cannot have a source node.
- ///
- /// This class implements the node iterator of a path structure. To
- /// provide this feature, the underlying digraph should be passed to
+ /// \brief Class for iterating through the nodes of a path
+ ///
+ /// Class for iterating through the nodes of a path.
+ ///
+ /// In a sense, a path can be treated as a list of arcs. The
+ /// LEMON path type simply stores this list. As a consequence, it
+ /// cannot enumerate the nodes in the path, and the source node of
+ /// a zero-length path is undefined.
+ ///
+ /// However, this class implements a node iterator for path structures.
+ /// To provide this feature, the underlying digraph should be passed to
/// the constructor of the iterator.
template