Index: lemon/graph_utils.h
===================================================================
--- lemon/graph_utils.h	(revision 199)
+++ lemon/graph_utils.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 @@
   ///This \c \#define creates convenience typedefs for the following types
   ///of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,
-  ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap, 
+  ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap,
   ///\c BoolArcMap, \c IntArcMap, \c DoubleArcMap.
   ///
@@ -53,16 +53,16 @@
   ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()
   ///macro.
-#define DIGRAPH_TYPEDEFS(Digraph)					\
-  typedef Digraph::Node Node;						\
-  typedef Digraph::NodeIt NodeIt;					\
-  typedef Digraph::Arc Arc;						\
-  typedef Digraph::ArcIt ArcIt;						\
-  typedef Digraph::InArcIt InArcIt;					\
-  typedef Digraph::OutArcIt OutArcIt;					\
-  typedef Digraph::NodeMap<bool> BoolNodeMap;				\
-  typedef Digraph::NodeMap<int> IntNodeMap;				\
-  typedef Digraph::NodeMap<double> DoubleNodeMap;			\
-  typedef Digraph::ArcMap<bool> BoolArcMap;				\
-  typedef Digraph::ArcMap<int> IntArcMap;				\
+#define DIGRAPH_TYPEDEFS(Digraph)                                        \
+  typedef Digraph::Node Node;                                                \
+  typedef Digraph::NodeIt NodeIt;                                        \
+  typedef Digraph::Arc Arc;                                                \
+  typedef Digraph::ArcIt ArcIt;                                                \
+  typedef Digraph::InArcIt InArcIt;                                        \
+  typedef Digraph::OutArcIt OutArcIt;                                        \
+  typedef Digraph::NodeMap<bool> BoolNodeMap;                                \
+  typedef Digraph::NodeMap<int> IntNodeMap;                                \
+  typedef Digraph::NodeMap<double> DoubleNodeMap;                        \
+  typedef Digraph::ArcMap<bool> BoolArcMap;                                \
+  typedef Digraph::ArcMap<int> IntArcMap;                                \
   typedef Digraph::ArcMap<double> DoubleArcMap
 
@@ -73,18 +73,18 @@
   ///\note Use this macro, if the graph type is a dependent type,
   ///ie. the graph type depend on a template parameter.
-#define TEMPLATE_DIGRAPH_TYPEDEFS(Digraph)				\
-  typedef typename Digraph::Node Node;					\
-  typedef typename Digraph::NodeIt NodeIt;				\
-  typedef typename Digraph::Arc Arc;					\
-  typedef typename Digraph::ArcIt ArcIt;				\
-  typedef typename Digraph::InArcIt InArcIt;				\
-  typedef typename Digraph::OutArcIt OutArcIt;				\
-  typedef typename Digraph::template NodeMap<bool> BoolNodeMap;		\
-  typedef typename Digraph::template NodeMap<int> IntNodeMap;		\
-  typedef typename Digraph::template NodeMap<double> DoubleNodeMap;	\
-  typedef typename Digraph::template ArcMap<bool> BoolArcMap;		\
-  typedef typename Digraph::template ArcMap<int> IntArcMap;		\
+#define TEMPLATE_DIGRAPH_TYPEDEFS(Digraph)                                \
+  typedef typename Digraph::Node Node;                                        \
+  typedef typename Digraph::NodeIt NodeIt;                                \
+  typedef typename Digraph::Arc Arc;                                        \
+  typedef typename Digraph::ArcIt ArcIt;                                \
+  typedef typename Digraph::InArcIt InArcIt;                                \
+  typedef typename Digraph::OutArcIt OutArcIt;                                \
+  typedef typename Digraph::template NodeMap<bool> BoolNodeMap;                \
+  typedef typename Digraph::template NodeMap<int> IntNodeMap;                \
+  typedef typename Digraph::template NodeMap<double> DoubleNodeMap;        \
+  typedef typename Digraph::template ArcMap<bool> BoolArcMap;                \
+  typedef typename Digraph::template ArcMap<int> IntArcMap;                \
   typedef typename Digraph::template ArcMap<double> DoubleArcMap
-  
+
   ///Creates convenience typedefs for the graph types and iterators
 
@@ -97,11 +97,11 @@
   ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()
   ///macro.
-#define GRAPH_TYPEDEFS(Graph)						\
-  DIGRAPH_TYPEDEFS(Graph);						\
-  typedef Graph::Edge Edge;						\
-  typedef Graph::EdgeIt EdgeIt;						\
-  typedef Graph::IncEdgeIt IncEdgeIt;					\
-  typedef Graph::EdgeMap<bool> BoolEdgeMap;				\
-  typedef Graph::EdgeMap<int> IntEdgeMap;				\
+#define GRAPH_TYPEDEFS(Graph)                                                \
+  DIGRAPH_TYPEDEFS(Graph);                                                \
+  typedef Graph::Edge Edge;                                                \
+  typedef Graph::EdgeIt EdgeIt;                                                \
+  typedef Graph::IncEdgeIt IncEdgeIt;                                        \
+  typedef Graph::EdgeMap<bool> BoolEdgeMap;                                \
+  typedef Graph::EdgeMap<int> IntEdgeMap;                                \
   typedef Graph::EdgeMap<double> DoubleEdgeMap
 
@@ -112,11 +112,11 @@
   ///\note Use this macro, if the graph type is a dependent type,
   ///ie. the graph type depend on a template parameter.
-#define TEMPLATE_GRAPH_TYPEDEFS(Graph)					\
-  TEMPLATE_DIGRAPH_TYPEDEFS(Graph);					\
-  typedef typename Graph::Edge Edge;					\
-  typedef typename Graph::EdgeIt EdgeIt;				\
-  typedef typename Graph::IncEdgeIt IncEdgeIt;				\
-  typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;		\
-  typedef typename Graph::template EdgeMap<int> IntEdgeMap;		\
+#define TEMPLATE_GRAPH_TYPEDEFS(Graph)                                        \
+  TEMPLATE_DIGRAPH_TYPEDEFS(Graph);                                        \
+  typedef typename Graph::Edge Edge;                                        \
+  typedef typename Graph::EdgeIt EdgeIt;                                \
+  typedef typename Graph::IncEdgeIt IncEdgeIt;                                \
+  typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;                \
+  typedef typename Graph::template EdgeMap<int> IntEdgeMap;                \
   typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
 
@@ -139,5 +139,5 @@
 
   namespace _graph_utils_bits {
-    
+
     template <typename Graph, typename Enable = void>
     struct CountNodesSelector {
@@ -149,11 +149,11 @@
     template <typename Graph>
     struct CountNodesSelector<
-      Graph, typename 
-      enable_if<typename Graph::NodeNumTag, void>::type> 
+      Graph, typename
+      enable_if<typename Graph::NodeNumTag, void>::type>
     {
       static int count(const Graph &g) {
         return g.nodeNum();
       }
-    };    
+    };
   }
 
@@ -164,5 +164,5 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// If the graph contains a \e nodeNum() member function and a 
+  /// If the graph contains a \e nodeNum() member function and a
   /// \e NodeNumTag tag then this function calls directly the member
   /// function to query the cardinality of the node set.
@@ -175,5 +175,5 @@
 
   namespace _graph_utils_bits {
-    
+
     template <typename Graph, typename Enable = void>
     struct CountArcsSelector {
@@ -185,11 +185,11 @@
     template <typename Graph>
     struct CountArcsSelector<
-      Graph, 
-      typename enable_if<typename Graph::ArcNumTag, void>::type> 
+      Graph,
+      typename enable_if<typename Graph::ArcNumTag, void>::type>
     {
       static int count(const Graph &g) {
         return g.arcNum();
       }
-    };    
+    };
   }
 
@@ -200,5 +200,5 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// If the graph contains a \e arcNum() member function and a 
+  /// If the graph contains a \e arcNum() member function and a
   /// \e EdgeNumTag tag then this function calls directly the member
   /// function to query the cardinality of the arc set.
@@ -210,5 +210,5 @@
   // Edge counting:
   namespace _graph_utils_bits {
-    
+
     template <typename Graph, typename Enable = void>
     struct CountEdgesSelector {
@@ -220,11 +220,11 @@
     template <typename Graph>
     struct CountEdgesSelector<
-      Graph, 
-      typename enable_if<typename Graph::EdgeNumTag, void>::type> 
+      Graph,
+      typename enable_if<typename Graph::EdgeNumTag, void>::type>
     {
       static int count(const Graph &g) {
         return g.edgeNum();
       }
-    };    
+    };
   }
 
@@ -235,5 +235,5 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// If the graph contains a \e edgeNum() member function and a 
+  /// If the graph contains a \e edgeNum() member function and a
   /// \e EdgeNumTag tag then this function calls directly the member
   /// function to query the cardinality of the edge set.
