Index: src/lemon/concept/graph_component.h
===================================================================
--- src/lemon/concept/graph_component.h	(revision 1021)
+++ src/lemon/concept/graph_component.h	(revision 1022)
@@ -407,5 +407,5 @@
     /// core clear functions for the graph structure.
     /// The most of the base graphs should be conform to this concept.
-    class BaseClearableGraphComponent : virtual public BaseGraphComponent {
+    class ClearableGraphComponent : virtual public BaseGraphComponent {
     public:
 
@@ -419,9 +419,9 @@
       struct Constraints {
 	void constraints() {
-	  checkConcept< BaseGraphComponent, _Graph>();
+	  checkConcept<BaseGraphComponent, _Graph>();
 	  graph.clear();
 	}
 
-	_Graph& graph;
+	_Graph graph;
       };
     };
@@ -805,25 +805,4 @@
     };
 
-    class ClearableGraphComponent : virtual public BaseGraphComponent {
-    public:
-
-      typedef ClearableGraphComponent Graph;
-
-      typedef BaseGraphComponent::Node Node;
-      typedef BaseGraphComponent::Edge Edge;
-
-      void clear() {}    
-
-
-      template <typename _Graph>
-      struct ClearableGraphComponentConcept {
-	void constraints() {
-	  checkConcept< BaseGraphComponent, _Graph >();
-	  graph.clear();
-	}
-	_Graph& graph;
-      };
-    };
-
   }
 
Index: src/lemon/concept/undir_graph.h
===================================================================
--- src/lemon/concept/undir_graph.h	(revision 1021)
+++ src/lemon/concept/undir_graph.h	(revision 1022)
@@ -32,48 +32,161 @@
 
     /// \todo to be done
-    class BaseIterableUndirGraph;
 
-    template <typename Graph>
     struct BaseIterableUndirGraphConcept {
-      typedef typename Graph::UndirEdge UndirEdge;
-      typedef typename Graph::Edge Edge;
-      typedef typename Graph::Node Node;
 
-      void constraints() {
-	checkConcept<BaseIterableGraphComponent, Graph>();
-	checkConcept<GraphItem<'u'>, UndirEdge >();
+      template <typename Graph>
+      struct Constraints {
 
-	/// \bug this should be base_and_derived:
-	UndirEdge ue = e;
-	ue = e;
+	typedef typename Graph::UndirEdge UndirEdge;
+	typedef typename Graph::Edge Edge;
+	typedef typename Graph::Node Node;
 
-	Node n;
-	n = graph.target(ue);
-	n = graph.source(ue);
+	void constraints() {
+	  checkConcept<BaseIterableGraphComponent, Graph>();
+	  checkConcept<GraphItem<'u'>, UndirEdge >();
 
-	graph.first(ue);
-	graph.next(ue);
-      }
-      const Graph &graph;
-      Edge e;
+	  /// \bug this should be base_and_derived:
+	  UndirEdge ue = e;
+	  ue = e;
+
+	  Node n;
+	  n = graph.target(ue);
+	  n = graph.source(ue);
+
+	  graph.first(ue);
+	  graph.next(ue);
+	}
+	const Graph &graph;
+	Edge e;
+      };
+
     };
 
-    template <typename Graph>
+
     struct IterableUndirGraphConcept {
-      void constraints() {
-	/// \todo we don't need the iterable component should base iterable	
-	//	checkConcept< BaseIterableUndirGraph, Graph > ();
-	checkConcept< IterableGraphComponent, Graph > ();
 
-	typedef typename Graph::UndirEdge UndirEdge;
-	typedef typename Graph::UndirEdgeIt UndirEdgeIt;
-	typedef typename Graph::UndirIncEdgeIt UndirIncEdgeIt;
+      template <typename Graph>
+      struct Constraints {
+	void constraints() {
+	  /// \todo we don't need the iterable component to be base iterable
+	  /// Don't we really???
+	  //checkConcept< BaseIterableUndirGraphConcept, Graph > ();
 
-	checkConcept< GraphIterator<Graph, UndirEdge>, UndirEdgeIt >();
+	  checkConcept<IterableGraphComponent, Graph> ();
 
-	checkConcept<
-	  GraphIncIterator<Graph, UndirEdge>,
-	  UndirIncEdgeIt >();
-      }
+	  typedef typename Graph::UndirEdge UndirEdge;
+	  typedef typename Graph::UndirEdgeIt UndirEdgeIt;
+	  typedef typename Graph::UndirIncEdgeIt UndirIncEdgeIt;
+
+	  checkConcept<GraphIterator<Graph, UndirEdge>, UndirEdgeIt>();
+	  checkConcept<GraphIncIterator<Graph, UndirEdge>, UndirIncEdgeIt>();
+	}
+      };
+
+    };
+
+    struct MappableUndirGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+
+	struct Dummy {
+	  int value;
+	  Dummy() : value(0) {}
+	  Dummy(int _v) : value(_v) {}
+	};
+
+	void constraints() {
+	  checkConcept<MappableGraphComponent, Graph>();
+
+	  typedef typename Graph::template UndirEdgeMap<int> IntMap;
+	  checkConcept<GraphMap<Graph, typename Graph::UndirEdge, int>,
+	    IntMap >();
+
+	  typedef typename Graph::template UndirEdgeMap<bool> BoolMap;
+	  checkConcept<GraphMap<Graph, typename Graph::UndirEdge, bool>,
+	    BoolMap >();
+
+	  typedef typename Graph::template UndirEdgeMap<Dummy> DummyMap;
+	  checkConcept<GraphMap<Graph, typename Graph::UndirEdge, Dummy>,
+	    DummyMap >();
+	}
+      };
+
+    };
+
+    struct ExtendableUndirGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+	void constraints() {
+	  node_a = graph.addNode();
+	  uedge = graph.addEdge(node_a, node_b);
+	}
+	typename Graph::Node node_a, node_b;
+	typename Graph::UndirEdge uedge;
+	Graph graph;
+      };
+
+    };
+
+    struct ErasableUndirGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+	void constraints() {
+	  graph.erase(n);
+	  graph.erase(e);
+	}
+	Graph graph;
+	typename Graph::Node n;
+	typename Graph::UndirEdge e;
+      };
+
+    };
+
+    class UndirGraph {
+    public:
+
+      template <typename Graph>
+      struct Constraints {
+	void constraints() {
+	  checkConcept<BaseIterableUndirGraphConcept, Graph>();
+	  checkConcept<IterableUndirGraphConcept, Graph>();
+	  checkConcept<MappableUndirGraphConcept, Graph>();
+	}
+      };
+
+    };
+
+    class ExtendableUndirGraph : public UndirGraph {
+    public:
+
+      template <typename Graph>
+      struct Constraints {
+	void constraints() {
+	  checkConcept<BaseIterableUndirGraphConcept, Graph>();
+	  checkConcept<IterableUndirGraphConcept, Graph>();
+	  checkConcept<MappableUndirGraphConcept, Graph>();
+
+	  checkConcept<UndirGraph, Graph>();
+	  checkConcept<ExtendableUndirGraphConcept, Graph>();
+	  checkConcept<ClearableGraphComponent, Graph>();
+	}
+      };
+
+    };
+
+    class ErasableUndirGraph : public ExtendableUndirGraph {
+    public:
+
+      template <typename Graph>
+      struct Constraints {
+	void constraints() {
+	  checkConcept<ExtendableUndirGraph, Graph>();
+	  checkConcept<ErasableUndirGraphConcept, Graph>();
+	}
+      };
+
     };
 
