Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 125)
+++ lemon/concepts/digraph.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
@@ -47,5 +47,5 @@
     private:
       ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
-      
+
       ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
       ///
@@ -53,5 +53,5 @@
       ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
       ///\e not allowed. Use DigraphCopy() instead.
-      
+
       ///Assignment of \ref Digraph "Digraph"s to another ones are
       ///\e not allowed.  Use DigraphCopy() instead.
@@ -96,21 +96,21 @@
 
         /// Inequality operator
-        
+
         /// \sa operator==(Node n)
         ///
         bool operator!=(Node) const { return true; }
 
-	/// Artificial ordering operator.
-	
-	/// To allow the use of digraph descriptors as key type in std::map or
-	/// similar associative container we require this.
-	///
-	/// \note This operator only have to define some strict ordering of
-	/// the items; this order has nothing to do with the iteration
-	/// ordering of the items.
-	bool operator<(Node) const { return false; }
-
-      };
-    
+        /// Artificial ordering operator.
+
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        bool operator<(Node) const { return false; }
+
+      };
+
       /// This iterator goes through each node.
 
@@ -130,5 +130,5 @@
         NodeIt() { }
         /// Copy constructor.
-        
+
         /// Copy constructor.
         ///
@@ -146,7 +146,7 @@
         /// Node -> NodeIt conversion.
 
-        /// Sets the iterator to the node of \c the digraph pointed by 
-	/// the trivial iterator.
-        /// This feature necessitates that each time we 
+        /// Sets the iterator to the node of \c the digraph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
         NodeIt(const Digraph&, const Node&) { }
@@ -157,6 +157,6 @@
         NodeIt& operator++() { return *this; }
       };
-    
-    
+
+
       /// Class for identifying an arc of the digraph
 
@@ -192,15 +192,15 @@
         bool operator!=(Arc) const { return true; }
 
-	/// Artificial ordering operator.
-	
-	/// To allow the use of digraph descriptors as key type in std::map or
-	/// similar associative container we require this.
-	///
-	/// \note This operator only have to define some strict ordering of
-	/// the items; this order has nothing to do with the iteration
-	/// ordering of the items.
-	bool operator<(Arc) const { return false; }
-      };
-    
+        /// Artificial ordering operator.
+
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        bool operator<(Arc) const { return false; }
+      };
+
       /// This iterator goes trough the outgoing arcs of a node.
 
@@ -214,5 +214,5 @@
       /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
-    
+
       class OutArcIt : public Arc {
       public:
@@ -233,5 +233,5 @@
         OutArcIt(Invalid) { }
         /// This constructor sets the iterator to the first outgoing arc.
-    
+
         /// This constructor sets the iterator to the first outgoing arc of
         /// the node.
@@ -240,10 +240,10 @@
 
         /// Sets the iterator to the value of the trivial iterator.
-	/// This feature necessitates that each time we 
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
         OutArcIt(const Digraph&, const Arc&) { }
         ///Next outgoing arc
-        
-        /// Assign the iterator to the next 
+
+        /// Assign the iterator to the next
         /// outgoing arc of the corresponding node.
         OutArcIt& operator++() { return *this; }
@@ -280,5 +280,5 @@
         InArcIt(Invalid) { }
         /// This constructor sets the iterator to first incoming arc.
-    
+
         /// This constructor set the iterator to the first incoming arc of
         /// the node.
@@ -287,5 +287,5 @@
 
         /// Sets the iterator to the value of the trivial iterator \c e.
-        /// This feature necessitates that each time we 
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
         InArcIt(const Digraph&, const Arc&) { }
@@ -323,5 +323,5 @@
         ArcIt(Invalid) { }
         /// This constructor sets the iterator to the first arc.
-    
+
         /// This constructor sets the iterator to the first arc of \c g.
         ///@param g the digraph
@@ -330,9 +330,9 @@
 
         /// Sets the iterator to the value of the trivial iterator \c e.
-        /// This feature necessitates that each time we 
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
-        ArcIt(const Digraph&, const Arc&) { } 
+        ArcIt(const Digraph&, const Arc&) { }
         ///Next arc
-        
+
         /// Assign the iterator to the next arc.
         ArcIt& operator++() { return *this; }
@@ -350,24 +350,24 @@
 
       /// \brief Returns the ID of the node.
-      int id(Node) const { return -1; } 
+      int id(Node) const { return -1; }
 
       /// \brief Returns the ID of the arc.
-      int id(Arc) const { return -1; } 
+      int id(Arc) const { return -1; }
 
       /// \brief Returns the node with the given ID.
       ///
       /// \pre The argument should be a valid node ID in the graph.
-      Node nodeFromId(int) const { return INVALID; } 
+      Node nodeFromId(int) const { return INVALID; }
 
       /// \brief Returns the arc with the given ID.
       ///
       /// \pre The argument should be a valid arc ID in the graph.
-      Arc arcFromId(int) const { return INVALID; } 
+      Arc arcFromId(int) const { return INVALID; }
 
       /// \brief Returns an upper bound on the node IDs.
-      int maxNodeId() const { return -1; } 
+      int maxNodeId() const { return -1; }
 
       /// \brief Returns an upper bound on the arc IDs.
-      int maxArcId() const { return -1; } 
+      int maxArcId() const { return -1; }
 
       void first(Node&) const {}
@@ -390,7 +390,7 @@
 
       // Dummy parameter.
-      int maxId(Node) const { return -1; } 
+      int maxId(Node) const { return -1; }
       // Dummy parameter.
-      int maxId(Arc) const { return -1; } 
+      int maxId(Arc) const { return -1; }
 
       /// \brief The base node of the iterator.
@@ -424,8 +424,8 @@
 
       /// \brief Read write map of the nodes to type \c T.
-      /// 
+      ///
       /// ReadWrite map of the nodes to type \c T.
       /// \sa Reference
-      template<class T> 
+      template<class T>
       class NodeMap : public ReadWriteMap< Node, T > {
       public:
@@ -440,7 +440,7 @@
         ///Assignment operator
         template <typename CMap>
-        NodeMap& operator=(const CMap&) { 
+        NodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, T>, CMap>();
-          return *this; 
+          return *this;
         }
       };
@@ -450,5 +450,5 @@
       /// Reference map of the arcs to type \c T.
       /// \sa Reference
-      template<class T> 
+      template<class T>
       class ArcMap : public ReadWriteMap<Arc,T> {
       public:
@@ -462,7 +462,7 @@
         ///Assignment operator
         template <typename CMap>
-        ArcMap& operator=(const CMap&) { 
+        ArcMap& operator=(const CMap&) {
           checkConcept<ReadMap<Arc, T>, CMap>();
-          return *this; 
+          return *this;
         }
       };
@@ -472,5 +472,5 @@
         void constraints() {
           checkConcept<IterableDigraphComponent<>, _Digraph>();
-	  checkConcept<IDableDigraphComponent<>, _Digraph>();
+          checkConcept<IDableDigraphComponent<>, _Digraph>();
           checkConcept<MappableDigraphComponent<>, _Digraph>();
         }
@@ -478,6 +478,6 @@
 
     };
-    
-  } //namespace concepts  
+
+  } //namespace concepts
 } //namespace lemon
 
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 125)
+++ lemon/concepts/graph.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
@@ -66,5 +66,5 @@
     /// direction. The IncEdgeIt iterates also on the same edges
     /// as the OutArcIt and InArcIt but it is not convertible to Arc just
-    /// to Edge.  
+    /// to Edge.
     class Graph {
     public:
@@ -73,14 +73,14 @@
       ///
       /// The undirected graph should be tagged by the UndirectedTag. This
-      /// tag helps the enable_if technics to make compile time 
-      /// specializations for undirected graphs.  
+      /// tag helps the enable_if technics to make compile time
+      /// specializations for undirected graphs.
       typedef True UndirectedTag;
 
-      /// \brief The base type of node iterators, 
+      /// \brief The base type of node iterators,
       /// or in other words, the trivial node iterator.
       ///
       /// This is the base type of each node iterator,
       /// thus each kind of node iterator converts to this.
-      /// More precisely each kind of node iterator should be inherited 
+      /// More precisely each kind of node iterator should be inherited
       /// from the trivial node iterator.
       class Node {
@@ -109,21 +109,21 @@
 
         /// Inequality operator
-        
+
         /// \sa operator==(Node n)
         ///
         bool operator!=(Node) const { return true; }
 
-	/// Artificial ordering operator.
-	
-	/// To allow the use of graph descriptors as key type in std::map or
-	/// similar associative container we require this.
-	///
-	/// \note This operator only have to define some strict ordering of
-	/// the items; this order has nothing to do with the iteration
-	/// ordering of the items.
-	bool operator<(Node) const { return false; }
-
-      };
-    
+        /// Artificial ordering operator.
+
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        bool operator<(Node) const { return false; }
+
+      };
+
       /// This iterator goes through each node.
 
@@ -143,5 +143,5 @@
         NodeIt() { }
         /// Copy constructor.
-        
+
         /// Copy constructor.
         ///
@@ -159,7 +159,7 @@
         /// Node -> NodeIt conversion.
 
-        /// Sets the iterator to the node of \c the graph pointed by 
-	/// the trivial iterator.
-        /// This feature necessitates that each time we 
+        /// Sets the iterator to the node of \c the graph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
         NodeIt(const Graph&, const Node&) { }
@@ -170,6 +170,6 @@
         NodeIt& operator++() { return *this; }
       };