@@ -257,5 +257,5 @@
   ///
   /// This function counts the number of the out-arcs from node \c n
-  /// in the graph.  
+  /// in the graph.
   template <typename Graph>
   inline int countOutArcs(const Graph& _g,  const typename Graph::Node& _n) {
@@ -266,5 +266,5 @@
   ///
   /// This function counts the number of the in-arcs to node \c n
-  /// in the graph.  
+  /// in the graph.
   template <typename Graph>
   inline int countInArcs(const Graph& _g,  const typename Graph::Node& _n) {
@@ -275,5 +275,5 @@
   ///
   /// This function counts the number of the inc-edges to node \c n
-  /// in the graph.  
+  /// in the graph.
   template <typename Graph>
   inline int countIncEdges(const Graph& _g,  const typename Graph::Node& _n) {
@@ -282,5 +282,5 @@
 
   namespace _graph_utils_bits {
-    
+
     template <typename Graph, typename Enable = void>
     struct FindArcSelector {
@@ -302,6 +302,6 @@
     template <typename Graph>
     struct FindArcSelector<
-      Graph, 
-      typename enable_if<typename Graph::FindEdgeTag, void>::type> 
+      Graph,
+      typename enable_if<typename Graph::FindEdgeTag, void>::type>
     {
       typedef typename Graph::Node Node;
@@ -310,5 +310,5 @@
         return g.findArc(u, v, prev);
       }
-    };    
+    };
   }
 
@@ -334,5 +334,5 @@
   ///\sa ConArcIt
   template <typename Graph>
-  inline typename Graph::Arc 
+  inline typename Graph::Arc
   findArc(const Graph &g, typename Graph::Node u, typename Graph::Node v,
            typename Graph::Arc prev = INVALID) {
@@ -342,5 +342,5 @@
   /// \brief Iterator for iterating on arcs connected the same nodes.
   ///
-  /// Iterator for iterating on arcs connected the same nodes. It is 
+  /// Iterator for iterating on arcs connected the same nodes. It is
   /// higher level interface for the findArc() function. You can
   /// use it the following way:
@@ -350,5 +350,5 @@
   /// }
   ///\endcode
-  /// 
+  ///
   ///\sa findArc()
   ///\sa ArcLookUp
@@ -375,14 +375,14 @@
     /// \brief Constructor.
     ///
-    /// Construct a new ConArcIt which continues the iterating from 
+    /// Construct a new ConArcIt which continues the iterating from
     /// the \c e arc.
     ConArcIt(const Graph& g, Arc a) : Parent(a), _graph(g) {}
-    
+
     /// \brief Increment operator.
     ///
     /// It increments the iterator and gives back the next arc.
     ConArcIt& operator++() {
-      Parent::operator=(findArc(_graph, _graph.source(*this), 
-				_graph.target(*this), *this));
+      Parent::operator=(findArc(_graph, _graph.source(*this),
+                                _graph.target(*this), *this));
       return *this;
     }
@@ -392,5 +392,5 @@
 
   namespace _graph_utils_bits {
-    
+
     template <typename Graph, typename Enable = void>
     struct FindEdgeSelector {
@@ -426,6 +426,6 @@
     template <typename Graph>
     struct FindEdgeSelector<
-      Graph, 
-      typename enable_if<typename Graph::FindEdgeTag, void>::type> 
+      Graph,
+      typename enable_if<typename Graph::FindEdgeTag, void>::type>
     {
       typedef typename Graph::Node Node;
@@ -434,5 +434,5 @@
         return g.findEdge(u, v, prev);
       }
-    };    
+    };
   }
 
@@ -450,5 +450,5 @@
   /// Thus you can iterate through each arc from \c u to \c v as it follows.
   ///\code
-  /// for(Edge e = findEdge(g,u,v); e != INVALID; 
+  /// for(Edge e = findEdge(g,u,v); e != INVALID;
   ///     e = findEdge(g,u,v,e)) {
   ///   ...
@@ -459,5 +459,5 @@
 
   template <typename Graph>
-  inline typename Graph::Edge 
+  inline typename Graph::Edge
   findEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,
             typename Graph::Edge p = INVALID) {
@@ -467,5 +467,5 @@
   /// \brief Iterator for iterating on edges connected the same nodes.
   ///
-  /// Iterator for iterating on edges connected the same nodes. It is 
+  /// Iterator for iterating on edges connected the same nodes. It is
   /// higher level interface for the findEdge() function. You can
   /// use it the following way:
@@ -497,14 +497,14 @@
     /// \brief Constructor.
     ///
-    /// Construct a new ConEdgeIt which continues the iterating from 
+    /// Construct a new ConEdgeIt which continues the iterating from
     /// the \c e edge.
     ConEdgeIt(const Graph& g, Edge e) : Parent(e), _graph(g) {}
-    
+
     /// \brief Increment operator.
     ///
     /// It increments the iterator and gives back the next edge.
     ConEdgeIt& operator++() {
-      Parent::operator=(findEdge(_graph, _graph.u(*this), 
-				 _graph.v(*this), *this));
+      Parent::operator=(findEdge(_graph, _graph.u(*this),
+                                 _graph.v(*this), *this));
       return *this;
     }
@@ -519,16 +519,16 @@
     public:
       virtual void copy(const Digraph& from, const RefMap& refMap) = 0;
-      
+
       virtual ~MapCopyBase() {}
     };
 
-    template <typename Digraph, typename Item, typename RefMap, 
+    template <typename Digraph, typename Item, typename RefMap,
               typename ToMap, typename FromMap>
     class MapCopy : public MapCopyBase<Digraph, Item, RefMap> {
     public:
 
-      MapCopy(ToMap& tmap, const FromMap& map) 
+      MapCopy(ToMap& tmap, const FromMap& map)
         : _tmap(tmap), _map(map) {}
-      
+
       virtual void copy(const Digraph& digraph, const RefMap& refMap) {
         typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
@@ -548,5 +548,5 @@
 
       ItemCopy(It& it, const Item& item) : _it(it), _item(item) {}
-      
+
       virtual void copy(const Digraph&, const RefMap& refMap) {
         _it = refMap[_item];
@@ -563,5 +563,5 @@
 
       RefCopy(Ref& map) : _map(map) {}
-      
+
       virtual void copy(const Digraph& digraph, const RefMap& refMap) {
         typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
@@ -575,5 +575,5 @@
     };
 
-    template <typename Digraph, typename Item, typename RefMap, 
+    template <typename Digraph, typename Item, typename RefMap,
               typename CrossRef>
     class CrossRefCopy : public MapCopyBase<Digraph, Item, RefMap> {
@@ -581,5 +581,5 @@
 
       CrossRefCopy(CrossRef& cmap) : _cmap(cmap) {}
-      
+
       virtual void copy(const Digraph& digraph, const RefMap& refMap) {
         typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
@@ -602,6 +602,6 @@
         }
         for (typename From::ArcIt it(from); it != INVALID; ++it) {
-          arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)], 
-				    nodeRefMap[from.target(it)]);
+          arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)],
+                                    nodeRefMap[from.target(it)]);
         }
       }
@@ -610,6 +610,6 @@
     template <typename Digraph>
     struct DigraphCopySelector<
-      Digraph, 
-      typename enable_if<typename Digraph::BuildTag, void>::type> 
+      Digraph,
+      typename enable_if<typename Digraph::BuildTag, void>::type>
     {
       template <typename From, typename NodeRefMap, typename ArcRefMap>
@@ -629,6 +629,6 @@
         }
         for (typename From::EdgeIt it(from); it != INVALID; ++it) {
-          edgeRefMap[it] = to.addEdge(nodeRefMap[from.u(it)], 
-				      nodeRefMap[from.v(it)]);
+          edgeRefMap[it] = to.addEdge(nodeRefMap[from.u(it)],
+                                      nodeRefMap[from.v(it)]);
         }
       }
@@ -637,6 +637,6 @@
     template <typename Graph>
     struct GraphCopySelector<
