# Changeset 954:be7dd3a8d6a3 in lemon-1.2 for lemon/concepts/path.h

Ignore:
Timestamp:
01/20/12 19:20:02 (8 years ago)
Branch:
1.2
Parents:
952:0976225b5cae (diff), 953:b873350e6258 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Phase:
public
Message:

Merge Intel C++ compatibility fixes to branch 1.2

Files:
2 edited

Unmodified
Removed
• ## lemon/concepts/path.h

 r785 } _Path& p; PathDumperConstraints() {} }; } _Path& p; PathDumperConstraints() {} };
• ## lemon/concepts/path.h

 r953 ///\ingroup concept ///\file ///\brief Classes for representing paths in digraphs. ///\brief The concept of paths /// /// A skeleton structure for representing directed paths in a /// digraph. /// In a sense, a path can be treated as a list of arcs. /// LEMON path types just store this list. As a consequence, they cannot /// enumerate the nodes on the path directly and a zero length path /// cannot store its source node. /// /// The arcs of a path should be stored in the order of their directions, /// i.e. the target node of each arc should be the same as the source /// node of the next arc. This consistency could be checked using /// \ref checkPath(). /// The source and target nodes of a (consistent) path can be obtained /// using \ref pathSource() and \ref pathTarget(). /// /// A path can be constructed from another path of any type using the /// copy constructor or the assignment operator. /// /// \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. /// template class Path { Path() {} /// \brief Template constructor /// \brief Template copy constructor template Path(const CPath& cpath) {} /// \brief Template assigment /// \brief Template assigment operator template Path& operator=(const CPath& cpath) { } /// Length of the path ie. the number of arcs in the path. /// Length of the path, i.e. the number of arcs on the path. int length() const { return 0;} void clear() {} /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path. /// /// This class is used to iterate on the arcs of the paths. /// LEMON style iterator class for enumerating the arcs of a path. class ArcIt { public: /// Invalid constructor ArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the first arc of the given path ArcIt(const Path &) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; } /// /// A skeleton structure for path dumpers. The path dumpers are /// the generalization of the paths. The path dumpers can /// enumerate the arcs of the path wheter in forward or in /// backward order.  In most time these classes are not used /// directly rather it used to assign a dumped class to a real /// path type. /// the generalization of the paths, they can enumerate the arcs /// of the path either in forward or in backward order. /// These classes are typically not used directly, they are rather /// used to be assigned to a real path type. /// /// The main purpose of this concept is that the shortest path /// algorithms can enumerate easily the arcs in reverse order. /// If we would like to give back a real path from these /// algorithms then we should create a temporarly path object. In /// LEMON such algorithms gives back a path dumper what can /// assigned to a real path and the dumpers can be implemented as /// algorithms can enumerate the arcs easily in reverse order. /// In LEMON, such algorithms give back a (reverse) path dumper that /// can be assigned to a real path. The dumpers can be implemented as /// an adaptor class to the predecessor map. /// /// \tparam GR The digraph type in which the path is. /// /// The paths can be constructed from any path type by a /// template constructor or a template assignment operator. template class PathDumper { typedef typename Digraph::Arc Arc; /// Length of the path ie. the number of arcs in the path. /// Length of the path, i.e. the number of arcs on the path. int length() const { return 0;} /// \brief Forward or reverse dumping /// /// If the RevPathTag is defined and true then reverse dumping /// is provided in the path dumper. In this case instead of the /// ArcIt the RevArcIt iterator should be implemented in the /// dumper. /// If this tag is defined to be \c True, then reverse dumping /// is provided in the path dumper. In this case, \c RevArcIt /// iterator should be implemented instead of \c ArcIt iterator. typedef False RevPathTag; /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path. /// /// This class is used to iterate on the arcs of the paths. /// LEMON style iterator class for enumerating the arcs of a path. class ArcIt { public: /// Invalid constructor ArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the first arc of the given path ArcIt(const PathDumper&) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; } }; /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path /// in reverse direction. /// /// This class is used to iterate on the arcs of the paths in /// reverse direction. /// LEMON style iterator class for enumerating the arcs of a path /// in reverse direction. class RevArcIt { public: /// Invalid constructor RevArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the last arc of the given path RevArcIt(const PathDumper &) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; }
Note: See TracChangeset for help on using the changeset viewer.