-    
-    
+
+
       /// The base type of the edge iterators.
 
@@ -204,13 +204,13 @@
         bool operator!=(Edge) const { return true; }
 
-	/// Artificial ordering operator.
-	
-	/// To allow the use of graph descriptors as key type in std::map or
-	/// similar associative container we require this.
-	///
-	/// \note This operator only have to define some strict ordering of
-	/// the items; this order has nothing to do with the iteration
-	/// ordering of the items.
-	bool operator<(Edge) const { return false; }
+        /// Artificial ordering operator.
+
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        bool operator<(Edge) const { return false; }
       };
 
@@ -242,5 +242,5 @@
         EdgeIt(Invalid) { }
         /// This constructor sets the iterator to the first edge.
-    
+
         /// This constructor sets the iterator to the first edge.
         EdgeIt(const Graph&) { }
@@ -249,23 +249,23 @@
         /// Sets the iterator to the value of the trivial iterator.
         /// This feature necessitates that each time we
-        /// iterate the edge-set, the iteration order is the 
-	/// same.
-        EdgeIt(const Graph&, const Edge&) { } 
+        /// iterate the edge-set, the iteration order is the
+        /// same.
+        EdgeIt(const Graph&, const Edge&) { }
         /// Next edge
-        
+
         /// Assign the iterator to the next edge.
         EdgeIt& operator++() { return *this; }
       };
 
-      /// \brief This iterator goes trough the incident undirected 
+      /// \brief This iterator goes trough the incident undirected
       /// arcs of a node.
       ///
       /// This iterator goes trough the incident edges
-      /// of a certain node of a graph. You should assume that the 
+      /// of a certain node of a graph. You should assume that the
       /// loop arcs will be iterated twice.
-      /// 
+      ///
       /// Its usage is quite simple, for example you can compute the
       /// degree (i.e. count the number of incident arcs of a node \c n
-      /// in graph \c g of type \c Graph as follows. 
+      /// in graph \c g of type \c Graph as follows.
       ///
       ///\code
@@ -291,5 +291,5 @@
         IncEdgeIt(Invalid) { }
         /// This constructor sets the iterator to first incident arc.
-    
+
         /// This constructor set the iterator to the first incident arc of
         /// the node.
@@ -298,5 +298,5 @@
 
         /// Sets the iterator to the value of the trivial iterator \c e.
-        /// This feature necessitates that each time we 
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
         IncEdgeIt(const Graph&, const Edge&) { }
@@ -304,5 +304,5 @@
 
         /// Assign the iterator to the next incident arc
-	/// of the corresponding node.
+        /// of the corresponding node.
         IncEdgeIt& operator++() { return *this; }
       };
@@ -341,15 +341,15 @@
         bool operator!=(Arc) const { return true; }
 
-	/// Artificial ordering operator.
-	
-	/// To allow the use of graph descriptors as key type in std::map or
-	/// similar associative container we require this.
-	///
-	/// \note This operator only have to define some strict ordering of
-	/// the items; this order has nothing to do with the iteration
-	/// ordering of the items.
-	bool operator<(Arc) const { return false; }
-	
-      }; 
+        /// Artificial ordering operator.
+
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        bool operator<(Arc) const { return false; }
+
+      };
       /// This iterator goes through each directed arc.
 
@@ -379,5 +379,5 @@
         ArcIt(Invalid) { }
         /// This constructor sets the iterator to the first arc.
-    
+
         /// This constructor sets the iterator to the first arc of \c g.
         ///@param g the graph
@@ -386,13 +386,13 @@
 
         /// Sets the iterator to the value of the trivial iterator \c e.
-        /// This feature necessitates that each time we 
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
-        ArcIt(const Graph&, const Arc&) { } 
+        ArcIt(const Graph&, const Arc&) { }
         ///Next arc
-        
+
         /// Assign the iterator to the next arc.
         ArcIt& operator++() { return *this; }
       };
-   
+
       /// This iterator goes trough the outgoing directed arcs of a node.
 
@@ -406,5 +406,5 @@
       /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
-    
+
       class OutArcIt : public Arc {
       public:
@@ -425,5 +425,5 @@
         OutArcIt(Invalid) { }
         /// This constructor sets the iterator to the first outgoing arc.
-    
+
         /// This constructor sets the iterator to the first outgoing arc of
         /// the node.
@@ -431,16 +431,16 @@
         ///@param g the graph
         OutArcIt(const Graph& n, const Node& g) {
-	  ignore_unused_variable_warning(n);
-	  ignore_unused_variable_warning(g);
-	}
+          ignore_unused_variable_warning(n);
+          ignore_unused_variable_warning(g);
+        }
         /// Arc -> OutArcIt conversion
 
         /// Sets the iterator to the value of the trivial iterator.
-	/// This feature necessitates that each time we 
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
         OutArcIt(const Graph&, const Arc&) { }
         ///Next outgoing arc
-        
-        /// Assign the iterator to the next 
+
+        /// Assign the iterator to the next
         /// outgoing arc of the corresponding node.
         OutArcIt& operator++() { return *this; }
@@ -477,17 +477,17 @@
         InArcIt(Invalid) { }
         /// This constructor sets the iterator to first incoming arc.
-    
+
         /// This constructor set the iterator to the first incoming arc of
         /// the node.
         ///@param n the node
         ///@param g the graph
-        InArcIt(const Graph& g, const Node& n) { 
-	  ignore_unused_variable_warning(n);
-	  ignore_unused_variable_warning(g);
-	}
+        InArcIt(const Graph& g, const Node& n) {
+          ignore_unused_variable_warning(n);
+          ignore_unused_variable_warning(g);
+        }
         /// Arc -> InArcIt conversion
 
         /// Sets the iterator to the value of the trivial iterator \c e.
-        /// This feature necessitates that each time we 
+        /// This feature necessitates that each time we
         /// iterate the arc-set, the iteration order is the same.
         InArcIt(const Graph&, const Arc&) { }
@@ -500,8 +500,8 @@
 
       /// \brief Read write map of the nodes to type \c T.
-      /// 
+      ///
       /// ReadWrite map of the nodes to type \c T.
       /// \sa Reference
-      template<class T> 
+      template<class T>
       class NodeMap : public ReadWriteMap< Node, T >
       {
@@ -517,7 +517,7 @@
         ///Assignment operator
         template <typename CMap>
-        NodeMap& operator=(const CMap&) { 
+        NodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, T>, CMap>();
-          return *this; 
+          return *this;
         }
       };
@@ -527,5 +527,5 @@
       /// Reference map of the directed arcs to type \c T.
       /// \sa Reference
-      template<class T> 
+      template<class T>
       class ArcMap : public ReadWriteMap<Arc,T>
       {
@@ -540,7 +540,7 @@
         ///Assignment operator
         template <typename CMap>
-        ArcMap& operator=(const CMap&) { 
+        ArcMap& operator=(const CMap&) {
           checkConcept<ReadMap<Arc, T>, CMap>();
-          return *this; 
+          return *this;
         }
       };
@@ -550,5 +550,5 @@
       /// Reference map of the arcs to type \c T.
       /// \sa Reference
-      template<class T> 
+      template<class T>
       class EdgeMap : public ReadWriteMap<Edge,T>
       {
@@ -563,7 +563,7 @@
         ///Assignment operator
         template <typename CMap>
-        EdgeMap& operator=(const CMap&) { 
+        EdgeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Edge, T>, CMap>();
-          return *this; 
+          return *this;
         }
       };
@@ -574,5 +574,5 @@
       /// will be the given node.
       Arc direct(const Edge&, const Node&) const {
-	return INVALID;
+        return INVALID;
       }
 
@@ -584,5 +584,5 @@
       /// the directed arc is the same when the given bool is true.
       Arc direct(const Edge&, bool) const {
-	return INVALID;
+        return INVALID;
       }
 
@@ -626,35 +626,35 @@
 
       /// \brief Returns the id of the node.
-      int id(Node) const { return -1; } 
+      int id(Node) const { return -1; }
 
       /// \brief Returns the id of the edge.
-      int id(Edge) const { return -1; } 
+      int id(Edge) const { return -1; }
 
       /// \brief Returns the id of the arc.
-      int id(Arc) const { return -1; } 
+      int id(Arc) const { return -1; }
 
       /// \brief Returns the node with the given id.
       ///
       /// \pre The argument should be a valid node id in the graph.
-      Node nodeFromId(int) const { return INVALID; } 
+      Node nodeFromId(int) const { return INVALID; }
 
       /// \brief Returns the edge with the given id.
       ///
       /// \pre The argument should be a valid edge id in the graph.
-      Edge edgeFromId(int) const { return INVALID; } 
+      Edge edgeFromId(int) const { return INVALID; }
 
       /// \brief Returns the arc with the given id.
       ///
       /// \pre The argument should be a valid arc id in the graph.
-      Arc arcFromId(int) const { return INVALID; } 
+      Arc arcFromId(int) const { return INVALID; }
 
       /// \brief Returns an upper bound on the node IDs.
-      int maxNodeId() const { return -1; } 
+      int maxNodeId() const { return -1; }
 
       /// \brief Returns an upper bound on the edge IDs.
-      int maxEdgeId() const { return -1; } 
+      int maxEdgeId() const { return -1; }
 
       /// \brief Returns an upper bound on the arc IDs.
-      int maxArcId() const { return -1; } 
+      int maxArcId() const { return -1; }
 
       void first(Node&) const {}
@@ -684,9 +684,9 @@
 
       // Dummy parameter.
-      int maxId(Node) const { return -1; } 
+      int maxId(Node) const { return -1; }
       // Dummy parameter.
-      int maxId(Edge) const { return -1; } 
+      int maxId(Edge) const { return -1; }
       // Dummy parameter.
-      int maxId(Arc) const { return -1; } 
+      int maxId(Arc) const { return -1; }
 
       /// \brief Base node of the iterator
@@ -694,5 +694,5 @@
       /// Returns the base node (the source in this case) of the iterator
       Node baseNode(OutArcIt e) const {
-	return source(e);
+        return source(e);
       }
       /// \brief Running node of the iterator
@@ -701,5 +701,5 @@
       /// iterator
       Node runningNode(OutArcIt e) const {
-	return target(e);
+        return target(e);
       }
 
@@ -708,5 +708,5 @@
       /// Returns the base node (the target in this case) of the iterator
       Node baseNode(InArcIt e) const {
-	return target(e);
+        return target(e);
       }
       /// \brief Running node of the iterator
@@ -715,5 +715,5 @@
       /// iterator
       Node runningNode(InArcIt e) const {
-	return source(e);
+        return source(e);
       }
 
@@ -722,21 +722,21 @@
       /// Returns the base node of the iterator
       Node baseNode(IncEdgeIt) const {
-	return INVALID;
+        return INVALID;
       }
-      
+
       /// \brief Running node of the iterator
       ///
       /// Returns the running node of the iterator
       Node runningNode(IncEdgeIt) const {
-	return INVALID;
+        return INVALID;
       }
 
       template <typename _Graph>
       struct Constraints {
-	void constraints() {
-	  checkConcept<IterableGraphComponent<>, _Graph>();
-	  checkConcept<IDableGraphComponent<>, _Graph>();
-	  checkConcept<MappableGraphComponent<>, _Graph>();
-	}
+        void constraints() {
+          checkConcept<IterableGraphComponent<>, _Graph>();
+          checkConcept<IDableGraphComponent<>, _Graph>();
+          checkConcept<MappableGraphComponent<>, _Graph>();
+        }
       };
 
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 169)
+++ lemon/concepts/graph_components.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
@@ -50,5 +50,5 @@
     public:
       /// \brief Default constructor.