-      Graph, 
-      typename enable_if<typename Graph::BuildTag, void>::type> 
+      Graph,
+      typename enable_if<typename Graph::BuildTag, void>::type>
     {
       template <typename From, typename NodeRefMap, typename EdgeRefMap>
@@ -698,7 +698,7 @@
     typedef typename From::template NodeMap<TNode> NodeRefMap;
     typedef typename From::template ArcMap<TArc> ArcRefMap;
-    
-    
-  public: 
+
+
+  public:
 
 
@@ -707,5 +707,5 @@
     /// It copies the content of the \c _from digraph into the
     /// \c _to digraph.
-    DigraphCopy(To& to, const From& from) 
+    DigraphCopy(To& to, const From& from)
       : _from(from), _to(to) {}
 
@@ -731,6 +731,6 @@
     template <typename NodeRef>
     DigraphCopy& nodeRef(NodeRef& map) {
-      _node_maps.push_back(new _graph_utils_bits::RefCopy<From, Node, 
-			   NodeRefMap, NodeRef>(map));
+      _node_maps.push_back(new _graph_utils_bits::RefCopy<From, Node,
+                           NodeRefMap, NodeRef>(map));
       return *this;
     }
@@ -745,5 +745,5 @@
     DigraphCopy& nodeCrossRef(NodeCrossRef& map) {
       _node_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
-			   NodeRefMap, NodeCrossRef>(map));
+                           NodeRefMap, NodeCrossRef>(map));
       return *this;
     }
@@ -756,6 +756,6 @@
     template <typename ToMap, typename FromMap>
     DigraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
-      _node_maps.push_back(new _graph_utils_bits::MapCopy<From, Node, 
-			   NodeRefMap, ToMap, FromMap>(tmap, map));
+      _node_maps.push_back(new _graph_utils_bits::MapCopy<From, Node,
+                           NodeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -765,6 +765,6 @@
     /// Make a copy of the given node.
     DigraphCopy& node(TNode& tnode, const Node& snode) {
-      _node_maps.push_back(new _graph_utils_bits::ItemCopy<From, Node, 
-			   NodeRefMap, TNode>(tnode, snode));
+      _node_maps.push_back(new _graph_utils_bits::ItemCopy<From, Node,
+                           NodeRefMap, TNode>(tnode, snode));
       return *this;
     }
@@ -775,6 +775,6 @@
     template <typename ArcRef>
     DigraphCopy& arcRef(ArcRef& map) {
-      _arc_maps.push_back(new _graph_utils_bits::RefCopy<From, Arc, 
-			  ArcRefMap, ArcRef>(map));
+      _arc_maps.push_back(new _graph_utils_bits::RefCopy<From, Arc,
+                          ArcRefMap, ArcRef>(map));
       return *this;
     }
@@ -787,5 +787,5 @@
     DigraphCopy& arcCrossRef(ArcCrossRef& map) {
       _arc_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Arc,
-			  ArcRefMap, ArcCrossRef>(map));
+                          ArcRefMap, ArcCrossRef>(map));
       return *this;
     }
@@ -793,12 +793,12 @@
     /// \brief Make copy of the given map.
     ///
-    /// Makes copy of the given map for the newly created digraph. 
+    /// Makes copy of the given map for the newly created digraph.
     /// The new map's key type is the to digraph's arc type,
     /// and the copied map's key type is the from digraph's arc
-    /// type.  
+    /// type.
     template <typename ToMap, typename FromMap>
     DigraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
-      _arc_maps.push_back(new _graph_utils_bits::MapCopy<From, Arc, 
-			  ArcRefMap, ToMap, FromMap>(tmap, map));
+      _arc_maps.push_back(new _graph_utils_bits::MapCopy<From, Arc,
+                          ArcRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -808,6 +808,6 @@
     /// Make a copy of the given arc.
     DigraphCopy& arc(TArc& tarc, const Arc& sarc) {
-      _arc_maps.push_back(new _graph_utils_bits::ItemCopy<From, Arc, 
-			  ArcRefMap, TArc>(tarc, sarc));
+      _arc_maps.push_back(new _graph_utils_bits::ItemCopy<From, Arc,
+                          ArcRefMap, TArc>(tarc, sarc));
       return *this;
     }
@@ -826,5 +826,5 @@
       for (int i = 0; i < int(_arc_maps.size()); ++i) {
         _arc_maps[i]->copy(_from, arcRefMap);
-      }      
+      }
     }
 
@@ -835,8 +835,8 @@
     To& _to;
 
-    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
     _node_maps;
 
-    std::vector<_graph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* >
     _arc_maps;
 
@@ -851,5 +851,5 @@
   /// copyDigraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
   ///\endcode
-  /// 
+  ///
   /// After the copy the \c nr map will contain the mapping from the
   /// nodes of the \c from digraph to the nodes of the \c to digraph and
@@ -857,5 +857,5 @@
   /// to the arcs of the \c from digraph.
   ///
-  /// \see DigraphCopy 
+  /// \see DigraphCopy
   template <typename To, typename From>
   DigraphCopy<To, From> copyDigraph(To& to, const From& from) {
@@ -918,6 +918,6 @@
     struct ArcRefMap {
       ArcRefMap(const To& to, const From& from,
-		const EdgeRefMap& edge_ref, const NodeRefMap& node_ref) 
-        : _to(to), _from(from), 
+                const EdgeRefMap& edge_ref, const NodeRefMap& node_ref)
+        : _to(to), _from(from),
           _edge_ref(edge_ref), _node_ref(node_ref) {}
 
@@ -927,10 +927,10 @@
       Value operator[](const Key& key) const {
         bool forward = _from.u(key) != _from.v(key) ?
-	  _node_ref[_from.source(key)] == 
-	  _to.source(_to.direct(_edge_ref[key], true)) :
-	  _from.direction(key);
-	return _to.direct(_edge_ref[key], forward); 
-      }
-      
+          _node_ref[_from.source(key)] ==
+          _to.source(_to.direct(_edge_ref[key], true)) :
+          _from.direction(key);
+        return _to.direct(_edge_ref[key], forward);
+      }
+
       const To& _to;
       const From& _from;
@@ -939,6 +939,6 @@
     };
 
-    
-  public: 
+
+  public:
 
 
@@ -947,5 +947,5 @@
     /// It copies the content of the \c _from graph into the
     /// \c _to graph.
-    GraphCopy(To& to, const From& from) 
+    GraphCopy(To& to, const From& from)
       : _from(from), _to(to) {}
 
@@ -971,6 +971,6 @@
     template <typename NodeRef>
     GraphCopy& nodeRef(NodeRef& map) {
-      _node_maps.push_back(new _graph_utils_bits::RefCopy<From, Node, 
-			   NodeRefMap, NodeRef>(map));
+      _node_maps.push_back(new _graph_utils_bits::RefCopy<From, Node,
+                           NodeRefMap, NodeRef>(map));
       return *this;
     }
@@ -983,5 +983,5 @@
     GraphCopy& nodeCrossRef(NodeCrossRef& map) {
       _node_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
-			   NodeRefMap, NodeCrossRef>(map));
+                           NodeRefMap, NodeCrossRef>(map));
       return *this;
     }
@@ -989,12 +989,12 @@
     /// \brief Make copy of the given map.
     ///
-    /// Makes copy of the given map for the newly created graph. 
+    /// Makes copy of the given map for the newly created graph.
     /// The new map's key type is the to graph's node type,
     /// and the copied map's key type is the from graph's node
-    /// type.  
+    /// type.
     template <typename ToMap, typename FromMap>
     GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
-      _node_maps.push_back(new _graph_utils_bits::MapCopy<From, Node, 
-			   NodeRefMap, ToMap, FromMap>(tmap, map));
+      _node_maps.push_back(new _graph_utils_bits::MapCopy<From, Node,
+                           NodeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1004,6 +1004,6 @@
     /// Make a copy of the given node.
     GraphCopy& node(TNode& tnode, const Node& snode) {
-      _node_maps.push_back(new _graph_utils_bits::ItemCopy<From, Node, 
-			   NodeRefMap, TNode>(tnode, snode));
+      _node_maps.push_back(new _graph_utils_bits::ItemCopy<From, Node,
+                           NodeRefMap, TNode>(tnode, snode));
       return *this;
     }
@@ -1014,6 +1014,6 @@
     template <typename ArcRef>
     GraphCopy& arcRef(ArcRef& map) {
-      _arc_maps.push_back(new _graph_utils_bits::RefCopy<From, Arc, 
-			  ArcRefMap, ArcRef>(map));
+      _arc_maps.push_back(new _graph_utils_bits::RefCopy<From, Arc,
+                          ArcRefMap, ArcRef>(map));
       return *this;
     }
@@ -1026,5 +1026,5 @@
     GraphCopy& arcCrossRef(ArcCrossRef& map) {
       _arc_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Arc,
-			  ArcRefMap, ArcCrossRef>(map));
+                          ArcRefMap, ArcCrossRef>(map));
       return *this;
     }
@@ -1032,12 +1032,12 @@
     /// \brief Make copy of the given map.
     ///
-    /// Makes copy of the given map for the newly created graph. 
+    /// Makes copy of the given map for the newly created graph.
     /// The new map's key type is the to graph's arc type,
     /// and the copied map's key type is the from graph's arc
-    /// type.  
+    /// type.
     template <typename ToMap, typename FromMap>
     GraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
