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;
       };
     };