-      ///      
+      ///
       /// \warning The default constructor is not required to set
       /// the item to some well-defined value. So you should consider it
@@ -67,5 +67,5 @@
       /// \brief Assign operator for nodes.
       ///
-      /// The nodes are assignable. 
+      /// The nodes are assignable.
       ///
       GraphItem& operator=(GraphItem const&) { return *this; }
@@ -93,25 +93,25 @@
       template<typename _GraphItem>
       struct Constraints {
-	void constraints() {
-	  _GraphItem i1;
-	  _GraphItem i2 = i1;
-	  _GraphItem i3 = INVALID;
-	  
-	  i1 = i2 = i3;
-
-	  bool b;
-	  //	  b = (ia == ib) && (ia != ib) && (ia < ib);
-	  b = (ia == ib) && (ia != ib);
-	  b = (ia == INVALID) && (ib != INVALID);
+        void constraints() {
+          _GraphItem i1;
+          _GraphItem i2 = i1;
+          _GraphItem i3 = INVALID;
+
+          i1 = i2 = i3;
+
+          bool b;
+          //          b = (ia == ib) && (ia != ib) && (ia < ib);
+          b = (ia == ib) && (ia != ib);
+          b = (ia == INVALID) && (ib != INVALID);
           b = (ia < ib);
-	}
-
-	const _GraphItem &ia;
-	const _GraphItem &ib;
+        }
+
+        const _GraphItem &ia;
+        const _GraphItem &ib;
       };
     };
 
     /// \brief An empty base directed graph class.
-    ///  
+    ///
     /// This class provides the minimal set of features needed for a
     /// directed graph structure. All digraph concepts have to be
@@ -123,8 +123,8 @@
 
       typedef BaseDigraphComponent Digraph;
-      
+
       /// \brief Node class of the digraph.
       ///
-      /// This class represents the Nodes of the digraph. 
+      /// This class represents the Nodes of the digraph.
       ///
       typedef GraphItem<'n'> Node;
@@ -132,5 +132,5 @@
       /// \brief Arc class of the digraph.
       ///
-      /// This class represents the Arcs of the digraph. 
+      /// This class represents the Arcs of the digraph.
       ///
       typedef GraphItem<'e'> Arc;
@@ -157,25 +157,25 @@
       template <typename _Digraph>
       struct Constraints {
-	typedef typename _Digraph::Node Node;
-	typedef typename _Digraph::Arc Arc;
-      
-	void constraints() {
-	  checkConcept<GraphItem<'n'>, Node>();
-	  checkConcept<GraphItem<'a'>, Arc>();
-	  {
-	    Node n;
-	    Arc e(INVALID);
-	    n = digraph.source(e);
-	    n = digraph.target(e);
+        typedef typename _Digraph::Node Node;
+        typedef typename _Digraph::Arc Arc;
+
+        void constraints() {
+          checkConcept<GraphItem<'n'>, Node>();
+          checkConcept<GraphItem<'a'>, Arc>();
+          {
+            Node n;
+            Arc e(INVALID);
+            n = digraph.source(e);
+            n = digraph.target(e);
             n = digraph.oppositeNode(n, e);
-	  }      
-	}
-      
-	const _Digraph& digraph;
+          }
+        }
+
+        const _Digraph& digraph;
       };
     };
 
     /// \brief An empty base undirected graph class.
-    ///  
+    ///
     /// This class provides the minimal set of features needed for an
     /// undirected graph structure. All undirected graph concepts have
@@ -200,5 +200,5 @@
         typedef GraphItem<'u'> Parent;
         /// \brief Default constructor.
-        ///      
+        ///
         /// \warning The default constructor is not required to set
         /// the item to some well-defined value. So you should consider it
@@ -218,10 +218,10 @@
         ///
         /// Besides the core graph item functionality each arc should
-        /// be convertible to the represented edge. 
+        /// be convertible to the represented edge.
         Edge(const Arc&) {}
         /// \brief Assign arc to edge.
         ///
         /// Besides the core graph item functionality each arc should
-        /// be convertible to the represented edge. 
+        /// be convertible to the represented edge.
         Edge& operator=(const Arc&) { return *this; }
       };
@@ -238,5 +238,5 @@
       /// Returns the directed arc from its direction and the
       /// represented edge.
-      Arc direct(const Edge&, bool) const { return INVALID;} 
+      Arc direct(const Edge&, bool) const { return INVALID;}
 
       /// \brief Returns the directed arc.
@@ -244,5 +244,5 @@
       /// Returns the directed arc from its source and the
       /// represented edge.
-      Arc direct(const Edge&, const Node&) const { return INVALID;} 
+      Arc direct(const Edge&, const Node&) const { return INVALID;}
 
       /// \brief Returns the opposite arc.
@@ -261,20 +261,20 @@
       /// Gives back the other ending of an edge.
       Node v(const Edge&) const { return INVALID;}
-      
+
       template <typename _Graph>
       struct Constraints {
-	typedef typename _Graph::Node Node;
-	typedef typename _Graph::Arc Arc;
-	typedef typename _Graph::Edge Edge;
-      
-	void constraints() {
+        typedef typename _Graph::Node Node;
+        typedef typename _Graph::Arc Arc;
+        typedef typename _Graph::Edge Edge;
+
+        void constraints() {
           checkConcept<BaseDigraphComponent, _Graph>();
-	  checkConcept<GraphItem<'u'>, Edge>();
-	  {
-	    Node n;
-	    Edge ue(INVALID);
+          checkConcept<GraphItem<'u'>, Edge>();
+          {
+            Node n;
+            Edge ue(INVALID);
             Arc e;
-	    n = graph.u(ue);
-	    n = graph.v(ue);
+            n = graph.u(ue);
+            n = graph.v(ue);
             e = graph.direct(ue, true);
             e = graph.direct(ue, n);
@@ -283,8 +283,8 @@
             bool d = graph.direction(e);
             ignore_unused_variable_warning(d);
-	  }      
-	}
-      
-	const _Graph& graph;
+          }
+        }
+
+        const _Graph& graph;
       };
 
@@ -292,5 +292,5 @@
 
     /// \brief An empty idable base digraph class.
-    ///  
+    ///
     /// This class provides beside the core digraph features
     /// core id functions for the digraph structure.
@@ -305,7 +305,7 @@
       typedef typename Base::Arc Arc;
 
-      /// \brief Gives back an unique integer id for the Node. 
-      ///
-      /// Gives back an unique integer id for the Node. 
+      /// \brief Gives back an unique integer id for the Node.
+      ///
+      /// Gives back an unique integer id for the Node.
       ///
       int id(const Node&) const { return -1;}
@@ -315,10 +315,10 @@
       /// Gives back the node by the unique id.
       /// If the digraph does not contain node with the given id
-      /// then the result of the function is undetermined. 
+      /// then the result of the function is undetermined.
       Node nodeFromId(int) const { return INVALID;}
 
-      /// \brief Gives back an unique integer id for the Arc. 
-      ///
-      /// Gives back an unique integer id for the Arc. 
+      /// \brief Gives back an unique integer id for the Arc.
+      ///
+      /// Gives back an unique integer id for the Arc.
       ///
       int id(const Arc&) const { return -1;}