-      _arc_maps.push_back(new _graph_utils_bits::MapCopy<From, Arc, 
-			  ArcRefMap, ToMap, FromMap>(tmap, map));
+      _arc_maps.push_back(new _graph_utils_bits::MapCopy<From, Arc,
+                          ArcRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1047,6 +1047,6 @@
     /// Make a copy of the given arc.
     GraphCopy& arc(TArc& tarc, const Arc& sarc) {
-      _arc_maps.push_back(new _graph_utils_bits::ItemCopy<From, Arc, 
-			  ArcRefMap, TArc>(tarc, sarc));
+      _arc_maps.push_back(new _graph_utils_bits::ItemCopy<From, Arc,
+                          ArcRefMap, TArc>(tarc, sarc));
       return *this;
     }
@@ -1057,6 +1057,6 @@
     template <typename EdgeRef>
     GraphCopy& edgeRef(EdgeRef& map) {
-      _edge_maps.push_back(new _graph_utils_bits::RefCopy<From, Edge, 
-			   EdgeRefMap, EdgeRef>(map));
+      _edge_maps.push_back(new _graph_utils_bits::RefCopy<From, Edge,
+                           EdgeRefMap, EdgeRef>(map));
       return *this;
     }
@@ -1068,6 +1068,6 @@
     template <typename EdgeCrossRef>
     GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-      _edge_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, 
-			   Edge, EdgeRefMap, EdgeCrossRef>(map));
+      _edge_maps.push_back(new _graph_utils_bits::CrossRefCopy<From,
+                           Edge, EdgeRefMap, EdgeCrossRef>(map));
       return *this;
     }
@@ -1075,12 +1075,12 @@
     /// \brief Make copy of the given map.
     ///
-    /// Makes copy of the given map for the newly created graph. 
+    /// Makes copy of the given map for the newly created graph.
     /// The new map's key type is the to graph's edge type,
     /// and the copied map's key type is the from graph's edge
-    /// type.  
+    /// type.
     template <typename ToMap, typename FromMap>
     GraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
-      _edge_maps.push_back(new _graph_utils_bits::MapCopy<From, Edge, 
-			   EdgeRefMap, ToMap, FromMap>(tmap, map));
+      _edge_maps.push_back(new _graph_utils_bits::MapCopy<From, Edge,
+                           EdgeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1090,6 +1090,6 @@
     /// Make a copy of the given edge.
     GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
-      _edge_maps.push_back(new _graph_utils_bits::ItemCopy<From, Edge, 
-			   EdgeRefMap, TEdge>(tedge, sedge));
+      _edge_maps.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
+                           EdgeRefMap, TEdge>(tedge, sedge));
       return *this;
     }
@@ -1116,15 +1116,15 @@
 
   private:
-    
+
     const From& _from;
     To& _to;
 
-    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
     _node_maps;
 
-    std::vector<_graph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* >
     _arc_maps;
 
-    std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
     _edge_maps;
 
@@ -1139,5 +1139,5 @@
   /// copyGraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
   ///\endcode
-  /// 
+  ///
   /// After the copy the \c nr map will contain the mapping from the
   /// nodes of the \c from graph to the nodes of the \c to graph and
@@ -1145,7 +1145,7 @@
   /// to the arcs of the \c from graph.
   ///
-  /// \see GraphCopy 
+  /// \see GraphCopy
   template <typename To, typename From>
-  GraphCopy<To, From> 
+  GraphCopy<To, From>
   copyGraph(To& to, const From& from) {
     return GraphCopy<To, From>(to, from);
@@ -1215,5 +1215,5 @@
       ///
       /// Gives back the given item from its id.
-      /// 
+      ///
       Item operator[](int id) const { return _graph->fromId(id, Item());}
 
@@ -1225,13 +1225,13 @@
     ///
     /// Gives back the inverse of the IdMap.
-    InverseMap inverse() const { return InverseMap(*_graph);} 
+    InverseMap inverse() const { return InverseMap(*_graph);}
 
   };
 
-  
+
   /// \brief General invertable graph-map type.
 
-  /// This type provides simple invertable graph-maps. 
-  /// The InvertableMap wraps an arbitrary ReadWriteMap 
+  /// This type provides simple invertable graph-maps.
+  /// The InvertableMap wraps an arbitrary ReadWriteMap
   /// and if a key is set to a new value then store it
   /// in the inverse map.
@@ -1248,13 +1248,13 @@
   class InvertableMap : protected DefaultMap<_Graph, _Item, _Value> {
   private:
-    
+
     typedef DefaultMap<_Graph, _Item, _Value> Map;
     typedef _Graph Graph;
 
     typedef std::map<_Value, _Item> Container;
-    Container _inv_map;    
+    Container _inv_map;
 
   public:
- 
+
     /// The key type of InvertableMap (Node, Arc, Edge).
     typedef typename Map::Key Key;
@@ -1268,5 +1268,5 @@
     /// Construct a new InvertableMap for the graph.
     ///
-    explicit InvertableMap(const Graph& graph) : Map(graph) {} 
+    explicit InvertableMap(const Graph& graph) : Map(graph) {}
 
     /// \brief Forward iterator for values.
@@ -1276,19 +1276,19 @@
     /// be accessed in the [beginValue, endValue) range.
     ///
-    class ValueIterator 
+    class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
       friend class InvertableMap;
     private:
-      ValueIterator(typename Container::const_iterator _it) 
+      ValueIterator(typename Container::const_iterator _it)
         : it(_it) {}
     public:
-      
+
       ValueIterator() {}
 
       ValueIterator& operator++() { ++it; return *this; }
-      ValueIterator operator++(int) { 
-        ValueIterator tmp(*this); 
+      ValueIterator operator++(int) {
+        ValueIterator tmp(*this);
         operator++();
-        return tmp; 
+        return tmp;
       }
 
@@ -1298,5 +1298,5 @@
       bool operator==(ValueIterator jt) const { return it == jt.it; }
       bool operator!=(ValueIterator jt) const { return it != jt.it; }
-      
+
     private:
       typename Container::const_iterator it;
@@ -1305,5 +1305,5 @@
     /// \brief Returns an iterator to the first value.
     ///
-    /// Returns an stl compatible iterator to the 
+    /// Returns an stl compatible iterator to the
     /// first value of the map. The values of the
     /// map can be accessed in the [beginValue, endValue)
@@ -1315,5 +1315,5 @@
     /// \brief Returns an iterator after the last value.
     ///
-    /// Returns an stl compatible iterator after the 
+    /// Returns an stl compatible iterator after the
     /// last value of the map. The values of the
     /// map can be accessed in the [beginValue, endValue)
@@ -1322,5 +1322,5 @@
       return ValueIterator(_inv_map.end());
     }
-    
+
     /// \brief The setter function of the map.
     ///
@@ -1330,6 +1330,6 @@
       typename Container::iterator it = _inv_map.find(oldval);
       if (it != _inv_map.end() && it->second == key) {
-	_inv_map.erase(it);
-      }      
+        _inv_map.erase(it);
+      }
       _inv_map.insert(make_pair(val, key));
       Map::set(key, val);
@@ -1339,5 +1339,5 @@
     ///
     /// It gives back the value associated with the key.
-    typename MapTraits<Map>::ConstReturnValue 
+    typename MapTraits<Map>::ConstReturnValue
     operator[](const Key& key) const {
       return Map::operator[](key);
@@ -1362,5 +1362,5 @@
       typename Container::iterator it = _inv_map.find(val);
       if (it != _inv_map.end() && it->second == key) {
-	_inv_map.erase(it);
+        _inv_map.erase(it);
       }
       Map::erase(key);
@@ -1373,9 +1373,9 @@
     virtual void erase(const std::vector<Key>& keys) {
       for (int i = 0; i < int(keys.size()); ++i) {
-	Value val = Map::operator[](keys[i]);
-	typename Container::iterator it = _inv_map.find(val);
-	if (it != _inv_map.end() && it->second == keys[i]) {
-	  _inv_map.erase(it);
-	}
+        Value val = Map::operator[](keys[i]);
+        typename Container::iterator it = _inv_map.find(val);
+        if (it != _inv_map.end() && it->second == keys[i]) {
+          _inv_map.erase(it);
+        }
       }
       Map::erase(keys);
@@ -1396,5 +1396,5 @@
     ///
     /// The inverse of this map. The subscript operator of the map
-    /// gives back always the item what was last assigned to the value. 
+    /// gives back always the item what was last assigned to the value.
     class InverseMap {
     public:
@@ -1402,5 +1402,5 @@
       ///
       /// Constructor of the InverseMap.
-      explicit InverseMap(const InvertableMap& inverted) 
+      explicit InverseMap(const InvertableMap& inverted)
         : _inverted(inverted) {}
 
@@ -1408,14 +1408,14 @@
       typedef typename InvertableMap::Key Value;
       /// The key type of the InverseMap.
-      typedef typename InvertableMap::Value Key; 
-
-      /// \brief Subscript operator. 
+      typedef typename InvertableMap::Value Key;
+
+      /// \brief Subscript operator.
       ///
-      /// Subscript operator. It gives back always the item 
+      /// Subscript operator. It gives back always the item
       /// what was last assigned to the value.
       Value operator[](const Key& key) const {
-	return _inverted(key);
-      }
-      
+        return _inverted(key);
+      }
+
     private:
       const InvertableMap& _inverted;
@@ -1427,11 +1427,11 @@
     InverseMap inverse() const {
       return InverseMap(*this);
-    } 
-
-
-    
+    }
+
+
+
   };
 
