lemon: comparison lemon/path.h

equal deleted inserted replaced

-:c6d8db14a63b
+:6c0e05012e12
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 /// \brief Default constructor
 ArcIt() {}
 /// \brief Invalid constructor
 ArcIt(Invalid) : path(0), idx(-1) {}
 /// \brief Initializate the iterator to the first arc of path
 ArcIt(const Path &_path)
 : path(&_path), idx(_path.empty() ? -1 : 0) {}
 private:
 ArcIt(const Path &_path, int _idx)
 : path(&_path), idx(_idx) {}
 public:
 /// \brief Conversion to Arc
 operator const Arc&() const {
 return path->nth(idx);
 }
 /// \brief Next arc
 ArcIt& operator++() {
 ++idx;
 if (idx >= path->length()) idx = -1;
 return *this;
 }
 /// \brief Comparison operator
 bool operator==(const ArcIt& e) const { return idx==e.idx; }
 /// \brief Comparison operator
 /// Default constructor
 ArcIt() {}
 /// Invalid constructor
 ArcIt(Invalid) : path(0), idx(-1) {}
 /// \brief Initializate the constructor to the first arc of path
 ArcIt(const SimplePath &_path)
 : path(&_path), idx(_path.empty() ? -1 : 0) {}
 private:
 /// Constructor with starting point
 ArcIt(const SimplePath &_path, int _idx)
 : idx(_idx), path(&_path) {}
 public:
 ///Conversion to Digraph::Arc
 operator const Arc&() const {
 return path->nth(idx);
 }
 /// Next arc
 ArcIt& operator++() {
 ++idx;
 if (idx >= path->length()) idx = -1;
 return *this;
 }
 /// Comparison operator
 bool operator==(const ArcIt& e) const { return idx==e.idx; }
 /// Comparison operator
 typedef _Digraph Digraph;
 typedef typename Digraph::Arc Arc;
 protected:
 // the std::list<> is incompatible
 // hard to create invalid iterator
 struct Node {
 Arc arc;
 Node *next, *prev;
 };
 Node *first, *last;
 std::allocator<Node> alloc;
 public:
 /// \brief Default constructor
 ///
 /// Default constructor
 ListPath() : first(0), last(0) {}
 /// Default constructor
 ArcIt() {}
 /// Invalid constructor
 ArcIt(Invalid) : path(0), node(0) {}
 /// \brief Initializate the constructor to the first arc of path
 ArcIt(const ListPath &_path)
 : path(&_path), node(_path.first) {}
 protected:
 ArcIt(const ListPath &_path, Node *_node)
 : path(&_path), node(_node) {}
 public:
 operator const Arc&() const {
 return node->arc;
 }
 /// Next arc
 ArcIt& operator++() {
 node = node->next;
 return *this;
 }
 /// Comparison operator
 bool operator==(const ArcIt& e) const { return node==e.node; }
 /// Comparison operator
 /// \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) {
 /// Default constructor
 ArcIt() {}
 /// Invalid constructor
 ArcIt(Invalid) : path(0), idx(-1) {}
 /// Initializate the constructor to the first arc of path
 ArcIt(const StaticPath &_path)
 : path(&_path), idx(_path.empty() ? -1 : 0) {}
 private:
 /// Constructor with starting point
 ArcIt(const StaticPath &_path, int _idx)
 : idx(_idx), path(&_path) {}
 public:
 ///Conversion to Digraph::Arc
 operator const Arc&() const {
 return path->nth(idx);
 }
 /// Next arc
 ArcIt& operator++() {
 ++idx;
 if (idx >= path->length()) idx = -1;
 return *this;
 }
 /// Comparison operator
 bool operator==(const ArcIt& e) const { return idx==e.idx; }
 /// Comparison operator
 static const bool value = false;
 };
 template <typename Path>
 struct RevPathTagIndicator<
 Path,
 typename enable_if<typename Path::RevPathTag, void>::type
 > {
 static const bool value = true;
 };
 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,
+bool buildEnable = BuildTagIndicator<Target>::value,
-	      bool revEnable = RevPathTagIndicator<Source>::value>
+bool revEnable = RevPathTagIndicator<Source>::value>
 struct PathCopySelector {
 static void copy(Target& target, const Source& source) {
 target.clear();
 for (typename Source::ArcIt it(source); it != INVALID; ++it) {
 target.addBack(it);
 }
 /// \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);
 public:
 typedef typename Path::Digraph Digraph;
 typedef typename Digraph::Node Node;
 /// Default constructor
 PathNodeIt() {}
 /// Invalid constructor
 PathNodeIt(Invalid)
 : _digraph(0), _it(INVALID), _nd(INVALID) {}
 /// Constructor
 PathNodeIt(const Digraph& digraph, const Path& path)
 : _digraph(&digraph), _it(path) {
 _nd = (_it != INVALID ? _digraph->source(_it) : INVALID);
 }
 /// Constructor
 PathNodeIt(const Digraph& digraph, const Path& path, const Node& src)
 : _digraph(&digraph), _it(path), _nd(src) {}
 ///Conversion to Digraph::Node
 operator Node() const {
 return _nd;
 /// Next node
 PathNodeIt& operator++() {
 if (_it == INVALID) _nd = INVALID;
 else {
-	_nd = _digraph->target(_it);
+_nd = _digraph->target(_it);
-	++_it;
+++_it;
 }
 return *this;
 }
 /// Comparison operator
 bool operator==(const PathNodeIt& n) const {
 return _it == n._it && _nd == n._nd;
 }
 /// Comparison operator
 bool operator!=(const PathNodeIt& n) const {
 return _it != n._it || _nd != n._nd;
 }
 /// Comparison operator
 bool operator<(const PathNodeIt& n) const {
 return (_it < n._it && _nd != INVALID);
 }
 };
 ///@}
 } // namespace lemon
 #endif // LEMON_PATH_H

changeset 209	765619b7cbb2
parent 157	2ccc1afc2c52
child 220	a5d8c039f218