@@ -328,5 +328,5 @@
       /// Gives back the arc by the unique id.
       /// If the digraph does not contain arc with the given id
-      /// then the result of the function is undetermined. 
+      /// then the result of the function is undetermined.
       Arc arcFromId(int) const { return INVALID;}
 
@@ -348,27 +348,27 @@
       struct Constraints {
 
-	void constraints() {
-	  checkConcept<Base, _Digraph >();
-	  typename _Digraph::Node node;
-	  int nid = digraph.id(node);
-	  nid = digraph.id(node);
-	  node = digraph.nodeFromId(nid);
-	  typename _Digraph::Arc arc;
-	  int eid = digraph.id(arc);
-	  eid = digraph.id(arc);
-	  arc = digraph.arcFromId(eid);
-
-	  nid = digraph.maxNodeId();
-	  ignore_unused_variable_warning(nid);
-	  eid = digraph.maxArcId();
-	  ignore_unused_variable_warning(eid);
-	}
-
-	const _Digraph& digraph;
+        void constraints() {
+          checkConcept<Base, _Digraph >();
+          typename _Digraph::Node node;
+          int nid = digraph.id(node);
+          nid = digraph.id(node);
+          node = digraph.nodeFromId(nid);
+          typename _Digraph::Arc arc;
+          int eid = digraph.id(arc);
+          eid = digraph.id(arc);
+          arc = digraph.arcFromId(eid);
+
+          nid = digraph.maxNodeId();
+          ignore_unused_variable_warning(nid);
+          eid = digraph.maxArcId();
+          ignore_unused_variable_warning(eid);
+        }
+
+        const _Digraph& digraph;
       };
     };
 
     /// \brief An empty idable base undirected graph class.
-    ///  
+    ///
     /// This class provides beside the core undirected graph features
     /// core id functions for the undirected graph structure.  The
@@ -384,7 +384,7 @@
       using IDableDigraphComponent<_Base>::id;
 
-      /// \brief Gives back an unique integer id for the Edge. 
-      ///
-      /// Gives back an unique integer id for the Edge. 
+      /// \brief Gives back an unique integer id for the Edge.
+      ///
+      /// Gives back an unique integer id for the Edge.
       ///
       int id(const Edge&) const { return -1;}
@@ -407,16 +407,16 @@
       struct Constraints {
 
-	void constraints() {
-	  checkConcept<Base, _Graph >();
-	  checkConcept<IDableDigraphComponent<Base>, _Graph >();
-	  typename _Graph::Edge edge;
-	  int ueid = graph.id(edge);
-	  ueid = graph.id(edge);
-	  edge = graph.edgeFromId(ueid);
-	  ueid = graph.maxEdgeId();
-	  ignore_unused_variable_warning(ueid);
-	}
-
-	const _Graph& graph;
+        void constraints() {
+          checkConcept<Base, _Graph >();
+          checkConcept<IDableDigraphComponent<Base>, _Graph >();
+          typename _Graph::Edge edge;
+          int ueid = graph.id(edge);
+          ueid = graph.id(edge);
+          edge = graph.edgeFromId(ueid);
+          ueid = graph.maxEdgeId();
+          ignore_unused_variable_warning(ueid);
+        }
+
+        const _Graph& graph;
       };
     };
@@ -451,37 +451,37 @@
       /// \brief Assign operator for items.
       ///
-      /// The items are assignable. 
-      ///
-      GraphItemIt& operator=(const GraphItemIt&) { return *this; }      
+      /// The items are assignable.
+      ///
+      GraphItemIt& operator=(const GraphItemIt&) { return *this; }
       /// \brief Next item.
-      /// 
+      ///
       /// Assign the iterator to the next item.
       ///
       GraphItemIt& operator++() { return *this; }
       /// \brief Equality operator
-      /// 
+      ///
       /// Two iterators are equal if and only if they point to the
       /// same object or both are invalid.
       bool operator==(const GraphItemIt&) const { return true;}
       /// \brief Inequality operator
-      ///	
+      ///
       /// \sa operator==(Node n)
       ///
       bool operator!=(const GraphItemIt&) const { return true;}
-      
+
       template<typename _GraphItemIt>
       struct Constraints {
-	void constraints() {
-	  _GraphItemIt it1(g);	
-	  _GraphItemIt it2;
-
-	  it2 = ++it1;
-	  ++it2 = it1;
-	  ++(++it1);
-
-	  _Item bi = it1;
-	  bi = it2;
-	}
-	_Graph& g;
+        void constraints() {
+          _GraphItemIt it1(g);
+          _GraphItemIt it2;
+
+          it2 = ++it1;
+          ++it2 = it1;
+          ++(++it1);
+
+          _Item bi = it1;
+          bi = it2;
+        }
+        _Graph& g;
       };
     };
@@ -490,11 +490,11 @@
     ///
     /// \note Because InArcIt and OutArcIt may not inherit from the same
-    /// base class, the _selector is a additional template parameter. For 
-    /// InArcIt you should instantiate it with character 'i' and for 
+    /// base class, the _selector is a additional template parameter. For
+    /// InArcIt you should instantiate it with character 'i' and for
     /// OutArcIt with 'o'.
     template <typename _Graph,
-	      typename _Item = typename _Graph::Arc,
-              typename _Base = typename _Graph::Node, 
-	      char _selector = '0'>
+              typename _Item = typename _Graph::Arc,
+              typename _Base = typename _Graph::Node,
+              char _selector = '0'>
     class GraphIncIt : public _Item {
     public:
@@ -509,8 +509,8 @@
       ///
       GraphIncIt(GraphIncIt const& gi) : _Item(gi) {}
-      /// \brief Sets the iterator to the first arc incoming into or outgoing 
+      /// \brief Sets the iterator to the first arc incoming into or outgoing
       /// from the node.
       ///
-      /// Sets the iterator to the first arc incoming into or outgoing 
+      /// Sets the iterator to the first arc incoming into or outgoing
       /// from the node.
       ///
@@ -523,7 +523,7 @@
       /// \brief Assign operator for iterators.
       ///
-      /// The iterators are assignable. 
-      ///
-      GraphIncIt& operator=(GraphIncIt const&) { return *this; }      
+      /// The iterators are assignable.
+      ///
+      GraphIncIt& operator=(GraphIncIt const&) { return *this; }
       /// \brief Next item.
       ///
@@ -546,21 +546,21 @@
       template <typename _GraphIncIt>
       struct Constraints {
-	void constraints() {
-	  checkConcept<GraphItem<_selector>, _GraphIncIt>();
-	  _GraphIncIt it1(graph, node);
-	  _GraphIncIt it2;
-
-	  it2 = ++it1;
-	  ++it2 = it1;
-	  ++(++it1);
-	  _Item e = it1;
-	  e = it2;
-
-	}
-
-	_Item arc;
-	_Base node;
-	_Graph graph;
-	_GraphIncIt it;
+        void constraints() {
+          checkConcept<GraphItem<_selector>, _GraphIncIt>();
+          _GraphIncIt it1(graph, node);
+          _GraphIncIt it2;
+
+          it2 = ++it1;
+          ++it2 = it1;
+          ++(++it1);
+          _Item e = it1;
+          e = it2;
+
+        }
+
+        _Item arc;
+        _Base node;
+        _Graph graph;
+        _GraphIncIt it;
       };
     };
@@ -576,5 +576,5 @@
 
     public:
-    
+
       typedef _Base Base;
       typedef typename Base::Node Node;
@@ -584,13 +584,13 @@
 
       /// \name Base iteration
-      /// 
+      ///
       /// This interface provides functions for iteration on digraph items
       ///
-      /// @{  
+      /// @{
 
       /// \brief Gives back the first node in the iterating order.
-      ///      
+      ///
       /// Gives back the first node in the iterating order.
-      ///     
+      ///
       void first(Node&) const {}
 
@@ -598,5 +598,5 @@
       ///
       /// Gives back the next node in the iterating order.
-      ///     
+      ///
       void next(Node&) const {}
 
@@ -604,5 +604,5 @@
       ///
       /// Gives back the first arc in the iterating order.
-      ///     
+      ///
       void first(Arc&) const {}
 
@@ -610,5 +610,5 @@
       ///
       /// Gives back the next arc in the iterating order.
-      ///     
+      ///
       void next(Arc&) const {}
 
@@ -618,5 +618,5 @@
       ///
       /// Gives back the first of the arcs point to the given node.
-      ///     
+      ///
       void firstIn(Arc&, const Node&) const {}
 
@@ -630,7 +630,7 @@
       /// \brief Gives back the first of the arcs start from the
       /// given node.
-      ///      
+      ///
       /// Gives back the first of the arcs start from the given node.
-      ///     
+      ///
       void firstOut(Arc&, const Node&) const {}
 
@@ -639,5 +639,5 @@
       ///
       /// Gives back the next of the arcs start from the given node.
-      ///     
+      ///
       void nextOut(Arc&) const {}
 
@@ -645,5 +645,5 @@
 
       /// \name Class based iteration
-      /// 
+      ///
       /// This interface provides functions for iteration on digraph items
       ///
@@ -700,11 +700,11 @@
       /// @}
 