-  /// \brief Provides a mutable, continuous and unique descriptor for each 
+  /// \brief Provides a mutable, continuous and unique descriptor for each
   /// item in the graph.
   ///
@@ -1446,5 +1446,5 @@
   ///
   /// \tparam _Graph The graph class the \c DescriptorMap belongs to.
-  /// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or 
+  /// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or
   /// Edge.
   template <typename _Graph, typename _Item>
@@ -1468,9 +1468,9 @@
     explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
       Item it;
-      const typename Map::Notifier* nf = Map::notifier(); 
+      const typename Map::Notifier* nf = Map::notifier();
       for (nf->first(it); it != INVALID; nf->next(it)) {
-	Map::set(it, _inv_map.size());
-	_inv_map.push_back(it);	
-      }      
+        Map::set(it, _inv_map.size());
+        _inv_map.push_back(it);
+      }
     }
 
@@ -1494,6 +1494,6 @@
       Map::add(items);
       for (int i = 0; i < int(items.size()); ++i) {
-	Map::set(items[i], _inv_map.size());
-	_inv_map.push_back(items[i]);
+        Map::set(items[i], _inv_map.size());
+        _inv_map.push_back(items[i]);
       }
     }
@@ -1516,7 +1516,7 @@
     virtual void erase(const std::vector<Item>& items) {
       for (int i = 0; i < int(items.size()); ++i) {
-	Map::set(_inv_map.back(), Map::operator[](items[i]));
-	_inv_map[Map::operator[](items[i])] = _inv_map.back();
-	_inv_map.pop_back();
+        Map::set(_inv_map.back(), Map::operator[](items[i]));
+        _inv_map[Map::operator[](items[i])] = _inv_map.back();
+        _inv_map.pop_back();
       }
       Map::erase(items);
@@ -1530,11 +1530,11 @@
       Map::build();
       Item it;
-      const typename Map::Notifier* nf = Map::notifier(); 
+      const typename Map::Notifier* nf = Map::notifier();
       for (nf->first(it); it != INVALID; nf->next(it)) {
-	Map::set(it, _inv_map.size());
-	_inv_map.push_back(it);	
-      }      
-    }
-    
+        Map::set(it, _inv_map.size());
+        _inv_map.push_back(it);
+      }
+    }
+
     /// \brief Clear the keys from the map.
     ///
@@ -1580,5 +1580,5 @@
       return _inv_map[id];
     }
-    
+
   private:
 
@@ -1595,6 +1595,6 @@
       ///
       /// Constructor of the InverseMap.
-      explicit InverseMap(const DescriptorMap& inverted) 
-	: _inverted(inverted) {}
+      explicit InverseMap(const DescriptorMap& inverted)
+        : _inverted(inverted) {}
 
 
@@ -1602,12 +1602,12 @@
       typedef typename DescriptorMap::Key Value;
       /// The key type of the InverseMap.
-      typedef typename DescriptorMap::Value Key; 
-
-      /// \brief Subscript operator. 
+      typedef typename DescriptorMap::Value Key;
+
+      /// \brief Subscript operator.
       ///
-      /// Subscript operator. It gives back the item 
+      /// Subscript operator. It gives back the item
       /// that the descriptor belongs to currently.
       Value operator[](const Key& key) const {
-	return _inverted(key);
+        return _inverted(key);
       }
 
@@ -1616,7 +1616,7 @@
       /// Returns the size of the map.
       unsigned int size() const {
-	return _inverted.size();
-      }
-      
+        return _inverted.size();
+      }
+
     private:
       const DescriptorMap& _inverted;
@@ -1633,5 +1633,5 @@
   /// \brief Returns the source of the given arc.
   ///
-  /// The SourceMap gives back the source Node of the given arc. 
+  /// The SourceMap gives back the source Node of the given arc.
   /// \see TargetMap
   template <typename Digraph>
@@ -1651,6 +1651,6 @@
     ///
     /// The subscript operator.
-    /// \param arc The arc 
-    /// \return The source of the arc 
+    /// \param arc The arc
+    /// \return The source of the arc
     Value operator[](const Key& arc) const {
       return _digraph.source(arc);
@@ -1668,9 +1668,9 @@
   inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
     return SourceMap<Digraph>(digraph);
-  } 
+  }
 
   /// \brief Returns the target of the given arc.
   ///
-  /// The TargetMap gives back the target Node of the given arc. 
+  /// The TargetMap gives back the target Node of the given arc.
   /// \see SourceMap
   template <typename Digraph>
@@ -1690,6 +1690,6 @@
     ///
     /// The subscript operator.
-    /// \param e The arc 
-    /// \return The target of the arc 
+    /// \param e The arc
+    /// \return The target of the arc
     Value operator[](const Key& e) const {
       return _digraph.target(e);
@@ -1729,6 +1729,6 @@
     ///
     /// The subscript operator.
-    /// \param key An edge 
-    /// \return The "forward" directed arc view of edge 
+    /// \param key An edge
+    /// \return The "forward" directed arc view of edge
     Value operator[](const Key& key) const {
       return _graph.direct(key, true);
@@ -1768,6 +1768,6 @@
     ///
     /// The subscript operator.
-    /// \param key An edge 
-    /// \return The "backward" directed arc view of edge 
+    /// \param key An edge
+    /// \return The "backward" directed arc view of edge
     Value operator[](const Key& key) const {
       return _graph.direct(key, false);
@@ -1801,6 +1801,6 @@
     ///
     /// Contructor of the map
-    explicit PotentialDifferenceMap(const Digraph& digraph, 
-                                    const NodeMap& potential) 
+    explicit PotentialDifferenceMap(const Digraph& digraph,
+                                    const NodeMap& potential)
       : _digraph(digraph), _potential(potential) {}
 
@@ -1809,6 +1809,6 @@
     /// Const subscription operator
     Value operator[](const Key& arc) const {
-      return _potential[_digraph.target(arc)] - 
-	_potential[_digraph.source(arc)];
+      return _potential[_digraph.target(arc)] -
+        _potential[_digraph.source(arc)];
     }
 
@@ -1823,5 +1823,5 @@
   /// \relates PotentialDifferenceMap
   template <typename Digraph, typename NodeMap>
-  PotentialDifferenceMap<Digraph, NodeMap> 
+  PotentialDifferenceMap<Digraph, NodeMap>
   potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
     return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
@@ -1846,10 +1846,10 @@
 
   template <typename _Digraph>
-  class InDegMap  
+  class InDegMap
     : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
-    
+
     typedef _Digraph Digraph;
     typedef int Value;
@@ -1867,24 +1867,24 @@
 
       AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
-      
+
       virtual void add(const Key& key) {
-	Parent::add(key);
-	Parent::set(key, 0);
+        Parent::add(key);
+        Parent::set(key, 0);
       }
 
       virtual void add(const std::vector<Key>& keys) {
-	Parent::add(keys);
-	for (int i = 0; i < int(keys.size()); ++i) {
-	  Parent::set(keys[i], 0);
-	}
+        Parent::add(keys);
+        for (int i = 0; i < int(keys.size()); ++i) {
+          Parent::set(keys[i], 0);
+        }
       }
 
       virtual void build() {
-	Parent::build();
-	Key it;
-	typename Parent::Notifier* nf = Parent::notifier();
-	for (nf->first(it); it != INVALID; nf->next(it)) {
-	  Parent::set(it, 0);
-	}
+        Parent::build();
+        Key it;
+        typename Parent::Notifier* nf = Parent::notifier();
+        for (nf->first(it); it != INVALID; nf->next(it)) {
+          Parent::set(it, 0);
+        }
       }
     };
@@ -1895,13 +1895,13 @@
     ///
     /// Constructor for creating in-degree map.
-    explicit InDegMap(const Digraph& digraph) 
+    explicit InDegMap(const Digraph& digraph)
       : _digraph(digraph), _deg(digraph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
-      
+
       for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countInArcs(_digraph, it);
-      }
-    }
-    
+        _deg[it] = countInArcs(_digraph, it);
+      }
+    }
+
     /// Gives back the in-degree of a Node.
     int operator[](const Key& key) const {
@@ -1910,5 +1910,5 @@
 
   protected:
-    
+
     typedef typename Digraph::Arc Arc;
 
@@ -1935,15 +1935,15 @@
     virtual void build() {
       for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countInArcs(_digraph, it);
-      }      
+        _deg[it] = countInArcs(_digraph, it);
+      }
     }
 
     virtual void clear() {
       for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = 0;
+        _deg[it] = 0;
       }
     }
   private:
