# Changeset 1420:1f4f01870c1e in lemon for lemon/path.h

Ignore:
Timestamp:
02/17/18 23:44:15 (20 months ago)
Branch:
default
Phase:
public
Message:

API doc improvements for Path structures (#250)

File:
1 edited

Unmodified
Removed
• ## lemon/path.h

 r1336 /// \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 /// \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) : /// \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 /// \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]; /// \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 /// /// 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; /// \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) { /// \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 /// 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 { /// \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]; 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; } /// \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
Note: See TracChangeset for help on using the changeset viewer.