Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 157)
+++ lemon/path.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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
@@ -94,10 +94,10 @@
       ArcIt(Invalid) : path(0), idx(-1) {}
       /// \brief Initializate the iterator to the first arc of path
-      ArcIt(const Path &_path) 
+      ArcIt(const Path &_path)
         : path(&_path), idx(_path.empty() ? -1 : 0) {}
 
     private:
 
-      ArcIt(const Path &_path, int _idx) 
+      ArcIt(const Path &_path, int _idx)
         : path(&_path), idx(_idx) {}
 
@@ -110,8 +110,8 @@
 
       /// \brief Next arc
-      ArcIt& operator++() { 
+      ArcIt& operator++() {
         ++idx;
-        if (idx >= path->length()) idx = -1; 
-        return *this; 
+        if (idx >= path->length()) idx = -1;
+        return *this;
       }
 
@@ -285,5 +285,5 @@
       ArcIt(Invalid) : path(0), idx(-1) {}
       /// \brief Initializate the constructor to the first arc of path
-      ArcIt(const SimplePath &_path) 
+      ArcIt(const SimplePath &_path)
         : path(&_path), idx(_path.empty() ? -1 : 0) {}
 
@@ -291,5 +291,5 @@
 
       /// Constructor with starting point
-      ArcIt(const SimplePath &_path, int _idx) 
+      ArcIt(const SimplePath &_path, int _idx)
         : idx(_idx), path(&_path) {}
 
@@ -302,8 +302,8 @@
 
       /// Next arc
-      ArcIt& operator++() { 
+      ArcIt& operator++() {
         ++idx;
-        if (idx >= path->length()) idx = -1; 
-        return *this; 
+        if (idx >= path->length()) idx = -1;
+        return *this;
       }
 
@@ -414,5 +414,5 @@
   protected:
 
-    // the std::list<> is incompatible 
+    // the std::list<> is incompatible
     // hard to create invalid iterator
     struct Node {
@@ -426,5 +426,5 @@
 
   public:
- 
+
     /// \brief Default constructor
     ///
@@ -471,10 +471,10 @@
       ArcIt(Invalid) : path(0), node(0) {}
       /// \brief Initializate the constructor to the first arc of path
-      ArcIt(const ListPath &_path) 
+      ArcIt(const ListPath &_path)
         : path(&_path), node(_path.first) {}
 
     protected:
 
-      ArcIt(const ListPath &_path, Node *_node) 
+      ArcIt(const ListPath &_path, Node *_node)
         : path(&_path), node(_node) {}
 
@@ -488,7 +488,7 @@
 
       /// Next arc
-      ArcIt& operator++() { 
+      ArcIt& operator++() {
         node = node->next;
-        return *this; 
+        return *this;
       }
 
@@ -758,5 +758,5 @@
     /// Default constructor
     StaticPath() : len(0), arcs(0) {}
-    
+
     /// \brief Template copy constructor
     ///
@@ -797,5 +797,5 @@
       ArcIt(Invalid) : path(0), idx(-1) {}
       /// Initializate the constructor to the first arc of path
-      ArcIt(const StaticPath &_path) 
+      ArcIt(const StaticPath &_path)
         : path(&_path), idx(_path.empty() ? -1 : 0) {}
 
@@ -803,5 +803,5 @@
 
       /// Constructor with starting point
-      ArcIt(const StaticPath &_path, int _idx) 
+      ArcIt(const StaticPath &_path, int _idx)
         : idx(_idx), path(&_path) {}
 
@@ -814,8 +814,8 @@
 
       /// Next arc
-      ArcIt& operator++() { 
+      ArcIt& operator++() {
         ++idx;
-        if (idx >= path->length()) idx = -1; 
-        return *this; 
+        if (idx >= path->length()) idx = -1;
+        return *this;
       }
 
@@ -910,5 +910,5 @@
     template <typename Path>
     struct RevPathTagIndicator<
-      Path, 
+      Path,
       typename enable_if<typename Path::RevPathTag, void>::type
       > {
@@ -923,5 +923,5 @@
     template <typename Path>
     struct BuildTagIndicator<
-      Path, 
+      Path,
       typename enable_if<typename Path::BuildTag, void>::type
     > {
@@ -930,6 +930,6 @@
 
     template <typename Target, typename Source,
-	      bool buildEnable = BuildTagIndicator<Target>::value, 
-	      bool revEnable = RevPathTagIndicator<Source>::value>
+              bool buildEnable = BuildTagIndicator<Target>::value,
+              bool revEnable = RevPathTagIndicator<Source>::value>
     struct PathCopySelector {
       static void copy(Target& target, const Source& source) {
@@ -982,6 +982,6 @@
   ///
   /// This function checks that the target of each arc is the same
-  /// as the source of the next one. 
-  /// 
+  /// as the source of the next one.
+  ///
   template <typename Digraph, typename Path>
   bool checkPath(const Digraph& digraph, const Path& path) {
@@ -1035,17 +1035,17 @@
     typedef typename Path::Digraph Digraph;
     typedef typename Digraph::Node Node;
-    
+
     /// Default constructor
     PathNodeIt() {}
     /// Invalid constructor
-    PathNodeIt(Invalid) 
+    PathNodeIt(Invalid)
       : _digraph(0), _it(INVALID), _nd(INVALID) {}
     /// Constructor
-    PathNodeIt(const Digraph& digraph, const Path& path) 
+    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) 
+    PathNodeIt(const Digraph& digraph, const Path& path, const Node& src)
       : _digraph(&digraph), _it(path), _nd(src) {}
 
@@ -1059,6 +1059,6 @@
       if (_it == INVALID) _nd = INVALID;
       else {
-	_nd = _digraph->target(_it);
-	++_it;
+        _nd = _digraph->target(_it);
+        ++_it;
       }
       return *this;
@@ -1066,18 +1066,18 @@
 
     /// Comparison operator
-    bool operator==(const PathNodeIt& n) const { 
-      return _it == n._it && _nd == n._nd; 
+    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; 
+    bool operator!=(const PathNodeIt& n) const {
+      return _it != n._it || _nd != n._nd;
     }
     /// Comparison operator
-    bool operator<(const PathNodeIt& n) const { 
+    bool operator<(const PathNodeIt& n) const {
       return (_it < n._it && _nd != INVALID);
     }
-    
+
   };
-  
+
   ///@}
 