-    
+
     const Digraph& _digraph;
     AutoNodeMap _deg;
@@ -1968,10 +1968,10 @@
 
   template <typename _Digraph>
-  class OutDegMap  
+  class OutDegMap
     : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
-    
+
     typedef _Digraph Digraph;
     typedef int Value;
@@ -1989,22 +1989,22 @@
 
       AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
-      
+
       virtual void add(const Key& key) {
-	Parent::add(key);
-	Parent::set(key, 0);
+        Parent::add(key);
+        Parent::set(key, 0);
       }
       virtual void add(const std::vector<Key>& keys) {
-	Parent::add(keys);
-	for (int i = 0; i < int(keys.size()); ++i) {
-	  Parent::set(keys[i], 0);
-	}
+        Parent::add(keys);
+        for (int i = 0; i < int(keys.size()); ++i) {
+          Parent::set(keys[i], 0);
+        }
       }
       virtual void build() {
-	Parent::build();
-	Key it;
-	typename Parent::Notifier* nf = Parent::notifier();
-	for (nf->first(it); it != INVALID; nf->next(it)) {
-	  Parent::set(it, 0);
-	}
+        Parent::build();
+        Key it;
+        typename Parent::Notifier* nf = Parent::notifier();
+        for (nf->first(it); it != INVALID; nf->next(it)) {
+          Parent::set(it, 0);
+        }
       }
     };
@@ -2015,10 +2015,10 @@
     ///
     /// Constructor for creating out-degree map.
-    explicit OutDegMap(const Digraph& digraph) 
+    explicit OutDegMap(const Digraph& digraph)
       : _digraph(digraph), _deg(digraph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
-      
+
       for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countOutArcs(_digraph, it);
+        _deg[it] = countOutArcs(_digraph, it);
       }
     }
@@ -2030,5 +2030,5 @@
 
   protected:
-    
+
     typedef typename Digraph::Arc Arc;
 
@@ -2055,15 +2055,15 @@
     virtual void build() {
       for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countOutArcs(_digraph, it);
-      }      
+        _deg[it] = countOutArcs(_digraph, it);
+      }
     }
 
     virtual void clear() {
       for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = 0;
+        _deg[it] = 0;
       }
     }
   private:
-    
+
     const Digraph& _digraph;
     AutoNodeMap _deg;
@@ -2072,5 +2072,5 @@
 
   ///Dynamic arc look up between given endpoints.
-  
+
   ///\ingroup gutils
   ///Using this class, you can find an arc in a digraph from a given
@@ -2090,10 +2090,10 @@
   ///queries.
   ///
-  ///\tparam G The type of the underlying digraph.  
-  ///
-  ///\sa ArcLookUp  
-  ///\sa AllArcLookUp  
+  ///\tparam G The type of the underlying digraph.
+  ///
+  ///\sa ArcLookUp
+  ///\sa AllArcLookUp
   template<class G>
-  class DynArcLookUp 
+  class DynArcLookUp
     : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
   {
@@ -2113,24 +2113,24 @@
 
       AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
-      
+
       virtual void add(const Node& node) {
-	Parent::add(node);
-	Parent::set(node, INVALID);
+        Parent::add(node);
+        Parent::set(node, INVALID);
       }
 
       virtual void add(const std::vector<Node>& nodes) {
-	Parent::add(nodes);
-	for (int i = 0; i < int(nodes.size()); ++i) {
-	  Parent::set(nodes[i], INVALID);
-	}
+        Parent::add(nodes);
+        for (int i = 0; i < int(nodes.size()); ++i) {
+          Parent::set(nodes[i], INVALID);
+        }
       }
 
       virtual void build() {
-	Parent::build();
-	Node it;
-	typename Parent::Notifier* nf = Parent::notifier();
-	for (nf->first(it); it != INVALID; nf->next(it)) {
-	  Parent::set(it, INVALID);
-	}
+        Parent::build();
+        Node it;
+        typename Parent::Notifier* nf = Parent::notifier();
+        for (nf->first(it); it != INVALID; nf->next(it)) {
+          Parent::set(it, INVALID);
+        }
       }
     };
@@ -2141,17 +2141,17 @@
     typename Digraph::template ArcMap<Arc> _left;
     typename Digraph::template ArcMap<Arc> _right;
-    
+
     class ArcLess {
       const Digraph &g;
     public:
       ArcLess(const Digraph &_g) : g(_g) {}
-      bool operator()(Arc a,Arc b) const 
+      bool operator()(Arc a,Arc b) const
       {
-	return g.target(a)<g.target(b);
-      }
-    };
-    
+        return g.target(a)<g.target(b);
+      }
+    };
+
   public:
-    
+
     ///Constructor
 
@@ -2159,11 +2159,11 @@
     ///
     ///It builds up the search database.
-    DynArcLookUp(const Digraph &g) 
-      : _g(g),_head(g),_parent(g),_left(g),_right(g) 
-    { 
+    DynArcLookUp(const Digraph &g)
+      : _g(g),_head(g),_parent(g),_left(g),_right(g)
+    {
       Parent::attach(_g.notifier(typename Digraph::Arc()));
-      refresh(); 
-    }
-    
+      refresh();
+    }
+
   protected:
 
@@ -2174,5 +2174,5 @@
     virtual void add(const std::vector<Arc>& arcs) {
       for (int i = 0; i < int(arcs.size()); ++i) {
-	insert(arcs[i]);
+        insert(arcs[i]);
       }
     }
@@ -2184,6 +2184,6 @@
     virtual void erase(const std::vector<Arc>& arcs) {
       for (int i = 0; i < int(arcs.size()); ++i) {
-	remove(arcs[i]);
-      }     
+        remove(arcs[i]);
+      }
     }
 
@@ -2194,5 +2194,5 @@
     virtual void clear() {
       for(NodeIt n(_g);n!=INVALID;++n) {
-	_head.set(n, INVALID);
+        _head.set(n, INVALID);
       }
     }
@@ -2203,31 +2203,31 @@
       _left.set(arc, INVALID);
       _right.set(arc, INVALID);
-      
+
       Arc e = _head[s];
       if (e == INVALID) {
-	_head.set(s, arc);
-	_parent.set(arc, INVALID);
-	return;
+        _head.set(s, arc);
+        _parent.set(arc, INVALID);
+        return;
       }
       while (true) {
-	if (t < _g.target(e)) {
-	  if (_left[e] == INVALID) {
-	    _left.set(e, arc);
-	    _parent.set(arc, e);
-	    splay(arc);
-	    return;
-	  } else {
-	    e = _left[e];
-	  }
-	} else {
-	  if (_right[e] == INVALID) {
-	    _right.set(e, arc);
-	    _parent.set(arc, e);
-	    splay(arc);
-	    return;
-	  } else {
-	    e = _right[e];
-	  }
-	}
+        if (t < _g.target(e)) {
+          if (_left[e] == INVALID) {
+            _left.set(e, arc);
+            _parent.set(arc, e);
+            splay(arc);
+            return;
+          } else {
+            e = _left[e];
+          }
+        } else {
+          if (_right[e] == INVALID) {
+            _right.set(e, arc);
+            _parent.set(arc, e);
+            splay(arc);
+            return;
+          } else {
+            e = _right[e];
+          }
+        }
       }
     }
