LEMON/LEMON-official Changeset - r552:bfe8377ba349

Repositories » LEMON » LEMON-official

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

Changeset - r552:bfe8377ba349

« 551:c6acc3
« 549:4ffd9b

866:2e9655 »

r552:bfe8377ba349

Thu, 05 Nov 2009 16:00:44

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Merge fix #321

0 1 0

merge 1.0

0 files changed with 51 insertions and 43 deletions:

lemon/path.h

↑ Collapse diff ↑

lemon/path.h

Show inline comments

@@ -65,25 +65,25 @@
 		    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;
@@ -253,26 +253,26 @@
 		    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
@@ -432,33 +432,33 @@
 		    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
@@ -758,33 +758,33 @@
 		    /// 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
@@ -923,80 +923,88 @@
 		    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>

0 comments (0 inline)

RhodeCode

Login to your account