-      template <typename _Digraph> 
-      struct Constraints {
-	void constraints() {
-	  checkConcept<Base, _Digraph>();
+      template <typename _Digraph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<Base, _Digraph>();
 
           {
-            typename _Digraph::Node node(INVALID);      
+            typename _Digraph::Node node(INVALID);
             typename _Digraph::Arc arc(INVALID);
             {
@@ -724,5 +724,5 @@
               digraph.nextOut(arc);
             }
-          }           
+          }
 
           {
@@ -731,7 +731,7 @@
             checkConcept<GraphItemIt<_Digraph, typename _Digraph::Node>,
               typename _Digraph::NodeIt >();
-            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc, 
+            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,
               typename _Digraph::Node, 'i'>, typename _Digraph::InArcIt>();
-            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc, 
+            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,
               typename _Digraph::Node, 'o'>, typename _Digraph::OutArcIt>();
 
@@ -746,7 +746,7 @@
           }
         }
-	
-	const _Digraph& digraph;
-	
+
+        const _Digraph& digraph;
+
       };
     };
@@ -766,11 +766,11 @@
       typedef typename Base::Edge Edge;
 
-    
+
       typedef IterableGraphComponent Graph;
 
       /// \name Base iteration
-      /// 
+      ///
       /// This interface provides functions for iteration on graph items
-      /// @{  
+      /// @{
 
       using IterableDigraphComponent<_Base>::first;
@@ -781,5 +781,5 @@
       ///
       /// Gives back the first edge in the iterating order.
-      ///     
+      ///
       void first(Edge&) const {}
 
@@ -788,5 +788,5 @@
       ///
       /// Gives back the next edge in the iterating order.
-      ///     
+      ///
       void next(Edge&) const {}
 
@@ -815,5 +815,5 @@
 
       /// \name Class based iteration
-      /// 
+      ///
       /// This interface provides functions for iteration on graph items
       ///
@@ -842,8 +842,8 @@
       /// @}
 
-      template <typename _Graph> 
-      struct Constraints {
-	void constraints() {
-	  checkConcept<IterableDigraphComponent<Base>, _Graph>();
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<IterableDigraphComponent<Base>, _Graph>();
 
           {
@@ -859,13 +859,13 @@
               graph.nextInc(edge, dir);
             }
-            
-          }	
-  
+
+          }
+
           {
             checkConcept<GraphItemIt<_Graph, typename _Graph::Edge>,
               typename _Graph::EdgeIt >();
-            checkConcept<GraphIncIt<_Graph, typename _Graph::Edge, 
+            checkConcept<GraphIncIt<_Graph, typename _Graph::Edge,
               typename _Graph::Node, 'u'>, typename _Graph::IncEdgeIt>();
-            
+
             typename _Graph::Node n;
             typename _Graph::IncEdgeIt ueit(INVALID);
@@ -874,12 +874,12 @@
           }
         }
-	
-	const _Graph& graph;
-	
+
+        const _Graph& graph;
+
       };
     };
 
     /// \brief An empty alteration notifier digraph class.
-    ///  
+    ///
     /// This class provides beside the core digraph features alteration
     /// notifier interface for the digraph structure.  This implements
@@ -898,46 +898,46 @@
 
       /// The node observer registry.
-      typedef AlterationNotifier<AlterableDigraphComponent, Node> 
+      typedef AlterationNotifier<AlterableDigraphComponent, Node>
       NodeNotifier;
       /// The arc observer registry.
-      typedef AlterationNotifier<AlterableDigraphComponent, Arc> 
+      typedef AlterationNotifier<AlterableDigraphComponent, Arc>
       ArcNotifier;
-      
+
       /// \brief Gives back the node alteration notifier.
       ///
       /// Gives back the node alteration notifier.
       NodeNotifier& notifier(Node) const {
-	return NodeNotifier();
+        return NodeNotifier();
       }
-      
+
       /// \brief Gives back the arc alteration notifier.
       ///
       /// Gives back the arc alteration notifier.
       ArcNotifier& notifier(Arc) const {
-	return ArcNotifier();
+        return ArcNotifier();
       }
 
-      template <typename _Digraph> 
-      struct Constraints {
-	void constraints() {
-	  checkConcept<Base, _Digraph>();
-          typename _Digraph::NodeNotifier& nn 
+      template <typename _Digraph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<Base, _Digraph>();
+          typename _Digraph::NodeNotifier& nn
             = digraph.notifier(typename _Digraph::Node());
 
-          typename _Digraph::ArcNotifier& en 
+          typename _Digraph::ArcNotifier& en
             = digraph.notifier(typename _Digraph::Arc());
-          
+
           ignore_unused_variable_warning(nn);
           ignore_unused_variable_warning(en);
-	}
-	
-	const _Digraph& digraph;
-	
-      };
-      
+        }
+
+        const _Digraph& digraph;
+
+      };
+
     };
 
     /// \brief An empty alteration notifier undirected graph class.
-    ///  
+    ///
     /// This class provides beside the core graph features alteration
     /// notifier interface for the graph structure.  This implements
@@ -955,31 +955,31 @@
 
       /// The arc observer registry.
-      typedef AlterationNotifier<AlterableGraphComponent, Edge> 
+      typedef AlterationNotifier<AlterableGraphComponent, Edge>
       EdgeNotifier;
-      
+
       /// \brief Gives back the arc alteration notifier.
       ///
       /// Gives back the arc alteration notifier.
       EdgeNotifier& notifier(Edge) const {
-	return EdgeNotifier();
+        return EdgeNotifier();
       }
 
-      template <typename _Graph> 
-      struct Constraints {
-	void constraints() {
-	  checkConcept<AlterableGraphComponent<Base>, _Graph>();
-          typename _Graph::EdgeNotifier& uen 
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<AlterableGraphComponent<Base>, _Graph>();
+          typename _Graph::EdgeNotifier& uen
             = graph.notifier(typename _Graph::Edge());
           ignore_unused_variable_warning(uen);
-	}
-	
-	const _Graph& graph;
-	
-      };
-      
+        }
+
+        const _Graph& graph;
+
+      };
+
     };
 
     /// \brief Class describing the concept of graph maps
-    /// 
+    ///
     /// This class describes the common interface of the graph maps
     /// (NodeMap, ArcMap), that is \ref maps-page "maps" which can be used to
@@ -1010,12 +1010,12 @@
       /// Copy Constructor.
       GraphMap(const GraphMap&) : Parent() {}
-      
+
       /// \brief Assign operator.
       ///
       /// Assign operator. It does not mofify the underlying graph,
       /// it just iterates on the current item set and set the  map
-      /// with the value returned by the assigned map. 
+      /// with the value returned by the assigned map.
       template <typename CMap>