@@ -2235,88 +2235,88 @@
     void remove(Arc arc) {
       if (_left[arc] == INVALID) {
-	if (_right[arc] != INVALID) {
-	  _parent.set(_right[arc], _parent[arc]);
-	}
-	if (_parent[arc] != INVALID) {
-	  if (_left[_parent[arc]] == arc) {
-	    _left.set(_parent[arc], _right[arc]);
-	  } else {
-	    _right.set(_parent[arc], _right[arc]);
-	  }
-	} else {
-	  _head.set(_g.source(arc), _right[arc]);
-	}
+        if (_right[arc] != INVALID) {
+          _parent.set(_right[arc], _parent[arc]);
+        }
+        if (_parent[arc] != INVALID) {
+          if (_left[_parent[arc]] == arc) {
+            _left.set(_parent[arc], _right[arc]);
+          } else {
+            _right.set(_parent[arc], _right[arc]);
+          }
+        } else {
+          _head.set(_g.source(arc), _right[arc]);
+        }
       } else if (_right[arc] == INVALID) {
-	_parent.set(_left[arc], _parent[arc]);
-	if (_parent[arc] != INVALID) {
-	  if (_left[_parent[arc]] == arc) {
-	    _left.set(_parent[arc], _left[arc]);
-	  } else {
-	    _right.set(_parent[arc], _left[arc]);
-	  }
-	} else {
-	  _head.set(_g.source(arc), _left[arc]);
-	}
+        _parent.set(_left[arc], _parent[arc]);
+        if (_parent[arc] != INVALID) {
+          if (_left[_parent[arc]] == arc) {
+            _left.set(_parent[arc], _left[arc]);
+          } else {
+            _right.set(_parent[arc], _left[arc]);
+          }
+        } else {
+          _head.set(_g.source(arc), _left[arc]);
+        }
       } else {
-	Arc e = _left[arc];
-	if (_right[e] != INVALID) {
-	  e = _right[e];	  
-	  while (_right[e] != INVALID) {
-	    e = _right[e];
-	  }
-	  Arc s = _parent[e];
-	  _right.set(_parent[e], _left[e]);
-	  if (_left[e] != INVALID) {
-	    _parent.set(_left[e], _parent[e]);
-	  }
-	  
-	  _left.set(e, _left[arc]);
-	  _parent.set(_left[arc], e);
-	  _right.set(e, _right[arc]);
-	  _parent.set(_right[arc], e);
-
-	  _parent.set(e, _parent[arc]);
-	  if (_parent[arc] != INVALID) {
-	    if (_left[_parent[arc]] == arc) {
-	      _left.set(_parent[arc], e);
-	    } else {
-	      _right.set(_parent[arc], e);
-	    }
-	  }
-	  splay(s);
-	} else {
-	  _right.set(e, _right[arc]);
-	  _parent.set(_right[arc], e);
-
-	  if (_parent[arc] != INVALID) {
-	    if (_left[_parent[arc]] == arc) {
-	      _left.set(_parent[arc], e);
-	    } else {
-	      _right.set(_parent[arc], e);
-	    }
-	  } else {
-	    _head.set(_g.source(arc), e);
-	  }
-	}
-      }
-    }
-
-    Arc refreshRec(std::vector<Arc> &v,int a,int b) 
+        Arc e = _left[arc];
+        if (_right[e] != INVALID) {
+          e = _right[e];
+          while (_right[e] != INVALID) {
+            e = _right[e];
+          }
+          Arc s = _parent[e];
+          _right.set(_parent[e], _left[e]);
+          if (_left[e] != INVALID) {
+            _parent.set(_left[e], _parent[e]);
+          }
+
+          _left.set(e, _left[arc]);
+          _parent.set(_left[arc], e);
+          _right.set(e, _right[arc]);
+          _parent.set(_right[arc], e);
+
+          _parent.set(e, _parent[arc]);
+          if (_parent[arc] != INVALID) {
+            if (_left[_parent[arc]] == arc) {
+              _left.set(_parent[arc], e);
+            } else {
+              _right.set(_parent[arc], e);
+            }
+          }
+          splay(s);
+        } else {
+          _right.set(e, _right[arc]);
+          _parent.set(_right[arc], e);
+
+          if (_parent[arc] != INVALID) {
+            if (_left[_parent[arc]] == arc) {
+              _left.set(_parent[arc], e);
+            } else {
+              _right.set(_parent[arc], e);
+            }
+          } else {
+            _head.set(_g.source(arc), e);
+          }
+        }
+      }
+    }
+
+    Arc refreshRec(std::vector<Arc> &v,int a,int b)
     {
       int m=(a+b)/2;
       Arc me=v[m];
       if (a < m) {
-	Arc left = refreshRec(v,a,m-1);
-	_left.set(me, left);
-	_parent.set(left, me);
+        Arc left = refreshRec(v,a,m-1);
+        _left.set(me, left);
+        _parent.set(left, me);
       } else {
-	_left.set(me, INVALID);
+        _left.set(me, INVALID);
       }
       if (m < b) {
-	Arc right = refreshRec(v,m+1,b);
-	_right.set(me, right);
-	_parent.set(right, me);
+        Arc right = refreshRec(v,m+1,b);
+        _right.set(me, right);
+        _parent.set(right, me);
       } else {
-	_right.set(me, INVALID);
+        _right.set(me, INVALID);
       }
       return me;
@@ -2325,17 +2325,17 @@
     void refresh() {
       for(NodeIt n(_g);n!=INVALID;++n) {
-	std::vector<Arc> v;
-	for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
-	if(v.size()) {
-	  std::sort(v.begin(),v.end(),ArcLess(_g));
-	  Arc head = refreshRec(v,0,v.size()-1);
-	  _head.set(n, head);
-	  _parent.set(head, INVALID);
-	}
-	else _head.set(n, INVALID);
-      }
-    }
-
-    void zig(Arc v) {        
+        std::vector<Arc> v;
+        for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
+        if(v.size()) {
+          std::sort(v.begin(),v.end(),ArcLess(_g));
+          Arc head = refreshRec(v,0,v.size()-1);
+          _head.set(n, head);
+          _parent.set(head, INVALID);
+        }
+        else _head.set(n, INVALID);
+      }
+    }
+
+    void zig(Arc v) {
       Arc w = _parent[v];
       _parent.set(v, _parent[w]);
@@ -2344,16 +2344,16 @@
       _right.set(v, w);
       if (_parent[v] != INVALID) {
-	if (_right[_parent[v]] == w) {
-	  _right.set(_parent[v], v);
-	} else {
-	  _left.set(_parent[v], v);
-	}
+        if (_right[_parent[v]] == w) {
+          _right.set(_parent[v], v);
+        } else {
+          _left.set(_parent[v], v);
+        }
       }
       if (_left[w] != INVALID){
-	_parent.set(_left[w], w);
-      }
-    }
-
-    void zag(Arc v) {        
+        _parent.set(_left[w], w);
+      }
+    }
+
+    void zag(Arc v) {
       Arc w = _parent[v];
       _parent.set(v, _parent[w]);
@@ -2362,12 +2362,12 @@
       _left.set(v, w);
       if (_parent[v] != INVALID){
-	if (_left[_parent[v]] == w) {
-	  _left.set(_parent[v], v);
-	} else {
-	  _right.set(_parent[v], v);
-	}
+        if (_left[_parent[v]] == w) {
+          _left.set(_parent[v], v);
+        } else {
+          _right.set(_parent[v], v);
+        }
       }
       if (_right[w] != INVALID){
-	_parent.set(_right[w], w);
+        _parent.set(_right[w], w);
       }
     }
