LEMON/LEMON-official Changeset - r551:c6acc34f98dc

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r551:c6acc34f98dc

« 548:41bdb4

865:e9c203 »
858:230516 »
831:1a7fe3 »
552:bfe837 »

r551:c6acc34f98dc

Fri, 16 Oct 2009 10:21:37

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Use pathCopy(from,to) instead of copyPath(to,from) (#321) The old version is kept as a deprecated alternative.

0 1 0

default

1 file changed with 51 insertions and 43 deletions:

lemon/path.h

↑ Collapse diff ↑

lemon/path.h

Show inline comments

@@ -61,33 +61,33 @@
 		    /// \brief Default constructor
 		    ///
 		    /// Default constructor
 		    Path() {}
 		    /// \brief Template copy constructor
 		    ///
 		    /// This constuctor initializes the path from any other path type.
 		    /// It simply makes a copy of the given path.
 		    template <typename CPath>
 		    Path(const CPath& cpath) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
+		    }
 		    /// \brief Template copy assignment
 		    ///
 		    /// This operator makes a copy of a path of any other type.
 		    template <typename CPath>
 		    Path& operator=(const CPath& cpath) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
 		      return *this;
+		    }
 		    /// \brief LEMON style iterator for path arcs
 		    ///
 		    /// This class is used to iterate on the arcs of the paths.
 		    class ArcIt {
 		      friend class Path;
 		    public:
 		      /// \brief Default constructor
 		      ArcIt() {}
 		      /// \brief Invalid constructor
@@ -249,34 +249,34 @@
 		    /// \brief Default constructor
 		    ///
 		    /// Default constructor
 		    SimplePath() {}
 		    /// \brief Template copy constructor
 		    ///
 		    /// This path can be initialized with any other path type. It just
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    SimplePath(const CPath& cpath) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
+		    }
 		    /// \brief Template copy assignment
 		    ///
 		    /// This path can be initialized with any other path type. It just
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    SimplePath& operator=(const CPath& cpath) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
 		      return *this;
+		    }
 		    /// \brief Iterator class to iterate on the arcs of the paths
 		    ///
 		    /// This class is used to iterate on the arcs of the paths
 		    ///
 		    /// Of course it converts to Digraph::Arc
 		    class ArcIt {
 		      friend class SimplePath;
 		    public:
 		      /// Default constructor
@@ -428,41 +428,41 @@
 		    /// \brief Default constructor
 		    ///
 		    /// Default constructor
 		    ListPath() : first(0), last(0) {}
 		    /// \brief Template copy constructor
 		    ///
 		    /// This path can be initialized with any other path type. It just
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    ListPath(const CPath& cpath) : first(0), last(0) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
+		    }
 		    /// \brief Destructor of the path
 		    ///
 		    /// Destructor of the path
 		    ~ListPath() {
 		      clear();
+		    }
 		    /// \brief Template copy assignment
 		    ///
 		    /// This path can be initialized with any other path type. It just
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    ListPath& operator=(const CPath& cpath) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
 		      return *this;