-      GraphMap& operator=(const CMap&) { 
+      GraphMap& operator=(const CMap&) {
         checkConcept<ReadMap<Key, Value>, CMap>();
         return *this;
@@ -1024,23 +1024,23 @@
       template<typename _Map>
       struct Constraints {
-	void constraints() {
-	  checkConcept<ReadWriteMap<Key, Value>, _Map >();
-	  // Construction with a graph parameter
-	  _Map a(g);
-	  // Constructor with a graph and a default value parameter
-	  _Map a2(g,t);
-	  // Copy constructor.
-	  _Map b(c);
-          
+        void constraints() {
+          checkConcept<ReadWriteMap<Key, Value>, _Map >();
+          // Construction with a graph parameter
+          _Map a(g);
+          // Constructor with a graph and a default value parameter
+          _Map a2(g,t);
+          // Copy constructor.
+          _Map b(c);
+
           ReadMap<Key, Value> cmap;
           b = cmap;
 
-	  ignore_unused_variable_warning(a2);
-	  ignore_unused_variable_warning(b);
-	}
-
-	const _Map &c;
-	const Graph &g;
-	const typename GraphMap::Value &t;
+          ignore_unused_variable_warning(a2);
+          ignore_unused_variable_warning(b);
+        }
+
+        const _Map &c;
+        const Graph &g;
+        const typename GraphMap::Value &t;
       };
 
@@ -1071,26 +1071,26 @@
         typedef GraphMap<MappableDigraphComponent, Node, _Value> Parent;
 
-	/// \brief Construct a new map.
-	///
-	/// Construct a new map for the digraph.
-	explicit NodeMap(const MappableDigraphComponent& digraph) 
+        /// \brief Construct a new map.
+        ///
+        /// Construct a new map for the digraph.
+        explicit NodeMap(const MappableDigraphComponent& digraph)
           : Parent(digraph) {}
 
-	/// \brief Construct a new map with default value.
-	///
-	/// Construct a new map for the digraph and initalise the values.
-	NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
+        /// \brief Construct a new map with default value.
+        ///
+        /// Construct a new map for the digraph and initalise the values.
+        NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
           : Parent(digraph, value) {}
 
-	/// \brief Copy constructor.
-	///
-	/// Copy Constructor.
-	NodeMap(const NodeMap& nm) : Parent(nm) {}
-
-	/// \brief Assign operator.
-	///
-	/// Assign operator.
+        /// \brief Copy constructor.
+        ///
+        /// Copy Constructor.
+        NodeMap(const NodeMap& nm) : Parent(nm) {}
+
+        /// \brief Assign operator.
+        ///
+        /// Assign operator.
         template <typename CMap>
-        NodeMap& operator=(const CMap&) { 
+        NodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, _Value>, CMap>();
           return *this;
@@ -1108,26 +1108,26 @@
         typedef GraphMap<MappableDigraphComponent, Arc, _Value> Parent;
 
-	/// \brief Construct a new map.
-	///
-	/// Construct a new map for the digraph.
-	explicit ArcMap(const MappableDigraphComponent& digraph) 
+        /// \brief Construct a new map.
+        ///
+        /// Construct a new map for the digraph.
+        explicit ArcMap(const MappableDigraphComponent& digraph)
           : Parent(digraph) {}
 
-	/// \brief Construct a new map with default value.
-	///
-	/// Construct a new map for the digraph and initalise the values.
-	ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
+        /// \brief Construct a new map with default value.
+        ///
+        /// Construct a new map for the digraph and initalise the values.
+        ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
           : Parent(digraph, value) {}
 
-	/// \brief Copy constructor.
-	///
-	/// Copy Constructor.
-	ArcMap(const ArcMap& nm) : Parent(nm) {}
-
-	/// \brief Assign operator.
-	///
-	/// Assign operator.
+        /// \brief Copy constructor.
+        ///
+        /// Copy Constructor.
+        ArcMap(const ArcMap& nm) : Parent(nm) {}
+
+        /// \brief Assign operator.
+        ///
+        /// Assign operator.
         template <typename CMap>
-        ArcMap& operator=(const CMap&) { 
+        ArcMap& operator=(const CMap&) {
           checkConcept<ReadMap<Arc, _Value>, CMap>();
           return *this;
@@ -1140,42 +1140,42 @@
       struct Constraints {
 
-	struct Dummy {
-	  int value;
-	  Dummy() : value(0) {}
-	  Dummy(int _v) : value(_v) {}
-	};
-
-	void constraints() {
-	  checkConcept<Base, _Digraph>();
-	  { // int map test
-	    typedef typename _Digraph::template NodeMap<int> IntNodeMap;
-	    checkConcept<GraphMap<_Digraph, typename _Digraph::Node, int>, 
-	      IntNodeMap >();
-	  } { // bool map test
-	    typedef typename _Digraph::template NodeMap<bool> BoolNodeMap;
-	    checkConcept<GraphMap<_Digraph, typename _Digraph::Node, bool>,
-	      BoolNodeMap >();
-	  } { // Dummy map test
-	    typedef typename _Digraph::template NodeMap<Dummy> DummyNodeMap;
-	    checkConcept<GraphMap<_Digraph, typename _Digraph::Node, Dummy>,
-	      DummyNodeMap >();
-	  } 
-
-	  { // int map test
-	    typedef typename _Digraph::template ArcMap<int> IntArcMap;
-	    checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, int>,
-	      IntArcMap >();
-	  } { // bool map test
-	    typedef typename _Digraph::template ArcMap<bool> BoolArcMap;
-	    checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, bool>,
-	      BoolArcMap >();
-	  } { // Dummy map test
-	    typedef typename _Digraph::template ArcMap<Dummy> DummyArcMap;
-	    checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, Dummy>, 
-	      DummyArcMap >();
-	  } 
-	}
-
-	_Digraph& digraph;
+        struct Dummy {
+          int value;
+          Dummy() : value(0) {}
+          Dummy(int _v) : value(_v) {}
+        };
+
+        void constraints() {
+          checkConcept<Base, _Digraph>();
+          { // int map test
+            typedef typename _Digraph::template NodeMap<int> IntNodeMap;
+            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, int>,
+              IntNodeMap >();
+          } { // bool map test
+            typedef typename _Digraph::template NodeMap<bool> BoolNodeMap;
+            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, bool>,
+              BoolNodeMap >();
+          } { // Dummy map test
+            typedef typename _Digraph::template NodeMap<Dummy> DummyNodeMap;
+            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, Dummy>,
+              DummyNodeMap >();
+          }
+
+          { // int map test
+            typedef typename _Digraph::template ArcMap<int> IntArcMap;
+            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, int>,
+              IntArcMap >();
+          } { // bool map test
+            typedef typename _Digraph::template ArcMap<bool> BoolArcMap;
+            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, bool>,
+              BoolArcMap >();
+          } { // Dummy map test
+            typedef typename _Digraph::template ArcMap<Dummy> DummyArcMap;
+            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, Dummy>,
+              DummyArcMap >();
+          }
+        }
+
+        _Digraph& digraph;
       };
     };
@@ -1200,30 +1200,30 @@
       ///
       template <typename _Value>
-      class EdgeMap : public GraphMap<Graph, Edge, _Value> {  
+      class EdgeMap : public GraphMap<Graph, Edge, _Value> {
       public:
         typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
 
-	/// \brief Construct a new map.
-	///
-	/// Construct a new map for the graph.
-	explicit EdgeMap(const MappableGraphComponent& graph) 
+        /// \brief Construct a new map.
+        ///
+        /// Construct a new map for the graph.
+        explicit EdgeMap(const MappableGraphComponent& graph)
           : Parent(graph) {}
 
-	/// \brief Construct a new map with default value.
-	///
-	/// Construct a new map for the graph and initalise the values.
-	EdgeMap(const MappableGraphComponent& graph, const _Value& value)
+        /// \brief Construct a new map with default value.
+        ///
+        /// Construct a new map for the graph and initalise the values.
+        EdgeMap(const MappableGraphComponent& graph, const _Value& value)
           : Parent(graph, value) {}
 
-	/// \brief Copy constructor.
-	///
-	/// Copy Constructor.
-	EdgeMap(const EdgeMap& nm) : Parent(nm) {}
-
-	/// \brief Assign operator.
-	///
-	/// Assign operator.
+        /// \brief Copy constructor.
+        ///
+        /// Copy Constructor.
+        EdgeMap(const EdgeMap& nm) : Parent(nm) {}
+
+        /// \brief Assign operator.
+        ///
+        /// Assign operator.
         template <typename CMap>
-        EdgeMap& operator=(const CMap&) { 
+        EdgeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Edge, _Value>, CMap>();
           return *this;
@@ -1236,29 +1236,29 @@
       struct Constraints {
 
-	struct Dummy {
-	  int value;
-	  Dummy() : value(0) {}
-	  Dummy(int _v) : value(_v) {}
-	};
-
-	void constraints() {
-	  checkConcept<MappableGraphComponent<Base>, _Graph>();
-
-	  { // int map test
-	    typedef typename _Graph::template EdgeMap<int> IntEdgeMap;
-	    checkConcept<GraphMap<_Graph, typename _Graph::Edge, int>,
-	      IntEdgeMap >();
-	  } { // bool map test
-	    typedef typename _Graph::template EdgeMap<bool> BoolEdgeMap;
-	    checkConcept<GraphMap<_Graph, typename _Graph::Edge, bool>,
-	      BoolEdgeMap >();
-	  } { // Dummy map test
-	    typedef typename _Graph::template EdgeMap<Dummy> DummyEdgeMap;
-	    checkConcept<GraphMap<_Graph, typename _Graph::Edge, Dummy>, 
-	      DummyEdgeMap >();
-	  } 
-	}
-
-	_Graph& graph;
+        struct Dummy {
+          int value;
+          Dummy() : value(0) {}
+          Dummy(int _v) : value(_v) {}
+        };
+
+        void constraints() {
+          checkConcept<MappableGraphComponent<Base>, _Graph>();
+
+          { // int map test
+            typedef typename _Graph::template EdgeMap<int> IntEdgeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Edge, int>,
+              IntEdgeMap >();
+          } { // bool map test
+            typedef typename _Graph::template EdgeMap<bool> BoolEdgeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Edge, bool>,
+              BoolEdgeMap >();
+          } { // Dummy map test
+            typedef typename _Graph::template EdgeMap<Dummy> DummyEdgeMap;
+            checkConcept<GraphMap<_Graph, typename _Graph::Edge, Dummy>,
+              DummyEdgeMap >();
+          }
+        }
+
+        _Graph& graph;
       };
     };
@@ -1283,26 +1283,26 @@
       ///
       Node addNode() {
-	return INVALID;
+        return INVALID;
       }
-    
+
       /// \brief Adds a new arc connects the given two nodes.
       ///
       /// Adds a new arc connects the the given two nodes.
       Arc addArc(const Node&, const Node&) {
-	return INVALID;
+        return INVALID;
       }
 
       template <typename _Digraph>
       struct Constraints {
-	void constraints() {
+        void constraints() {
           checkConcept<Base, _Digraph>();
-	  typename _Digraph::Node node_a, node_b;
-	  node_a = digraph.addNode();
-	  node_b = digraph.addNode();
-	  typename _Digraph::Arc arc;
-	  arc = digraph.addArc(node_a, node_b);
-	}
-
-	_Digraph& digraph;
+          typename _Digraph::Node node_a, node_b;
+          node_a = digraph.addNode();
+          node_b = digraph.addNode();
+          typename _Digraph::Arc arc;
+          arc = digraph.addArc(node_a, node_b);
+        }
+
+        _Digraph& digraph;
       };
     };
@@ -1328,31 +1328,31 @@
       ///
       Node addNode() {
-	return INVALID;
+        return INVALID;
       }
-    
+
       /// \brief Adds a new arc connects the given two nodes.
       ///
       /// Adds a new arc connects the the given two nodes.
       Edge addArc(const Node&, const Node&) {
-	return INVALID;
+        return INVALID;
       }
 
       template <typename _Graph>
       struct Constraints {
-	void constraints() {
-	  checkConcept<Base, _Graph>();
-	  typename _Graph::Node node_a, node_b;
-	  node_a = graph.addNode();
-	  node_b = graph.addNode();
-	  typename _Graph::Edge edge;
-	  edge = graph.addEdge(node_a, node_b);
-	}
-
-	_Graph& graph;
+        void constraints() {
+          checkConcept<Base, _Graph>();
+          typename _Graph::Node node_a, node_b;
+          node_a = graph.addNode();
+          node_b = graph.addNode();
+          typename _Graph::Edge edge;
+          edge = graph.addEdge(node_a, node_b);
+        }
+
+        _Graph& graph;
       };
     };
 
     /// \brief An empty erasable digraph class.
-    ///  
+    ///
     /// This class provides beside the core digraph features core erase
     /// functions for the digraph structure. The main difference between
@@ -1369,7 +1369,7 @@
       /// \brief Erase a node from the digraph.
       ///
-      /// Erase a node from the digraph. This function should 
+      /// Erase a node from the digraph. This function should
       /// erase all arcs connecting to the node.
-      void erase(const Node&) {}    
+      void erase(const Node&) {}
 
       /// \brief Erase an arc from the digraph.
@@ -1381,18 +1381,18 @@
       template <typename _Digraph>
       struct Constraints {
-	void constraints() {
+        void constraints() {
           checkConcept<Base, _Digraph>();
-	  typename _Digraph::Node node;
-	  digraph.erase(node);
-	  typename _Digraph::Arc arc;
-	  digraph.erase(arc);
-	}
-
-	_Digraph& digraph;
+          typename _Digraph::Node node;
+          digraph.erase(node);
+          typename _Digraph::Arc arc;
+          digraph.erase(arc);
+        }
+
+        _Digraph& digraph;
       };
     };
 
     /// \brief An empty erasable base undirected graph class.
-    ///  
+    ///
     /// This class provides beside the core undirected graph features
     /// core erase functions for the undirceted graph structure. The
@@ -1411,5 +1411,5 @@
       /// Erase a node from the graph. This function should erase
       /// arcs connecting to the node.
-      void erase(const Node&) {}    
+      void erase(const Node&) {}
 
       /// \brief Erase an arc from the graph.
@@ -1421,13 +1421,13 @@
       template <typename _Graph>
       struct Constraints {
-	void constraints() {
+        void constraints() {
           checkConcept<Base, _Graph>();
-	  typename _Graph::Node node;
-	  graph.erase(node);
-	  typename _Graph::Edge edge;
-	  graph.erase(edge);
-	}
-
-	_Graph& graph;
+          typename _Graph::Node node;
+          graph.erase(node);
+          typename _Graph::Edge edge;
+          graph.erase(edge);
+        }
+
+        _Graph& graph;
       };
     };
@@ -1449,14 +1449,14 @@
       /// Erase all nodes and arcs from the digraph.
       ///
-      void clear() {}    
+      void clear() {}
 
       template <typename _Digraph>
       struct Constraints {
-	void constraints() {
+        void constraints() {
           checkConcept<Base, _Digraph>();
-	  digraph.clear();
-	}
-
-	_Digraph digraph;
+          digraph.clear();
+        }
+
+        _Digraph digraph;
       };
     };
@@ -1476,9 +1476,9 @@
       template <typename _Graph>
       struct Constraints {
-	void constraints() {
+        void constraints() {
           checkConcept<ClearableGraphComponent<Base>, _Graph>();
-	}
-
-	_Graph graph;
+        }
+
+        _Graph graph;
       };
     };
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 203)
+++ lemon/concepts/heap.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -53,12 +53,12 @@
       /// the user.
       ///
