Index: src/lemon/concept/graph_component.h
===================================================================
--- src/lemon/concept/graph_component.h	(revision 989)
+++ src/lemon/concept/graph_component.h	(revision 1021)
@@ -506,7 +506,9 @@
     /// InEdgeIt you should instantiate it with character 'i' and for 
     /// OutEdgeIt with 'o'.
-    /// \todo check the name of the concept GraphIncEdgeIterator
-    template <typename _Graph, char _selector>
-    class GraphIncEdgeIterator : public _Graph::Edge {
+    /// \todo Is this a good name for this concept?
+    template <typename Graph,
+	      typename Edge = typename Graph::Edge,
+	      char _selector = '0'>
+    class GraphIncIterator : public Edge {
     public:
       /// Default constructor.
@@ -514,52 +516,54 @@
       /// @warning The default constructor sets the iterator
       /// to an undefined value.
-      GraphIncEdgeIterator() {}
+      GraphIncIterator() {}
       /// Copy constructor.
       
       /// Copy constructor.
       ///
-      GraphIncEdgeIterator(GraphIncEdgeIterator const&) {}
+      GraphIncIterator(GraphIncIterator const&) {}
       /// Sets the iterator to the first edge incoming into or outgoing from the node.
       
       /// Sets the iterator to the first edge incoming into or outgoing from the node.
       ///
-      explicit GraphIncEdgeIterator(const _Graph&, const typename _Graph::Node&) {}
+      explicit GraphIncIterator(const Graph&, const typename Graph::Node&) {}
       /// Invalid constructor \& conversion.
 
       /// This constructor initializes the item to be invalid.
       /// \sa Invalid for more details.
-      GraphIncEdgeIterator(Invalid) {}
+      GraphIncIterator(Invalid) {}
       /// Assign operator for nodes.
 
       /// The nodes are assignable. 
       ///
-      GraphIncEdgeIterator& operator=(GraphIncEdgeIterator const&) { return *this; }      
+      GraphIncIterator& operator=(GraphIncIterator const&) { return *this; }      
       /// Next edge.
 
       /// Assign the iterator to the next node.
       ///
-      GraphIncEdgeIterator& operator++() { return *this; }
+      GraphIncIterator& operator++() { return *this; }
+
       //	Node operator*() const { return INVALID; }
+
       /// Equality operator
 
       /// Two iterators are equal if and only if they point to the
       /// same object or both are invalid.
-      bool operator==(const GraphIncEdgeIterator&) const { return true;}
+      bool operator==(const GraphIncIterator&) const { return true;}
+
       /// Inequality operator
 	
       /// \sa operator==(Node n)
       ///
-      bool operator!=(const GraphIncEdgeIterator&) const { return true;}
-
-      template <typename _GraphIncEdgeIterator>
-      struct Constraints {
-	typedef typename _Graph::Node Node;
-	typedef typename _Graph::Edge Edge;
-	void constraints() {
-	  checkConcept<GraphItem<'e'>, _GraphIncEdgeIterator>();
-	  _GraphIncEdgeIterator it1(graph, node);
+      bool operator!=(const GraphIncIterator&) const { return true;}
+
+      template <typename _GraphIncIterator>
+      struct Constraints {
+	typedef typename Graph::Node Node;
+	void constraints() {
+	  checkConcept<GraphItem<'e'>, _GraphIncIterator>();
+	  _GraphIncIterator it1(graph, node);
 	  /// \todo Do we need OutEdgeIt(Edge) kind of constructor?
-	  //	_GraphIncEdgeIterator it2(edge);
-	  _GraphIncEdgeIterator it2;
+	  //	_GraphIncIterator it2(edge);
+	  _GraphIncIterator it2;
 
 	  it2 = ++it1;
@@ -572,7 +576,9 @@
 	Edge& edge;
 	Node& node;
-	_Graph& graph;
-      };
-    };
+	Graph& graph;
+      };
+    };
+
+
     /// An empty iterable base graph class.
   
@@ -603,10 +609,10 @@
       /// This iterator goes trough the \e inccoming edges of a certain node
       /// of a graph.
-      typedef GraphIncEdgeIterator<Graph, 'i'> InEdgeIt;
+      typedef GraphIncIterator<Graph, Edge, 'i'> InEdgeIt;
       /// This iterator goes trough the outgoing edges of a node.
 
       /// This iterator goes trough the \e outgoing edges of a certain node
       /// of a graph.
-      typedef GraphIncEdgeIterator<Graph, 'o'> OutEdgeIt;
+      typedef GraphIncIterator<Graph, Edge, 'o'> OutEdgeIt;
     };
     
@@ -618,6 +624,6 @@
 	checkConcept<GraphIterator<_Graph, typename _Graph::Edge>, typename _Graph::EdgeIt >();
 	checkConcept<GraphIterator<_Graph, typename _Graph::Node>, typename _Graph::NodeIt >();
-	checkConcept<GraphIncEdgeIterator<_Graph, 'i'>, typename _Graph::InEdgeIt >();
-	checkConcept<GraphIncEdgeIterator<_Graph, 'o'>, typename _Graph::OutEdgeIt >();
+	checkConcept<GraphIncIterator<_Graph>, typename _Graph::InEdgeIt >();
+	checkConcept<GraphIncIterator<_Graph>, typename _Graph::OutEdgeIt >();
       }
     };