+		    }
 		    /// \brief Iterator class to iterate on the arcs of the paths
 		    ///
 		    /// This class is used to iterate on the arcs of the paths
 		    ///
 		    /// Of course it converts to Digraph::Arc
 		    class ArcIt {
 		      friend class ListPath;
 		    public:
 		      /// Default constructor
@@ -754,41 +754,41 @@
 		    typedef typename Digraph::Arc Arc;
 		    /// \brief Default constructor
 		    ///
 		    /// Default constructor
 		    StaticPath() : len(0), arcs(0) {}
 		    /// \brief Template copy constructor
 		    ///
 		    /// This path can be initialized from any other path type.
 		    template <typename CPath>
 		    StaticPath(const CPath& cpath) : arcs(0) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
+		    }
 		    /// \brief Destructor of the path
 		    ///
 		    /// Destructor of the path
 		    ~StaticPath() {
 		      if (arcs) delete[] arcs;
+		    }
 		    /// \brief Template copy assignment
 		    ///
 		    /// This path can be made equal to any other path type. It simply
 		    /// makes a copy of the given path.
 		    template <typename CPath>
 		    StaticPath& operator=(const CPath& cpath) {
-		      copyPath(*this, cpath);
+		      pathCopy(cpath, *this);
 		      return *this;
+		    }
 		    /// \brief Iterator class to iterate on the arcs of the paths
 		    ///
 		    /// This class is used to iterate on the arcs of the paths
 		    ///
 		    /// Of course it converts to Digraph::Arc
 		    class ArcIt {
 		      friend class StaticPath;
 		    public:
 		      /// Default constructor
@@ -919,88 +919,96 @@
 		    struct BuildTagIndicator {
 		      static const bool value = false;
 		    };
 		    template <typename Path>
 		    struct BuildTagIndicator<
 		      Path,
 		      typename enable_if<typename Path::BuildTag, void>::type
 		    > {
 		      static const bool value = true;
 		    };
 		    template <typename Target, typename Source,
 		              bool buildEnable = BuildTagIndicator<Target>::value>
 		    template <typename From, typename To,
 		              bool buildEnable = BuildTagIndicator<To>::value>
 		    struct PathCopySelectorForward {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        for (typename Source::ArcIt it(source); it != INVALID; ++it) {
 		          target.addBack(it);
 		      static void copy(const From& from, To& to) {
 		        to.clear();
 		        for (typename From::ArcIt it(from); it != INVALID; ++it) {
 		          to.addBack(it);
+		        }
+		      }
 		    };
 		    template <typename Target, typename Source>
 		    struct PathCopySelectorForward<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
-		        target.build(source);
+		    template <typename From, typename To>
 		    struct PathCopySelectorForward<From, To, true> {
 		      static void copy(const From& from, To& to) {
 		        to.clear();
 		        to.build(from);
+		      }
 		    };
 		    template <typename Target, typename Source,
 		              bool buildEnable = BuildTagIndicator<Target>::value>
 		    template <typename From, typename To,
 		              bool buildEnable = BuildTagIndicator<To>::value>
 		    struct PathCopySelectorBackward {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        for (typename Source::RevArcIt it(source); it != INVALID; ++it) {
 		          target.addFront(it);
 		      static void copy(const From& from, To& to) {
 		        to.clear();
 		        for (typename From::RevArcIt it(from); it != INVALID; ++it) {
 		          to.addFront(it);
+		        }
+		      }
 		    };
 		    template <typename Target, typename Source>
 		    struct PathCopySelectorBackward<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
-		        target.buildRev(source);
+		    template <typename From, typename To>
 		    struct PathCopySelectorBackward<From, To, true> {
 		      static void copy(const From& from, To& to) {
 		        to.clear();
 		        to.buildRev(from);
+		      }
 		    };
 		    template <typename Target, typename Source,
 		              bool revEnable = RevPathTagIndicator<Source>::value>
 		    template <typename From, typename To,
 		              bool revEnable = RevPathTagIndicator<From>::value>
 		    struct PathCopySelector {
 		      static void copy(Target& target, const Source& source) {
 		        PathCopySelectorForward<Target, Source>::copy(target, source);
 		      static void copy(const From& from, To& to) {
 		        PathCopySelectorForward<From, To>::copy(from, to);
+		      }
 		    };
 		    template <typename Target, typename Source>
 		    struct PathCopySelector<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        PathCopySelectorBackward<Target, Source>::copy(target, source);
 		    template <typename From, typename To>
 		    struct PathCopySelector<From, To, true> {
 		      static void copy(const From& from, To& to) {
 		        PathCopySelectorBackward<From, To>::copy(from, to);
+		      }
 		    };
+		  }
 		  /// \brief Make a copy of a path.
 		  ///
 		  ///  This function makes a copy of a path.
 		  template <typename Target, typename Source>
 		  void copyPath(Target& target, const Source& source) {
 		    checkConcept<concepts::PathDumper<typename Source::Digraph>, Source>();
-		    _path_bits::PathCopySelector<Target, Source>::copy(target, source);
+		  /// This function makes a copy of a path.
 		  template <typename From, typename To>
 		  void pathCopy(const From& from, To& to) {
 		    checkConcept<concepts::PathDumper<typename From::Digraph>, From>();
 		    _path_bits::PathCopySelector<From, To>::copy(from, to);
+		  }
 		  /// \brief Deprecated version of \ref pathCopy().
 		  ///
 		  /// Deprecated version of \ref pathCopy() (only for reverse compatibility).
 		  template <typename To, typename From>
 		  void copyPath(To& to, const From& from) {
 		    pathCopy(from, to);
+		  }
 		  /// \brief Check the consistency of a path.
 		  ///
 		  /// This function checks that the target of each arc is the same
 		  /// as the source of the next one.
 		  ///
 		  template <typename Digraph, typename Path>
 		  bool checkPath(const Digraph& digraph, const Path& path) {
 		    typename Path::ArcIt it(path);
 		    if (it == INVALID) return true;
 		    typename Digraph::Node node = digraph.target(it);

0 comments (0 inline)

RhodeCode

Login to your account