-      /// The \c ItemIntMap must be initialized in such a way, that it 
+      /// The \c ItemIntMap must be initialized in such a way, that it
       /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
       enum State {
-	IN_HEAP = 0,
-	PRE_HEAP = -1,
-	POST_HEAP = -2
+        IN_HEAP = 0,
+        PRE_HEAP = -1,
+        POST_HEAP = -2
       };
-      
+
       /// \brief The constructor.
       ///
@@ -86,6 +86,6 @@
 
       /// \brief Inserts an item into the heap with the given priority.
-      ///    
-      /// Inserts the given item into the heap with the given priority. 
+      ///
+      /// Inserts the given item into the heap with the given priority.
       /// \param i The item to insert.
       /// \param p The priority of the item.
@@ -113,10 +113,10 @@
       ///
       /// Removes the given item from the heap if it is already stored.
-      /// \param i The item to delete. 
+      /// \param i The item to delete.
       void erase(const Item &i) {}
 
       /// \brief The priority of an item.
       ///
-      /// Returns the priority of the given item.  
+      /// Returns the priority of the given item.
       /// \pre \c i must be in the heap.
       /// \param i The item.
@@ -134,5 +134,5 @@
       /// \param p The priority.
       void set(const Item &i, const Prio &p) {}
-      
+
       /// \brief Decreases the priority of an item to the given value.
       ///
@@ -175,67 +175,67 @@
       struct Constraints {
       public:
-	void constraints() {
-	  typedef typename _Heap::Item OwnItem;
-	  typedef typename _Heap::Prio OwnPrio;
-	  typedef typename _Heap::State OwnState;
-
-	  Item item;
-	  Prio prio;
-	  item=Item();
-	  prio=Prio();
-	  ignore_unused_variable_warning(item);
-	  ignore_unused_variable_warning(prio);
-
-	  OwnItem own_item;
-	  OwnPrio own_prio;
-	  OwnState own_state;
-	  own_item=Item();
-	  own_prio=Prio();
-	  ignore_unused_variable_warning(own_item);
-	  ignore_unused_variable_warning(own_prio);
-	  ignore_unused_variable_warning(own_state);
-
-	  _Heap heap1(map);
-	  _Heap heap2 = heap1;
-	  ignore_unused_variable_warning(heap1);
-	  ignore_unused_variable_warning(heap2);
-	  
-	  int s = heap.size();
-	  ignore_unused_variable_warning(s);
-	  bool e = heap.empty();
-	  ignore_unused_variable_warning(e);
-
-	  prio = heap.prio();
-	  item = heap.top();
-	  prio = heap[item];
-	  own_prio = heap.prio();
-	  own_item = heap.top();
-	  own_prio = heap[own_item];
-
-	  heap.push(item, prio);
-	  heap.push(own_item, own_prio);
-	  heap.pop();
-
-	  heap.set(item, prio);
-	  heap.decrease(item, prio);
-	  heap.increase(item, prio);
-	  heap.set(own_item, own_prio);
-	  heap.decrease(own_item, own_prio);
-	  heap.increase(own_item, own_prio);
-
-	  heap.erase(item);
-	  heap.erase(own_item);
-	  heap.clear();
-
-	  own_state = heap.state(own_item);
-	  heap.state(own_item, own_state);
-
-	  own_state = _Heap::PRE_HEAP;
-	  own_state = _Heap::IN_HEAP;
-	  own_state = _Heap::POST_HEAP;
-	}
-
-	_Heap& heap;
-	ItemIntMap& map;
+        void constraints() {
+          typedef typename _Heap::Item OwnItem;
+          typedef typename _Heap::Prio OwnPrio;
+          typedef typename _Heap::State OwnState;
+
+          Item item;
+          Prio prio;
+          item=Item();
+          prio=Prio();
+          ignore_unused_variable_warning(item);
+          ignore_unused_variable_warning(prio);
+
+          OwnItem own_item;
+          OwnPrio own_prio;
+          OwnState own_state;
+          own_item=Item();
+          own_prio=Prio();
+          ignore_unused_variable_warning(own_item);
+          ignore_unused_variable_warning(own_prio);
+          ignore_unused_variable_warning(own_state);
+
+          _Heap heap1(map);
+          _Heap heap2 = heap1;
+          ignore_unused_variable_warning(heap1);
+          ignore_unused_variable_warning(heap2);
+
+          int s = heap.size();
+          ignore_unused_variable_warning(s);
+          bool e = heap.empty();
+          ignore_unused_variable_warning(e);
+
+          prio = heap.prio();
+          item = heap.top();
+          prio = heap[item];
+          own_prio = heap.prio();
+          own_item = heap.top();
+          own_prio = heap[own_item];
+
+          heap.push(item, prio);
+          heap.push(own_item, own_prio);
+          heap.pop();
+
+          heap.set(item, prio);
+          heap.decrease(item, prio);
+          heap.increase(item, prio);
+          heap.set(own_item, own_prio);
+          heap.decrease(own_item, own_prio);
+          heap.increase(own_item, own_prio);
+
+          heap.erase(item);
+          heap.erase(own_item);
+          heap.clear();
+
+          own_state = heap.state(own_item);
+          heap.state(own_item, own_state);
+
+          own_state = _Heap::PRE_HEAP;
+          own_state = _Heap::IN_HEAP;
+          own_state = _Heap::POST_HEAP;
+        }
+
+        _Heap& heap;
+        ItemIntMap& map;
       };
     };
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 114)
+++ lemon/concepts/maps.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -48,5 +48,5 @@
 
       /// Returns the value associated with the given key.