@@ -2375,29 +2375,29 @@
     void splay(Arc v) {
       while (_parent[v] != INVALID) {
-	if (v == _left[_parent[v]]) {
-	  if (_parent[_parent[v]] == INVALID) {
-	    zig(v);
-	  } else {
-	    if (_parent[v] == _left[_parent[_parent[v]]]) {
-	      zig(_parent[v]);
-	      zig(v);
-	    } else {
-	      zig(v);
-	      zag(v);
-	    }
-	  }
-	} else {
-	  if (_parent[_parent[v]] == INVALID) {
-	    zag(v);
-	  } else {
-	    if (_parent[v] == _left[_parent[_parent[v]]]) {
-	      zag(v);
-	      zig(v);
-	    } else {
-	      zag(_parent[v]);
-	      zag(v);
-	    }
-	  }
-	}
+        if (v == _left[_parent[v]]) {
+          if (_parent[_parent[v]] == INVALID) {
+            zig(v);
+          } else {
+            if (_parent[v] == _left[_parent[_parent[v]]]) {
+              zig(_parent[v]);
+              zig(v);
+            } else {
+              zig(v);
+              zag(v);
+            }
+          }
+        } else {
+          if (_parent[_parent[v]] == INVALID) {
+            zag(v);
+          } else {
+            if (_parent[v] == _left[_parent[_parent[v]]]) {
+              zag(v);
+              zig(v);
+            } else {
+              zag(_parent[v]);
+              zag(v);
+            }
+          }
+        }
       }
       _head[_g.source(v)] = v;
@@ -2406,7 +2406,7 @@
 
   public:
-    
+
     ///Find an arc between two nodes.
-    
+
     ///Find an arc between two nodes in time <em>O(</em>log<em>d)</em>, where
     /// <em>d</em> is the number of outgoing arcs of \c s.
@@ -2419,31 +2419,31 @@
       Arc a = _head[s];
       while (true) {
-	if (_g.target(a) == t) {
-	  const_cast<DynArcLookUp&>(*this).splay(a);
-	  return a;
-	} else if (t < _g.target(a)) {
-	  if (_left[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
-	    return INVALID;
-	  } else {
-	    a = _left[a];
-	  }
-	} else  {
-	  if (_right[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
-	    return INVALID;
-	  } else {
-	    a = _right[a];
-	  }
-	}
+        if (_g.target(a) == t) {
+          const_cast<DynArcLookUp&>(*this).splay(a);
+          return a;
+        } else if (t < _g.target(a)) {
+          if (_left[a] == INVALID) {
+            const_cast<DynArcLookUp&>(*this).splay(a);
+            return INVALID;
+          } else {
+            a = _left[a];
+          }
+        } else  {
+          if (_right[a] == INVALID) {
+            const_cast<DynArcLookUp&>(*this).splay(a);
+            return INVALID;
+          } else {
+            a = _right[a];
+          }
+        }
       }
     }
 
     ///Find the first arc between two nodes.
-    
+
     ///Find the first arc between two nodes in time
     /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
-    /// outgoing arcs of \c s.  
-    ///\param s The source node 
+    /// outgoing arcs of \c s.
+    ///\param s The source node
     ///\param t The target node
     ///\return An arc from \c s to \c t if there exists, \ref INVALID
@@ -2454,31 +2454,31 @@
       Arc r = INVALID;
       while (true) {
-	if (_g.target(a) < t) {
-	  if (_right[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
-	    return r;
-	  } else {
-	    a = _right[a];
-	  }
-	} else {
-	  if (_g.target(a) == t) {
-	    r = a;
-	  }
-	  if (_left[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
-	    return r;
-	  } else {
-	    a = _left[a];
-	  }
-	}
+        if (_g.target(a) < t) {
+          if (_right[a] == INVALID) {
+            const_cast<DynArcLookUp&>(*this).splay(a);
+            return r;
+          } else {
+            a = _right[a];
+          }
+        } else {
+          if (_g.target(a) == t) {
+            r = a;
+          }
+          if (_left[a] == INVALID) {
+            const_cast<DynArcLookUp&>(*this).splay(a);
+            return r;
+          } else {
+            a = _left[a];
+          }
+        }
       }
     }
 
     ///Find the next arc between two nodes.
-    
+
     ///Find the next arc between two nodes in time
     /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
-    /// outgoing arcs of \c s.  
-    ///\param s The source node 
+    /// outgoing arcs of \c s.
+    ///\param s The source node
     ///\param t The target node
     ///\return An arc from \c s to \c t if there exists, \ref INVALID
@@ -2494,22 +2494,22 @@
     {
       if (_right[a] != INVALID) {
-	a = _right[a];
-	while (_left[a] != INVALID) {
-	  a = _left[a];
-	}
-	const_cast<DynArcLookUp&>(*this).splay(a);
+        a = _right[a];
+        while (_left[a] != INVALID) {
+          a = _left[a];
+        }
+        const_cast<DynArcLookUp&>(*this).splay(a);
       } else {
-	while (_parent[a] != INVALID && _right[_parent[a]] ==  a) {
-	  a = _parent[a];
-	}
-	if (_parent[a] == INVALID) {
-	  return INVALID;
-	} else {
-	  a = _parent[a];
-	  const_cast<DynArcLookUp&>(*this).splay(a);
-	}
+        while (_parent[a] != INVALID && _right[_parent[a]] ==  a) {
+          a = _parent[a];
+        }
+        if (_parent[a] == INVALID) {
+          return INVALID;
+        } else {
+          a = _parent[a];
+          const_cast<DynArcLookUp&>(*this).splay(a);
+        }
       }
       if (_g.target(a) == t) return a;
-      else return INVALID;    
+      else return INVALID;
     }
 
@@ -2517,5 +2517,5 @@
 
   ///Fast arc look up between given endpoints.
-  
+
   ///\ingroup gutils
   ///Using this class, you can find an arc in a digraph from a given
@@ -2534,7 +2534,7 @@
   ///
   ///\sa DynArcLookUp
-  ///\sa AllArcLookUp  
+  ///\sa AllArcLookUp
   template<class G>
-  class ArcLookUp 
+  class ArcLookUp
   {
   public:
@@ -2547,17 +2547,17 @@
     typename Digraph::template ArcMap<Arc> _left;
     typename Digraph::template ArcMap<Arc> _right;
-    
+
     class ArcLess {
       const Digraph &g;
     public:
       ArcLess(const Digraph &_g) : g(_g) {}
-      bool operator()(Arc a,Arc b) const 
+      bool operator()(Arc a,Arc b) const
       {
-	return g.target(a)<g.target(b);
-      }
-    };
-    
+        return g.target(a)<g.target(b);
+      }
+    };
+
   public:
-    
+
     ///Constructor
 
@@ -2567,7 +2567,7 @@
     ///changes.
     ArcLookUp(const Digraph &g) :_g(g),_head(g),_left(g),_right(g) {refresh();}
-    
+
   private:
-    Arc refreshRec(std::vector<Arc> &v,int a,int b) 
+    Arc refreshRec(std::vector<Arc> &v,int a,int b)
     {
       int m=(a+b)/2;
@@ -2584,11 +2584,11 @@
     ///It runs in time <em>O(d</em>log<em>d)</em>, where <em>d</em> is
     ///the number of the outgoing arcs of \c n.
-    void refresh(Node n) 
+    void refresh(Node n)
     {
       std::vector<Arc> v;
       for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
       if(v.size()) {
-	std::sort(v.begin(),v.end(),ArcLess(_g));
-	_head[n]=refreshRec(v,0,v.size()-1);
+        std::sort(v.begin(),v.end(),ArcLess(_g));
+        _head[n]=refreshRec(v,0,v.size()-1);
       }
       else _head[n]=INVALID;
@@ -2603,11 +2603,11 @@
     ///out-degree of the digraph.
 
-    void refresh() 
+    void refresh()
     {
       for(NodeIt n(_g);n!=INVALID;++n) refresh(n);
     }
-    
+
     ///Find an arc between two nodes.
-    
+
     ///Find an arc between two nodes in time <em>O(</em>log<em>d)</em>, where
     /// <em>d</em> is the number of outgoing arcs of \c s.
@@ -2626,6 +2626,6 @@
       Arc e;
       for(e=_head[s];
-	  e!=INVALID&&_g.target(e)!=t;
-	  e = t < _g.target(e)?_left[e]:_right[e]) ;
+          e!=INVALID&&_g.target(e)!=t;
+          e = t < _g.target(e)?_left[e]:_right[e]) ;
       return e;
     }
@@ -2634,5 +2634,5 @@
 
   ///Fast look up of all arcs between given endpoints.
-  
+
   ///\ingroup gutils
   ///This class is the same as \ref ArcLookUp, with the addition
@@ -2647,5 +2647,5 @@
   ///
   ///\sa DynArcLookUp
-  ///\sa ArcLookUp  
+  ///\sa ArcLookUp
   template<class G>
   class AllArcLookUp : public ArcLookUp<G>
@@ -2658,24 +2658,24 @@
     TEMPLATE_DIGRAPH_TYPEDEFS(G);
     typedef G Digraph;
-    
+
     typename Digraph::template ArcMap<Arc> _next;
-    
+
     Arc refreshNext(Arc head,Arc next=INVALID)
     {
       if(head==INVALID) return next;
       else {
-	next=refreshNext(_right[head],next);
-// 	_next[head]=next;
-	_next[head]=( next!=INVALID && _g.target(next)==_g.target(head))
-	  ? next : INVALID;
-	return refreshNext(_left[head],head);
-      }
-    }
-    
+        next=refreshNext(_right[head],next);
+//         _next[head]=next;
+        _next[head]=( next!=INVALID && _g.target(next)==_g.target(head))
+          ? next : INVALID;
+        return refreshNext(_left[head],head);
+      }
+    }
+
     void refreshNext()
     {
       for(NodeIt n(_g);n!=INVALID;++n) refreshNext(_head[n]);
     }
-    
+
   public:
     ///Constructor
@@ -2693,11 +2693,11 @@
     ///It runs in time <em>O(d</em>log<em>d)</em>, where <em>d</em> is
     ///the number of the outgoing arcs of \c n.
-    
-    void refresh(Node n) 
+
+    void refresh(Node n)
     {
       ArcLookUp<G>::refresh(n);
       refreshNext(_head[n]);
     }
-    
+
     ///Refresh the full data structure.
 
@@ -2709,11 +2709,11 @@
     ///out-degree of the digraph.
 
-    void refresh() 
+    void refresh()
     {
       for(NodeIt n(_g);n!=INVALID;++n) refresh(_head[n]);
     }
-    
+
     ///Find an arc between two nodes.
-    
+
     ///Find an arc between two nodes.
     ///\param s The source node
@@ -2751,5 +2751,5 @@
     }
 #endif
-      
+
   };
 