-      Value operator[](const Key &) const { 
+      Value operator[](const Key &) const {
         return *static_cast<Value *>(0);
       }
@@ -54,18 +54,18 @@
       template<typename _ReadMap>
       struct Constraints {
-	void constraints() {
-	  Value val = m[key];
-	  val = m[key];
-	  typename _ReadMap::Value own_val = m[own_key];
-	  own_val = m[own_key];
-
-	  ignore_unused_variable_warning(key);
-	  ignore_unused_variable_warning(val);
-	  ignore_unused_variable_warning(own_key);
-	  ignore_unused_variable_warning(own_val);
-	}
-	const Key& key;
-	const typename _ReadMap::Key& own_key;
-	const _ReadMap& m;
+        void constraints() {
+          Value val = m[key];
+          val = m[key];
+          typename _ReadMap::Value own_val = m[own_key];
+          own_val = m[own_key];
+
+          ignore_unused_variable_warning(key);
+          ignore_unused_variable_warning(val);
+          ignore_unused_variable_warning(own_key);
+          ignore_unused_variable_warning(own_val);
+        }
+        const Key& key;
+        const typename _ReadMap::Key& own_key;
+        const _ReadMap& m;
       };
 
@@ -94,18 +94,18 @@
       template <typename _WriteMap>
       struct Constraints {
-	void constraints() {
-	  m.set(key, val);
-	  m.set(own_key, own_val);
-
-	  ignore_unused_variable_warning(key);
-	  ignore_unused_variable_warning(val);
-	  ignore_unused_variable_warning(own_key);
-	  ignore_unused_variable_warning(own_val);
-	}
-	const Key& key;
-	const Value& val;
-	const typename _WriteMap::Key& own_key;
-	const typename _WriteMap::Value& own_val;
-	_WriteMap& m;
+        void constraints() {
+          m.set(key, val);
+          m.set(own_key, own_val);
+
+          ignore_unused_variable_warning(key);
+          ignore_unused_variable_warning(val);
+          ignore_unused_variable_warning(own_key);
+          ignore_unused_variable_warning(own_val);
+        }
+        const Key& key;
+        const Value& val;
+        const typename _WriteMap::Key& own_key;
+        const typename _WriteMap::Value& own_val;
+        _WriteMap& m;
       };
     };
@@ -117,5 +117,5 @@
     template<typename K, typename T>
     class ReadWriteMap : public ReadMap<K,T>,
-			 public WriteMap<K,T>
+                         public WriteMap<K,T>
     {
     public:
@@ -126,5 +126,5 @@
 
       /// Returns the value associated with the given key.
-      Value operator[](const Key &) const { 
+      Value operator[](const Key &) const {
         return *static_cast<Value *>(0);
       }
@@ -135,8 +135,8 @@
       template<typename _ReadWriteMap>
       struct Constraints {
-	void constraints() {
-	  checkConcept<ReadMap<K, T>, _ReadWriteMap >();
-	  checkConcept<WriteMap<K, T>, _ReadWriteMap >();
-	}
+        void constraints() {
+          checkConcept<ReadMap<K, T>, _ReadWriteMap >();
+          checkConcept<WriteMap<K, T>, _ReadWriteMap >();
+        }
       };
     };
@@ -165,5 +165,5 @@
 
       /// Returns a reference to the value associated with the given key.
-      Reference operator[](const Key &) { 
+      Reference operator[](const Key &) {
         return *static_cast<Value *>(0);
       }
@@ -179,26 +179,26 @@
       template<typename _ReferenceMap>
       struct Constraints {
-	void constraints() {
-	  checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
-	  ref = m[key];
-	  m[key] = val;
-	  m[key] = ref;
-	  m[key] = cref;
-	  own_ref = m[own_key];
-	  m[own_key] = own_val;
-	  m[own_key] = own_ref;
-	  m[own_key] = own_cref;
-	  m[key] = m[own_key];
-	  m[own_key] = m[key];
-	}
-	const Key& key;
-	Value& val;
-	Reference ref;
-	ConstReference cref;
-	const typename _ReferenceMap::Key& own_key;
-	typename _ReferenceMap::Value& own_val;
-	typename _ReferenceMap::Reference own_ref;
-	typename _ReferenceMap::ConstReference own_cref;
-	_ReferenceMap& m;
+        void constraints() {
+          checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
+          ref = m[key];
+          m[key] = val;
+          m[key] = ref;
+          m[key] = cref;
+          own_ref = m[own_key];
+          m[own_key] = own_val;
+          m[own_key] = own_ref;
+          m[own_key] = own_cref;
+          m[key] = m[own_key];
+          m[own_key] = m[key];
+        }
+        const Key& key;
+        Value& val;
+        Reference ref;
+        ConstReference cref;
+        const typename _ReferenceMap::Key& own_key;
+        typename _ReferenceMap::Value& own_val;
+        typename _ReferenceMap::Reference own_ref;
+        typename _ReferenceMap::ConstReference own_cref;
+        _ReferenceMap& m;
       };
     };
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 157)
+++ lemon/concepts/path.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -40,5 +40,5 @@
     ///
     /// A skeleton structure for representing directed paths in a
-    /// digraph.  
+    /// digraph.
     /// \tparam _Digraph The digraph type in which the path is.
     ///
@@ -84,23 +84,23 @@
       class ArcIt {
       public:
-	/// Default constructor
-	ArcIt() {}
-	/// Invalid constructor
-	ArcIt(Invalid) {}
-	/// Constructor for first arc
-	ArcIt(const Path &) {}
+        /// Default constructor
+        ArcIt() {}
+        /// Invalid constructor
+        ArcIt(Invalid) {}
+        /// Constructor for first arc
+        ArcIt(const Path &) {}
 
         /// Conversion to Arc
-	operator Arc() const { return INVALID; }
-
-	/// Next arc
-	ArcIt& operator++() {return *this;}
-
-	/// Comparison operator
-	bool operator==(const ArcIt&) const {return true;}
-	/// Comparison operator
-	bool operator!=(const ArcIt&) const {return true;}
- 	/// Comparison operator
- 	bool operator<(const ArcIt&) const {return false;}
+        operator Arc() const { return INVALID; }
+
+        /// Next arc
+        ArcIt& operator++() {return *this;}
+
+        /// Comparison operator
+        bool operator==(const ArcIt&) const {return true;}
+        /// Comparison operator
+        bool operator!=(const ArcIt&) const {return true;}
+         /// Comparison operator
+         bool operator<(const ArcIt&) const {return false;}
 
       };
@@ -138,5 +138,5 @@
 
     namespace _path_bits {
-      
+
       template <typename _Digraph, typename _Path, typename RevPathTag = void>
       struct PathDumperConstraints {
@@ -163,5 +163,5 @@
       template <typename _Digraph, typename _Path>
       struct PathDumperConstraints<
-        _Digraph, _Path, 
+        _Digraph, _Path,
         typename enable_if<typename _Path::RevPathTag, void>::type
       > {
@@ -185,5 +185,5 @@
         _Path& p;
       };
-    
+
     }
 
@@ -210,5 +210,5 @@
     /// The paths can be constructed from any path type by a
     /// template constructor or a template assignment operator.
-    /// 
+    ///
     template <typename _Digraph>
     class PathDumper {
@@ -239,23 +239,23 @@
       class ArcIt {
       public:
-	/// Default constructor
-	ArcIt() {}
-	/// Invalid constructor
-	ArcIt(Invalid) {}
-	/// Constructor for first arc
-	ArcIt(const PathDumper&) {}
+        /// Default constructor
+        ArcIt() {}
+        /// Invalid constructor
+        ArcIt(Invalid) {}
+        /// Constructor for first arc
+        ArcIt(const PathDumper&) {}
 
         /// Conversion to Arc
-	operator Arc() const { return INVALID; }
-
-	/// Next arc
-	ArcIt& operator++() {return *this;}
-
-	/// Comparison operator
-	bool operator==(const ArcIt&) const {return true;}
-	/// Comparison operator
-	bool operator!=(const ArcIt&) const {return true;}
- 	/// Comparison operator
- 	bool operator<(const ArcIt&) const {return false;}
+        operator Arc() const { return INVALID; }
+
+        /// Next arc
+        ArcIt& operator++() {return *this;}
+
+        /// Comparison operator
+        bool operator==(const ArcIt&) const {return true;}
+        /// Comparison operator
+        bool operator!=(const ArcIt&) const {return true;}
+         /// Comparison operator
+         bool operator<(const ArcIt&) const {return false;}
 
       };
@@ -267,23 +267,23 @@
       class RevArcIt {
       public:
-	/// Default constructor
-	RevArcIt() {}
-	/// Invalid constructor
-	RevArcIt(Invalid) {}
-	/// Constructor for first arc
-	RevArcIt(const PathDumper &) {}
+        /// Default constructor
+        RevArcIt() {}
+        /// Invalid constructor
+        RevArcIt(Invalid) {}
+        /// Constructor for first arc
+        RevArcIt(const PathDumper &) {}
 
         /// Conversion to Arc
-	operator Arc() const { return INVALID; }
-
-	/// Next arc
-	RevArcIt& operator++() {return *this;}
-
-	/// Comparison operator
-	bool operator==(const RevArcIt&) const {return true;}
-	/// Comparison operator
-	bool operator!=(const RevArcIt&) const {return true;}
- 	/// Comparison operator
- 	bool operator<(const RevArcIt&) const {return false;}
+        operator Arc() const { return INVALID; }
+
+        /// Next arc
+        RevArcIt& operator++() {return *this;}
+
+        /// Comparison operator
+        bool operator==(const RevArcIt&) const {return true;}
+        /// Comparison operator
+        bool operator!=(const RevArcIt&) const {return true;}
+         /// Comparison operator
+         bool operator<(const RevArcIt&) const {return false;}
 
       };
