Index: doc/graphs.dox
===================================================================
--- doc/graphs.dox	(revision 1638)
+++ doc/graphs.dox	(revision 2111)
@@ -2,4 +2,8 @@
 
 \page graphs Graphs
+
+\todo Write a new Graphs page. I think it should be contain the Graph,
+UGraph and BpUGraph concept. It should be describe the iterators and
+the basic functions and the differences of the implementations.
 
 The primary data structures of LEMON are the graph classes. They all
@@ -8,16 +12,9 @@
 as  incoming and outgoing edges of a given node. 
 
+Each graph should meet the \ref lemon::concept::Graph "Graph" concept.
+This concept does not make it possible to change the graph (i.e. it is
+not possible to add or delete edges or nodes). Most of the graph
+algorithms will run on these graphs.
 
-Each graph should meet the
-\ref lemon::concept::StaticGraph "StaticGraph" concept.
-This concept does not
-make it possible to change the graph (i.e. it is not possible to add
-or delete edges or nodes). Most of the graph algorithms will run on
-these graphs.
-
-The graphs meeting the
-\ref lemon::concept::ExtendableGraph "ExtendableGraph"
-concept allow node and
-edge addition. You can also "clear" such a graph (i.e. erase all edges and nodes ).
 
 In case of graphs meeting the full feature
@@ -37,5 +34,5 @@
 \li \ref lemon::FullGraph "FullGraph"
 implements a complete graph. It is a
-\ref lemon::concept::StaticGraph "StaticGraph", so you cannot
+\ref lemon::concept::Graph "Graph", so you cannot
 change the number of nodes once it is constructed. It is extremely memory
 efficient: it uses constant amount of memory independently from the number of
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 2074)
+++ lemon/bellman_ford.h	(revision 2111)
@@ -165,5 +165,5 @@
   /// BellmanFord, it is only passed to \ref BellmanFordDefaultTraits.
   /// \param _LengthMap This read-only EdgeMap determines the lengths of the
-  /// edges. The default map type is \ref concept::StaticGraph::EdgeMap 
+  /// edges. The default map type is \ref concept::Graph::EdgeMap 
   /// "Graph::EdgeMap<int>".  The value of _LengthMap is not used directly 
   /// by BellmanFord, it is only passed to \ref BellmanFordDefaultTraits.  
Index: lemon/concept/bpugraph.h
===================================================================
--- lemon/concept/bpugraph.h	(revision 1993)
+++ lemon/concept/bpugraph.h	(revision 2111)
@@ -948,68 +948,4 @@
     };
 
-    /// \brief An empty non-static undirected graph class.
-    ///    
-    /// This class provides everything that \ref BpUGraph does.
-    /// Additionally it enables building graphs from scratch.
-    class ExtendableBpUGraph : public BpUGraph {
-    public:
-      
-      /// \brief Add a new ANode to the graph.
-      ///
-      /// Add a new ANode to the graph.
-      /// \return the new node.
-      Node addANode();
-
-      /// \brief Add a new ANode to the graph.
-      ///
-      /// Add a new ANode to the graph.
-      /// \return the new node.
-      Node addBNode();
-
-      /// \brief Add a new undirected edge to the graph.
-      ///
-      /// Add a new undirected edge to the graph. One of the nodes
-      /// should be ANode and the other should be BNode.
-      /// \pre The nodes are not in the same nodeset.
-      /// \return the new edge.
-      UEdge addEdge(const Node& from, const Node& to);
-
-      /// \brief Resets the graph.
-      ///
-      /// This function deletes all undirected edges and nodes of the graph.
-      /// It also frees the memory allocated to store them.
-      void clear() { }
-
-      template <typename Graph>
-      struct Constraints {
-	void constraints() {}
-      };
-
-    };
-
-    /// \brief An empty erasable undirected graph class.
-    ///
-    /// This class is an extension of \ref ExtendableBpUGraph. It makes it
-    /// possible to erase undirected edges or nodes.
-    class ErasableBpUGraph : public ExtendableBpUGraph {
-    public:
-
-      /// \brief Deletes a node.
-      ///
-      /// Deletes a node.
-      ///
-      void erase(Node) { }
-      /// \brief Deletes an undirected edge.
-      ///
-      /// Deletes an undirected edge.
-      ///
-      void erase(UEdge) { }
-
-      template <typename Graph>
-      struct Constraints {
-	void constraints() {}
-      };
-
-    };
 
     /// @}
Index: lemon/concept/graph.h
===================================================================
--- lemon/concept/graph.h	(revision 2090)
+++ lemon/concept/graph.h	(revision 2111)
@@ -39,6 +39,6 @@
     // \brief Modular static graph class.
     //     
-    // It should be the same as the \c StaticGraph class.
-    class _StaticGraph 
+    // It should be the same as the \c Graph class.
+    class _Graph 
       :  virtual public BaseGraphComponent,
          public IterableGraphComponent, public MappableGraphComponent {
@@ -57,47 +57,8 @@
     };
 
-    // \brief Modular extendable graph class.
-    //     
-    // It should be the same as the \c ExtendableGraph class.
-    class _ExtendableGraph 
-      :  virtual public BaseGraphComponent, public _StaticGraph,
-         public ExtendableGraphComponent, public ClearableGraphComponent {
-    public:
-      typedef BaseGraphComponent::Node Node;
-      typedef BaseGraphComponent::Edge Edge;
-
-      template <typename _Graph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<_StaticGraph, _Graph >();
-          checkConcept<ExtendableGraphComponent, _Graph >();
-          checkConcept<ClearableGraphComponent, _Graph >();
-        }
-      };
-    };
-
-    // \brief Modular erasable graph class.
-    //     
-    // It should be the same as the \c ErasableGraph class.
-    class _ErasableGraph 
-      :  virtual public BaseGraphComponent, public _ExtendableGraph,
-         public ErasableGraphComponent {
-    public:
-      typedef BaseGraphComponent::Node Node;
-      typedef BaseGraphComponent::Edge Edge;
-
-      template <typename _Graph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<_ExtendableGraph, _Graph >();
-          checkConcept<ErasableGraphComponent, _Graph >();
-        }
-      };
-    };
-
     /// \addtogroup graph_concepts
     /// @{
 
-    /// An empty static graph class.
+    /// An empty graph class.
   
     /// This class provides all the common features of a graph structure,
@@ -117,11 +78,5 @@
     /// \todo A pages describing the concept of concept description would
     /// be nice.
-    class StaticGraph
-    {
-//      ///Copy consructor.
-
-//       ///\todo It is not clear, what we expect from a copy constructor.
-//       ///E.g. How to assign the nodes/edges to each other? What about maps?
-//       StaticGraph(const StaticGraph& g) { }
+    class Graph {
     public:
       ///\e
@@ -131,5 +86,5 @@
       /// Defalult constructor.
       ///
-      StaticGraph() { }
+      Graph() { }
 
       /// The base type of node iterators, 
@@ -214,5 +169,5 @@
         /// Sets the iterator to the first node of \c g.
         ///
-        NodeIt(const StaticGraph&) { }
+        NodeIt(const Graph&) { }
         /// Node -> NodeIt conversion.
 
@@ -221,5 +176,5 @@
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        NodeIt(const StaticGraph&, const Node&) { }
+        NodeIt(const Graph&, const Node&) { }
         /// Next node.
 
@@ -308,5 +263,5 @@
         /// This constructor sets the iterator to the first outgoing edge of
         /// the node.
-        OutEdgeIt(const StaticGraph&, const Node&) { }
+        OutEdgeIt(const Graph&, const Node&) { }
         /// Edge -> OutEdgeIt conversion
 
@@ -314,5 +269,5 @@
 	/// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        OutEdgeIt(const StaticGraph&, const Edge&) { }
+        OutEdgeIt(const Graph&, const Edge&) { }
         ///Next outgoing edge
         
@@ -355,5 +310,5 @@
         /// This constructor set the iterator to the first incoming edge of
         /// the node.
-        InEdgeIt(const StaticGraph&, const Node&) { }
+        InEdgeIt(const Graph&, const Node&) { }
         /// Edge -> InEdgeIt conversion
 
@@ -361,5 +316,5 @@
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        InEdgeIt(const StaticGraph&, const Edge&) { }
+        InEdgeIt(const Graph&, const Edge&) { }
         /// Next incoming edge
 
@@ -398,5 +353,5 @@
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const StaticGraph& g) { ignore_unused_variable_warning(g); }
+        EdgeIt(const Graph& g) { ignore_unused_variable_warning(g); }
         /// Edge -> EdgeIt conversion
 
@@ -404,5 +359,5 @@
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        EdgeIt(const StaticGraph&, const Edge&) { } 
+        EdgeIt(const Graph&, const Edge&) { } 
         ///Next edge
         
@@ -421,51 +376,15 @@
       Node source(Edge) const { return INVALID; }
 
-//       /// Gives back the first Node in the iterating order.
-      
-//       /// Gives back the first Node in the iterating order.
-//       ///     
       void first(Node&) const {}
-
-//       /// Gives back the next Node in the iterating order.
-      
-//       /// Gives back the next Node in the iterating order.
-//       ///     
       void next(Node&) const {}
 
-//       /// Gives back the first Edge in the iterating order.
-      
-//       /// Gives back the first Edge in the iterating order.
-//       ///     
       void first(Edge&) const {}
-//       /// Gives back the next Edge in the iterating order.
-      
-//       /// Gives back the next Edge in the iterating order.
-//       ///     
       void next(Edge&) const {}
 
 
-//       /// Gives back the first of the Edges point to the given Node.
-      
-//       /// Gives back the first of the Edges point to the given Node.
-//       ///     
       void firstIn(Edge&, const Node&) const {}
-
-//       /// Gives back the next of the Edges points to the given Node.
-
-
-//       /// Gives back the next of the Edges points to the given Node.
-//       ///
       void nextIn(Edge&) const {}
 
-//       /// Gives back the first of the Edges start from the given Node.
-      
-//       /// Gives back the first of the Edges start from the given Node.
-//       ///     
       void firstOut(Edge&, const Node&) const {}
-
-//       /// Gives back the next of the Edges start from the given Node.
-      
-//       /// Gives back the next of the Edges start from the given Node.
-//       ///     
       void nextOut(Edge&) const {}
 
@@ -512,7 +431,7 @@
 
         ///\e
-        NodeMap(const StaticGraph&) { }
+        NodeMap(const Graph&) { }
         ///\e
-        NodeMap(const StaticGraph&, T) { }
+        NodeMap(const Graph&, T) { }
 
         ///Copy constructor
@@ -536,7 +455,7 @@
 
         ///\e
-        EdgeMap(const StaticGraph&) { }
+        EdgeMap(const Graph&) { }
         ///\e
-        EdgeMap(const StaticGraph&, T) { }
+        EdgeMap(const Graph&, T) { }
         ///Copy constructor
         EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
@@ -546,70 +465,6 @@
       };
 
-      template <typename _Graph>
-      struct Constraints : public _StaticGraph::Constraints<_Graph> {};
-
-    };
-
-    /// An empty non-static graph class.
-    
-    /// This class provides everything that \ref StaticGraph does.
-    /// Additionally it enables building graphs from scratch.
-    class ExtendableGraph : public StaticGraph
-    {
-    public:
-      /// Defalult constructor.
-
-      /// Defalult constructor.
-      ///
-      ExtendableGraph() { }
-      ///Add a new node to the graph.
-
-      /// \return the new node.
-      ///
-      Node addNode() { return INVALID; }
-      ///Add a new edge to the graph.
-
-      ///Add a new edge to the graph with source node \c s
-      ///and target node \c t.
-      ///\return the new edge.
-      Edge addEdge(Node, Node) { return INVALID; }
-    
-      /// Resets the graph.
-
-      /// This function deletes all edges and nodes of the graph.
-      /// It also frees the memory allocated to store them.
-      /// \todo It might belong to \ref ErasableGraph.
-      void clear() { }
-
-      template <typename _Graph>
-      struct Constraints : public _ExtendableGraph::Constraints<_Graph> {};
-
-    };
-
-    /// An empty erasable graph class.
-  
-    /// This class is an extension of \ref ExtendableGraph. It makes it
-    /// possible to erase edges or nodes.
-    class ErasableGraph : public ExtendableGraph
-    {
-    public:
-      /// Defalult constructor.
-
-      /// Defalult constructor.
-      ///
-      ErasableGraph() { }
-      /// Deletes a node.
-
-      /// Deletes node \c n node.
-      ///
-      void erase(Node) { }
-      /// Deletes an edge.
-
-      /// Deletes edge \c e edge.
-      ///
-      void erase(Edge) { }
-
-      template <typename _Graph>
-      struct Constraints : public _ErasableGraph::Constraints<_Graph> {};
+      template <typename RGraph>
+      struct Constraints : public _Graph::Constraints<RGraph> {};
 
     };
Index: lemon/concept/graph_component.h
===================================================================
--- lemon/concept/graph_component.h	(revision 1999)
+++ lemon/concept/graph_component.h	(revision 2111)
@@ -459,5 +459,5 @@
     /// core clear functions for the graph structure.
     /// The most of the base graphs should be conform to this concept.
-    class ClearableGraphComponent : virtual public BaseGraphComponent {
+    class BaseClearableGraphComponent : virtual public BaseGraphComponent {
     public:
 
@@ -647,5 +647,5 @@
     /// This class provides beside the core graph features
     /// iterator based iterable interface for the graph structure.
-    /// This concept is part of the StaticGraphConcept.
+    /// This concept is part of the GraphConcept.
     class IterableGraphComponent : virtual public BaseGraphComponent {
 
@@ -818,5 +818,5 @@
     /// This class provides beside the core graph features
     /// map interface for the graph structure.
-    /// This concept is part of the StaticGraphConcept.
+    /// This concept is part of the GraphConcept.
     class MappableGraphComponent : virtual public BaseGraphComponent {
     public:
@@ -931,84 +931,158 @@
     };
 
-    /// \brief An empty extendable extended graph class.
-    ///
-    /// This class provides beside the core graph features
-    /// item addition interface for the graph structure.
-    /// The difference between this class and the 
-    /// \c BaseExtendableGraphComponent is that it should
-    /// notify the item alteration observers.
-    class ExtendableGraphComponent : virtual public BaseGraphComponent {
-    public:
-
-      typedef ExtendableGraphComponent Graph;
-
-      typedef BaseGraphComponent::Node Node;
-      typedef BaseGraphComponent::Edge Edge;
-
-      /// \brief Add a node to the graph.
-      ///
-      /// Add a node to the graph and notify the observers.
-      Node addNode() {
-	return INVALID;
+
+//     /// Skeleton class which describes an edge with direction in \ref
+//     /// UGraph "undirected graph".
+    template <typename UGraph>
+    class UGraphEdge : public UGraph::UEdge {
+      typedef typename UGraph::UEdge UEdge;
+      typedef typename UGraph::Node Node;
+    public:
+
+      /// \e
+      UGraphEdge() {}
+
+      /// \e
+      UGraphEdge(const UGraphEdge& e) : UGraph::UEdge(e) {}
+
+      /// \e
+      UGraphEdge(Invalid) {}
+
+      /// \brief Directed edge from undirected edge and a source node.
+      ///
+      /// Constructs a directed edge from undirected edge and a source node.
+      ///
+      /// \note You have to specify the graph for this constructor.
+      UGraphEdge(const UGraph &g,
+		     UEdge u_edge, Node n) {
+	ignore_unused_variable_warning(u_edge);
+	ignore_unused_variable_warning(g);
+	ignore_unused_variable_warning(n);
       }
+
+      /// \e
+      UGraphEdge& operator=(UGraphEdge) { return *this; }
+
+      /// \e
+      bool operator==(UGraphEdge) const { return true; }
+      /// \e
+      bool operator!=(UGraphEdge) const { return false; }
+
+      /// \e
+      bool operator<(UGraphEdge) const { return false; }
+
+      template <typename Edge>
+      struct Constraints {
+	void constraints() {
+	  const_constraints();
+	}
+	void const_constraints() const {
+	  /// \bug This should be is_base_and_derived ...
+	  UEdge ue = e;
+	  ue = e;
+
+	  Edge e_with_source(graph,ue,n);
+	  ignore_unused_variable_warning(e_with_source);
+	}
+	Edge e;
+	UEdge ue;
+	UGraph graph;
+	Node n;
+      };
+    };
     
-      /// \brief Add an edge to the graph.
-      ///
-      /// Add an edge to the graph and notify the observers.
-      Edge addEdge(const Node&, const Node&) {
-	return INVALID;
-      }
-
-      template <typename _Graph>
-      struct Constraints {
-	void constraints() {
-	  checkConcept<BaseGraphComponent, _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 extended graph class.
-    ///
-    /// This class provides beside the core graph features
-    /// item erase interface for the graph structure.
-    /// The difference between this class and the 
-    /// \c BaseErasableGraphComponent is that it should
-    /// notify the item alteration observers.
-    class ErasableGraphComponent : virtual public BaseGraphComponent {
-    public:
-
-      typedef ErasableGraphComponent Graph;
-
-      typedef BaseGraphComponent::Node Node;
-      typedef BaseGraphComponent::Edge Edge;
-
-      /// \brief Erase the Node and notify the node alteration observers.
-      ///
-      ///  Erase the Node and notify the node alteration observers.
-      void erase(const Node&) {}    
-
-      /// \brief Erase the Edge and notify the edge alteration observers.
-      ///
-      ///  Erase the Edge and notify the edge alteration observers.
-      void erase(const Edge&) {}
-
-      template <typename _Graph>
-      struct Constraints {
-	void constraints() {
-	  checkConcept<BaseGraphComponent, _Graph >();
-	  typename _Graph::Node node;
-	  graph.erase(node);
-	  typename _Graph::Edge edge;
-	  graph.erase(edge);      
-	}
-
-	_Graph& graph;
-      };
+
+    struct BaseIterableUGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+
+	typedef typename Graph::UEdge UEdge;
+	typedef typename Graph::Edge Edge;
+	typedef typename Graph::Node Node;
+
+	void constraints() {
+	  checkConcept<BaseIterableGraphComponent, Graph>();
+	  checkConcept<GraphItem<>, UEdge>();
+	  //checkConcept<UGraphEdge<Graph>, Edge>();
+
+	  graph.first(ue);
+	  graph.next(ue);
+
+	  const_constraints();
+	}
+	void const_constraints() {
+	  Node n;
+	  n = graph.target(ue);
+	  n = graph.source(ue);
+	  n = graph.oppositeNode(n0, ue);
+
+	  bool b;
+	  b = graph.direction(e);
+	  Edge e = graph.direct(UEdge(), true);
+	  e = graph.direct(UEdge(), n);
+ 
+	  ignore_unused_variable_warning(b);
+	}
+
+	Graph graph;
+	Edge e;
+	Node n0;
+	UEdge ue;
+      };
+
+    };
+
+
+    struct IterableUGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+	void constraints() {
+	  /// \todo we don't need the iterable component to be base iterable
+	  /// Don't we really???
+	  //checkConcept< BaseIterableUGraphConcept, Graph > ();
+
+	  checkConcept<IterableGraphComponent, Graph> ();
+
+	  typedef typename Graph::UEdge UEdge;
+	  typedef typename Graph::UEdgeIt UEdgeIt;
+	  typedef typename Graph::IncEdgeIt IncEdgeIt;
+
+	  checkConcept<GraphIterator<Graph, UEdge>, UEdgeIt>();
+	  checkConcept<GraphIncIterator<Graph, UEdge>, IncEdgeIt>();
+	}
+      };
+
+    };
+
+    struct MappableUGraphConcept {
+
+      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 UEdgeMap<int> IntMap;
+	  checkConcept<GraphMap<Graph, typename Graph::UEdge, int>,
+	    IntMap >();
+
+	  typedef typename Graph::template UEdgeMap<bool> BoolMap;
+	  checkConcept<GraphMap<Graph, typename Graph::UEdge, bool>,
+	    BoolMap >();
+
+	  typedef typename Graph::template UEdgeMap<Dummy> DummyMap;
+	  checkConcept<GraphMap<Graph, typename Graph::UEdge, Dummy>,
+	    DummyMap >();
+	}
+      };
+
     };
 
Index: lemon/concept/ugraph.h
===================================================================
--- lemon/concept/ugraph.h	(revision 2021)
+++ lemon/concept/ugraph.h	(revision 2111)
@@ -19,5 +19,5 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief Undirected graphs and components of.
+///\brief The concept of the undirected graphs.
 
 
@@ -31,189 +31,4 @@
 namespace lemon {
   namespace concept {
-
-//     /// Skeleton class which describes an edge with direction in \ref
-//     /// UGraph "undirected graph".
-    template <typename UGraph>
-    class UGraphEdge : public UGraph::UEdge {
-      typedef typename UGraph::UEdge UEdge;
-      typedef typename UGraph::Node Node;
-    public:
-
-      /// \e
-      UGraphEdge() {}
-
-      /// \e
-      UGraphEdge(const UGraphEdge& e) : UGraph::UEdge(e) {}
-
-      /// \e
-      UGraphEdge(Invalid) {}
-
-      /// \brief Directed edge from undirected edge and a source node.
-      ///
-      /// Constructs a directed edge from undirected edge and a source node.
-      ///
-      /// \note You have to specify the graph for this constructor.
-      UGraphEdge(const UGraph &g,
-		     UEdge u_edge, Node n) {
-	ignore_unused_variable_warning(u_edge);
-	ignore_unused_variable_warning(g);
-	ignore_unused_variable_warning(n);
-      }
-
-      /// \e
-      UGraphEdge& operator=(UGraphEdge) { return *this; }
-
-      /// \e
-      bool operator==(UGraphEdge) const { return true; }
-      /// \e
-      bool operator!=(UGraphEdge) const { return false; }
-
-      /// \e
-      bool operator<(UGraphEdge) const { return false; }
-
-      template <typename Edge>
-      struct Constraints {
-	void constraints() {
-	  const_constraints();
-	}
-	void const_constraints() const {
-	  /// \bug This should be is_base_and_derived ...
-	  UEdge ue = e;
-	  ue = e;
-
-	  Edge e_with_source(graph,ue,n);
-	  ignore_unused_variable_warning(e_with_source);
-	}
-	Edge e;
-	UEdge ue;
-	UGraph graph;
-	Node n;
-      };
-    };
-    
-
-    struct BaseIterableUGraphConcept {
-
-      template <typename Graph>
-      struct Constraints {
-
-	typedef typename Graph::UEdge UEdge;
-	typedef typename Graph::Edge Edge;
-	typedef typename Graph::Node Node;
-
-	void constraints() {
-	  checkConcept<BaseIterableGraphComponent, Graph>();
-	  checkConcept<GraphItem<>, UEdge>();
-	  //checkConcept<UGraphEdge<Graph>, Edge>();
-
-	  graph.first(ue);
-	  graph.next(ue);
-
-	  const_constraints();
-	}
-	void const_constraints() {
-	  Node n;
-	  n = graph.target(ue);
-	  n = graph.source(ue);
-	  n = graph.oppositeNode(n0, ue);
-
-	  bool b;
-	  b = graph.direction(e);
-	  Edge e = graph.direct(UEdge(), true);
-	  e = graph.direct(UEdge(), n);
- 
-	  ignore_unused_variable_warning(b);
-	}
-
-	Graph graph;
-	Edge e;
-	Node n0;
-	UEdge ue;
-      };
-
-    };
-
-
-    struct IterableUGraphConcept {
-
-      template <typename Graph>
-      struct Constraints {
-	void constraints() {
-	  /// \todo we don't need the iterable component to be base iterable
-	  /// Don't we really???
-	  //checkConcept< BaseIterableUGraphConcept, Graph > ();
-
-	  checkConcept<IterableGraphComponent, Graph> ();
-
-	  typedef typename Graph::UEdge UEdge;
-	  typedef typename Graph::UEdgeIt UEdgeIt;
-	  typedef typename Graph::IncEdgeIt IncEdgeIt;
-
-	  checkConcept<GraphIterator<Graph, UEdge>, UEdgeIt>();
-	  checkConcept<GraphIncIterator<Graph, UEdge>, IncEdgeIt>();
-	}
-      };
-
-    };
-
-    struct MappableUGraphConcept {
-
-      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 UEdgeMap<int> IntMap;
-	  checkConcept<GraphMap<Graph, typename Graph::UEdge, int>,
-	    IntMap >();
-
-	  typedef typename Graph::template UEdgeMap<bool> BoolMap;
-	  checkConcept<GraphMap<Graph, typename Graph::UEdge, bool>,
-	    BoolMap >();
-
-	  typedef typename Graph::template UEdgeMap<Dummy> DummyMap;
-	  checkConcept<GraphMap<Graph, typename Graph::UEdge, Dummy>,
-	    DummyMap >();
-	}
-      };
-
-    };
-
-    struct ExtendableUGraphConcept {
-
-      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::UEdge uedge;
-	Graph graph;
-      };
-
-    };
-
-    struct ErasableUGraphConcept {
-
-      template <typename Graph>
-      struct Constraints {
-	void constraints() {
-	  graph.erase(n);
-	  graph.erase(e);
-	}
-	Graph graph;
-	typename Graph::Node n;
-	typename Graph::UEdge e;
-      };
-
-    };
 
     /// \addtogroup graph_concepts
@@ -232,11 +47,11 @@
     ///
     /// In LEMON undirected graphs also fulfill the concept of directed
-    /// graphs (\ref lemon::concept::StaticGraph "Graph Concept"). For
-    /// explanation of this and more see also the page \ref ugraphs,
-    /// a tutorial about undirected graphs.
+    /// graphs (\ref lemon::concept::Graph "Graph Concept"). For
+    /// explanation of this and more see also the page \ref graphs,
+    /// a tutorial about graphs.
     ///
     /// You can assume that all undirected graph can be handled
-    /// as a static directed graph. This way it is fully conform
-    /// to the StaticGraph concept.
+    /// as a directed graph. This way it is fully conform
+    /// to the Graph concept.
 
     class UGraph {
@@ -800,72 +615,21 @@
       Node target(Edge) const { return INVALID; }
 
-//       /// \brief First node of the graph
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void first(Node&) const {}
-//       /// \brief Next node of the graph
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void next(Node&) const {}
 
-//       /// \brief First undirected edge of the graph
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void first(UEdge&) const {}
-//       /// \brief Next undirected edge of the graph
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void next(UEdge&) const {}
 
-//       /// \brief First directed edge of the graph
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void first(Edge&) const {}
-//       /// \brief Next directed edge of the graph
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void next(Edge&) const {}
 
-//       /// \brief First outgoing edge from a given node
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void firstOut(Edge&, Node) const {}
-//       /// \brief Next outgoing edge to a node
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void nextOut(Edge&) const {}
 
-//       /// \brief First incoming edge to a given node
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void firstIn(Edge&, Node) const {}
-//       /// \brief Next incoming edge to a node
-//       ///
-//       /// \note This method is part of so called \ref
-//       /// developpers_interface "Developpers' interface", so it shouldn't
-//       /// be used in an end-user program.
       void nextIn(Edge&) const {}
 
 
       void firstInc(UEdge &, bool &, const Node &) const {}
-
       void nextInc(UEdge &, bool &) const {}
 
@@ -923,72 +687,4 @@
     };
 
-    /// \brief An empty non-static undirected graph class.
-    ///    
-    /// This class provides everything that \ref UGraph does.
-    /// Additionally it enables building graphs from scratch.
-    class ExtendableUGraph : public UGraph {
-    public:
-      
-      /// \brief Add a new node to the graph.
-      ///
-      /// Add a new node to the graph.
-      /// \return the new node.
-      Node addNode();
-
-      /// \brief Add a new undirected edge to the graph.
-      ///
-      /// Add a new undirected edge to the graph.
-      /// \return the new edge.
-      UEdge addEdge(const Node& from, const Node& to);
-
-      /// \brief Resets the graph.
-      ///
-      /// This function deletes all undirected edges and nodes of the graph.
-      /// It also frees the memory allocated to store them.
-      void clear() { }
-
-      template <typename Graph>
-      struct Constraints {
-	void constraints() {
-	  checkConcept<BaseIterableUGraphConcept, Graph>();
-	  checkConcept<IterableUGraphConcept, Graph>();
-	  checkConcept<MappableUGraphConcept, Graph>();
-
-	  checkConcept<UGraph, Graph>();
-	  checkConcept<ExtendableUGraphConcept, Graph>();
-	  checkConcept<ClearableGraphComponent, Graph>();
-	}
-      };
-
-    };
-
-    /// \brief An empty erasable undirected graph class.
-    ///
-    /// This class is an extension of \ref ExtendableUGraph. It makes it
-    /// possible to erase undirected edges or nodes.
-    class ErasableUGraph : public ExtendableUGraph {
-    public:
-
-      /// \brief Deletes a node.
-      ///
-      /// Deletes a node.
-      ///
-      void erase(Node) { }
-      /// \brief Deletes an undirected edge.
-      ///
-      /// Deletes an undirected edge.
-      ///
-      void erase(UEdge) { }
-
-      template <typename Graph>
-      struct Constraints {
-	void constraints() {
-	  checkConcept<ExtendableUGraph, Graph>();
-	  checkConcept<ErasableUGraphConcept, Graph>();
-	}
-      };
-
-    };
-
     /// @}
 
Index: lemon/dag_shortest_path.h
===================================================================
--- lemon/dag_shortest_path.h	(revision 1999)
+++ lemon/dag_shortest_path.h	(revision 2111)
@@ -275,5 +275,5 @@
   /// DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits.
   /// \param _LengthMap This read-only EdgeMap determines the lengths of the
-  /// edges. The default map type is \ref concept::StaticGraph::EdgeMap 
+  /// edges. The default map type is \ref concept::Graph::EdgeMap 
   /// "Graph::EdgeMap<int>".  The value of _LengthMap is not used directly 
   /// by DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits.  
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 2010)
+++ lemon/dijkstra.h	(revision 2111)
@@ -158,5 +158,5 @@
   ///relatively time consuming process to compute the edge length if
   ///it is necessary. The default map type is \ref
-  ///concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>".  The value
+  ///concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   ///of LM is not used directly by Dijkstra, it is only passed to \ref
   ///DijkstraDefaultTraits.  \param TR Traits class to set
Index: lemon/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 2076)
+++ lemon/edge_set.h	(revision 2111)
@@ -239,9 +239,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::StaticGraph
-  /// "StaticGraph" concept.
+  /// this class. Its interface must conform to the \ref concept::Graph
+  /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::ErasableGraph "ErasableGraph" concept.
+  /// \ref concept::Graph "Graph" concept.
   template <typename _Graph>
   class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<_Graph> > {
@@ -331,9 +331,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::StaticGraph
-  /// "StaticGraph" concept.
+  /// this class. Its interface must conform to the \ref concept::Graph
+  /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::ErasableUGraph "ErasableUGraph" concept.
+  /// \ref concept::UGraph "UGraph" concept.
   template <typename _Graph>
   class ListUEdgeSet 
@@ -568,9 +568,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::StaticGraph
-  /// "StaticGraph" concept.
+  /// this class. Its interface must conform to the \ref concept::Graph
+  /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
+  /// \ref concept::Graph "Graph" concept.
   template <typename _Graph>
   class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<_Graph> > {
@@ -663,9 +663,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::StaticGraph
-  /// "StaticGraph" concept.
+  /// this class. Its interface must conform to the \ref concept::Graph
+  /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::ExtendableUGraph "ExtendableUGraph" concept.
+  /// \ref concept::UGraph "UGraph" concept.
   template <typename _Graph>
   class SmartUEdgeSet 
Index: lemon/floyd_warshall.h
===================================================================
--- lemon/floyd_warshall.h	(revision 2042)
+++ lemon/floyd_warshall.h	(revision 2111)
@@ -172,5 +172,5 @@
   /// relatively time consuming process to compute the edge length if
   /// it is necessary. The default map type is \ref
-  /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of _LengthMap is not used directly by FloydWarshall, it is only passed 
   /// to \ref FloydWarshallDefaultTraits.  \param _Traits Traits class to set
Index: lemon/full_graph.h
===================================================================
--- lemon/full_graph.h	(revision 2076)
+++ lemon/full_graph.h	(revision 2111)
@@ -215,6 +215,6 @@
   /// edges or nodes.
   /// Thus it conforms to
-  /// the \ref concept::StaticGraph "StaticGraph" concept
-  /// \sa concept::StaticGraph.
+  /// the \ref concept::Graph "Graph" concept
+  /// \sa concept::Graph.
   ///
   /// \sa FullGraphBase
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 2084)
+++ lemon/graph_adaptor.h	(revision 2111)
@@ -2425,5 +2425,5 @@
   ///
   /// This graph adaptor is fully conform to the 
-  /// \ref concept::StaticGraph "StaticGraph" concept and
+  /// \ref concept::Graph "Graph" concept and
   /// contains some additional member functions and types. The 
   /// documentation of some member functions may be found just in the
Index: lemon/hypercube_graph.h
===================================================================
--- lemon/hypercube_graph.h	(revision 1998)
+++ lemon/hypercube_graph.h	(revision 2111)
@@ -250,5 +250,5 @@
   /// is 26. 
   ///
-  /// The graph type is fully conform to the \ref concept::StaticGraph
+  /// The graph type is fully conform to the \ref concept::Graph
   /// concept but it does not conform to the \ref concept::UGraph.
   ///
Index: lemon/johnson.h
===================================================================
--- lemon/johnson.h	(revision 2042)
+++ lemon/johnson.h	(revision 2111)
@@ -207,5 +207,5 @@
   /// relatively time consuming process to compute the edge length if
   /// it is necessary. The default map type is \ref
-  /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of _LengthMap is not used directly by Johnson, it is only passed 
   /// to \ref JohnsonDefaultTraits.  \param _Traits Traits class to set
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 2084)
+++ lemon/kruskal.h	(revision 2111)
@@ -45,5 +45,5 @@
   ///
   /// \param g The graph the algorithm runs on.
-  /// It can be either \ref concept::StaticGraph "directed" or 
+  /// It can be either \ref concept::Graph "directed" or 
   /// \ref concept::UGraph "undirected".
   /// If the graph is directed, the algorithm consider it to be 
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 2107)
+++ lemon/list_graph.h	(revision 2111)
@@ -275,5 +275,5 @@
 
   protected:
-    void _changeTarget(Edge e, Node n) 
+    void changeTarget(Edge e, Node n) 
     {
       if(edges[e.id].next_in != -1)
@@ -290,5 +290,5 @@
       nodes[n.id].first_in = e.id;
     }
-    void _changeSource(Edge e, Node n) 
+    void changeSource(Edge e, Node n) 
     {
       if(edges[e.id].next_out != -1)
@@ -317,8 +317,9 @@
   ///This is a simple and fast erasable graph implementation.
   ///
-  ///It conforms to the
-  ///\ref concept::ErasableGraph "ErasableGraph" concept and
-  ///it also provides several additional useful extra functionalities.
-  ///\sa concept::ErasableGraph.
+  ///It conforms to the \ref concept::Graph "Graph" concept and it
+  ///also provides several additional useful extra functionalities.
+  ///The most of the member functions and nested classes are
+  ///documented only in the concept class.
+  ///\sa concept::Graph.
 
   class ListGraph : public ExtendedListGraphBase {
@@ -326,4 +327,19 @@
 
     typedef ExtendedListGraphBase Parent;
+
+    ///Add a new node to the graph.
+    
+    /// \return the new node.
+    ///
+    Node addNode() { return Parent::addNode(); }
+
+    ///Add a new edge to the graph.
+    
+    ///Add a new edge to the graph with source node \c s
+    ///and target node \c t.
+    ///\return the new edge.
+    Edge addEdge(const Node& s, const Node& t) { 
+      return Parent::addEdge(s, t); 
+    }
 
     /// Changes the target of \c e to \c n
@@ -335,5 +351,5 @@
     ///valid. However <tt>InEdge</tt>s are invalidated.
     void changeTarget(Edge e, Node n) { 
-      _changeTarget(e,n); 
+      Parent::changeTarget(e,n); 
     }
     /// Changes the source of \c e to \c n
@@ -345,5 +361,5 @@
     ///valid. However <tt>OutEdge</tt>s are invalidated.
     void changeSource(Edge e, Node n) { 
-      _changeSource(e,n);
+      Parent::changeSource(e,n);
     }
 
@@ -355,10 +371,10 @@
     void reverseEdge(Edge e) {
       Node t=target(e);
-      _changeTarget(e,source(e));
-      _changeSource(e,t);
-    }
-
-    ///Using this it is possible to avoid the superfluous memory
-    ///allocation.
+      changeTarget(e,source(e));
+      changeSource(e,t);
+    }
+
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
 
     ///Using this it is possible to avoid the superfluous memory
@@ -368,6 +384,6 @@
     void reserveNode(int n) { nodes.reserve(n); };
 
-    ///Using this it is possible to avoid the superfluous memory
-    ///allocation.
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
 
     ///Using this it is possible to avoid the superfluous memory
@@ -599,4 +615,18 @@
   public:
     typedef ExtendedListUGraphBase Parent;
+    /// \brief Add a new node to the graph.
+    ///
+    /// \return the new node.
+    ///
+    Node addNode() { return Parent::addNode(); }
+
+    /// \brief Add a new edge to the graph.
+    ///
+    /// Add a new edge to the graph with source node \c s
+    /// and target node \c t.
+    /// \return the new undirected edge.
+    UEdge addEdge(const Node& s, const Node& t) { 
+      return Parent::addEdge(s, t); 
+    }
     /// \brief Changes the target of \c e to \c n
     ///
@@ -607,5 +637,5 @@
     /// valid. However <tt>InEdge</tt>'s are invalidated.
     void changeTarget(UEdge e, Node n) { 
-      _changeTarget(e,n); 
+      Parent::changeTarget(e,n); 
     }
     /// Changes the source of \c e to \c n
@@ -617,5 +647,5 @@
     ///valid. However <tt>OutEdge</tt>'s are invalidated.
     void changeSource(UEdge e, Node n) { 
-      _changeSource(e,n); 
+      Parent::changeSource(e,n); 
     }
     /// \brief Contract two nodes.
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 2042)
+++ lemon/min_cost_arborescence.h	(revision 2111)
@@ -111,5 +111,5 @@
   /// relatively time consuming process to compute the edge cost if
   /// it is necessary. The default map type is \ref
-  /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of _CostMap is not used directly by MinCostArborescence, 
   /// it is only passed to \ref MinCostArborescenceDefaultTraits.  
Index: lemon/min_cut.h
===================================================================
--- lemon/min_cut.h	(revision 2094)
+++ lemon/min_cut.h	(revision 2111)
@@ -180,5 +180,5 @@
   /// relatively time consuming process to compute the edge capacity if
   /// it is necessary. The default map type is \ref
-  /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of CapacityMap is not used directly by search algorithm, it is only 
   /// passed to \ref MaxCardinalitySearchDefaultTraits.  
@@ -702,5 +702,5 @@
     typedef _Graph Graph;
 
-    /// The AuxGraph type which is an ErasableGraph
+    /// The AuxGraph type which is an Graph
     typedef ListUGraph AuxGraph;
 
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 2076)
+++ lemon/smart_graph.h	(revision 2111)
@@ -240,6 +240,6 @@
   ///node and edge deletions</b>.
   ///It conforms to 
-  ///the \ref concept::ExtendableGraph "ExtendableGraph" concept.
-  ///\sa concept::ExtendableGraph.
+  ///the \ref concept::Graph "Graph" concept.
+  ///\sa concept::Graph.
   ///
   ///\author Alpar Juttner
Index: lemon/topology.h
===================================================================
--- lemon/topology.h	(revision 2082)
+++ lemon/topology.h	(revision 2111)
@@ -245,5 +245,5 @@
   template <typename Graph>
   bool stronglyConnected(const Graph& graph) {
-    checkConcept<concept::StaticGraph, Graph>();
+    checkConcept<concept::Graph, Graph>();
 
     typedef typename Graph::Node Node;
@@ -303,5 +303,5 @@
   template <typename Graph>
   int countStronglyConnectedComponents(const Graph& graph) {
-    checkConcept<concept::StaticGraph, Graph>();
+    checkConcept<concept::Graph, Graph>();
 
     using namespace _topology_bits;
@@ -372,5 +372,5 @@
   template <typename Graph, typename NodeMap>
   int stronglyConnectedComponents(const Graph& graph, NodeMap& compMap) {
-    checkConcept<concept::StaticGraph, Graph>();
+    checkConcept<concept::Graph, Graph>();
     typedef typename Graph::Node Node;
     typedef typename Graph::NodeIt NodeIt;
@@ -435,5 +435,5 @@
   template <typename Graph, typename EdgeMap>
   int stronglyConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {
-    checkConcept<concept::StaticGraph, Graph>();
+    checkConcept<concept::Graph, Graph>();
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
@@ -1206,5 +1206,5 @@
     using namespace _topology_bits;
 
-    checkConcept<concept::StaticGraph, Graph>();
+    checkConcept<concept::Graph, Graph>();
     checkConcept<concept::WriteMap<typename Graph::Node, int>, NodeMap>();
 
@@ -1248,5 +1248,5 @@
     using namespace _topology_bits;
 
-    checkConcept<concept::StaticGraph, Graph>();
+    checkConcept<concept::Graph, Graph>();
     checkConcept<concept::ReadWriteMap<typename Graph::Node, int>, NodeMap>();
 
@@ -1291,5 +1291,5 @@
   bool dag(const Graph& graph) {
 
-    checkConcept<concept::StaticGraph, Graph>();
+    checkConcept<concept::Graph, Graph>();
 
     typedef typename Graph::Node Node;
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 1956)
+++ test/bfs_test.cc	(revision 2111)
@@ -30,5 +30,5 @@
 void check_Bfs_Compile() 
 {
-  typedef concept::StaticGraph Graph;
+  typedef concept::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -67,5 +67,5 @@
 {
   typedef int VType;
-  typedef concept::StaticGraph Graph;
+  typedef concept::Graph Graph;
 
   typedef Graph::Edge Edge;
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 1956)
+++ test/dfs_test.cc	(revision 2111)
@@ -30,5 +30,5 @@
 void check_Dfs_SmartGraph_Compile() 
 {
-  typedef concept::StaticGraph Graph;
+  typedef concept::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -68,5 +68,5 @@
 {
   typedef int VType;
-  typedef concept::StaticGraph Graph;
+  typedef concept::Graph Graph;
 
   typedef Graph::Edge Edge;
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 1956)
+++ test/dijkstra_test.cc	(revision 2111)
@@ -32,5 +32,5 @@
 {
   typedef int VType;
-  typedef concept::StaticGraph Graph;
+  typedef concept::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -71,5 +71,5 @@
 {
   typedef int VType;
-  typedef concept::StaticGraph Graph;
+  typedef concept::Graph Graph;
 
   typedef Graph::Edge Edge;
Index: test/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 1990)
+++ test/edge_set_test.cc	(revision 2111)
@@ -18,12 +18,12 @@
 using namespace lemon::concept;
 
-typedef SmartGraph Graph;
+typedef SmartGraph RGraph;
 
 int main() {
   { // checking edge_sets
-    checkConcept<StaticGraph, ListEdgeSet<Graph> >();
-    checkConcept<UGraph, ListUEdgeSet<Graph> >();
-    checkConcept<StaticGraph, SmartEdgeSet<Graph> >();
-    checkConcept<UGraph, SmartUEdgeSet<Graph> >();
+    checkConcept<Graph, ListEdgeSet<RGraph> >();
+    checkConcept<UGraph, ListUEdgeSet<RGraph> >();
+    checkConcept<Graph, SmartEdgeSet<RGraph> >();
+    checkConcept<UGraph, SmartUEdgeSet<RGraph> >();
   }
 
Index: test/graph_adaptor_test.cc
===================================================================
--- test/graph_adaptor_test.cc	(revision 1991)
+++ test/graph_adaptor_test.cc	(revision 2111)
@@ -47,20 +47,20 @@
 {
   {
-    typedef StaticGraph Graph;
-    checkConcept<StaticGraph, GraphAdaptor<Graph> >();
+    typedef Graph Graph;
+    checkConcept<Graph, GraphAdaptor<Graph> >();
 
-    checkConcept<StaticGraph, RevGraphAdaptor<Graph> >();
+    checkConcept<Graph, RevGraphAdaptor<Graph> >();
 
-    checkConcept<StaticGraph, SubGraphAdaptor<Graph, 
+    checkConcept<Graph, SubGraphAdaptor<Graph, 
       Graph::NodeMap<bool> , Graph::EdgeMap<bool> > >();
-    checkConcept<StaticGraph, NodeSubGraphAdaptor<Graph, 
+    checkConcept<Graph, NodeSubGraphAdaptor<Graph, 
       Graph::NodeMap<bool> > >();
-    checkConcept<StaticGraph, EdgeSubGraphAdaptor<Graph, 
+    checkConcept<Graph, EdgeSubGraphAdaptor<Graph, 
       Graph::EdgeMap<bool> > >();
     
-    checkConcept<StaticGraph, ResGraphAdaptor<Graph, int, 
+    checkConcept<Graph, ResGraphAdaptor<Graph, int, 
       Graph::EdgeMap<int>, Graph::EdgeMap<int> > >();
 
-    checkConcept<StaticGraph, ErasingFirstGraphAdaptor<Graph, 
+    checkConcept<Graph, ErasingFirstGraphAdaptor<Graph, 
       Graph::NodeMap<Graph::Edge> > >(); 
 
@@ -74,5 +74,5 @@
       UGraph::UEdgeMap<bool> > >();
 
-    checkConcept<StaticGraph, DirUGraphAdaptor<UGraph, 
+    checkConcept<Graph, DirUGraphAdaptor<UGraph, 
       UGraph::UEdgeMap<bool> > >();
   }
Index: test/graph_factory_test.cc
===================================================================
--- test/graph_factory_test.cc	(revision 1956)
+++ test/graph_factory_test.cc	(revision 2111)
@@ -71,18 +71,18 @@
 
 //Compile Graph
-template void lemon::concept::checkCompileStaticGraph<concept::StaticGraph>
-(concept::StaticGraph &);
+template void lemon::concept::checkCompileGraph<concept::Graph>
+(concept::Graph &);
 
 template
-void lemon::concept::checkCompileExtendableGraph<concept::ExtendableGraph>
-(concept::ExtendableGraph &);
+void lemon::concept::checkCompileGraph<concept::Graph>
+(concept::Graph &);
 
 template
-void lemon::concept::checkCompileErasableGraph<concept::ErasableGraph>
-(concept::ErasableGraph &);
+void lemon::concept::checkCompileGraph<concept::Graph>
+(concept::Graph &);
 
 //Compile SmartGraph
 template
-void lemon::concept::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
+void lemon::concept::checkCompileGraph<SmartGraph>(SmartGraph &);
 template
 void lemon::concept::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
@@ -94,7 +94,7 @@
 //Compile ListGraph
 template
-void lemon::concept::checkCompileExtendableGraph<ListGraph>(ListGraph &);
+void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
 template
-void lemon::concept::checkCompileErasableGraph<ListGraph>(ListGraph &);
+void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
 template
 void lemon::concept::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
@@ -103,9 +103,9 @@
 //Compile SymListGraph
 //template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
-//template void hugo::checkCompileErasableGraph<SymListGraph>(SymListGraph &);
+//template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
 //template void hugo::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
 
 //Compile FullGraph
-template void lemon::concept::checkCompileStaticGraph<FullGraph>(FullGraph &);
+template void lemon::concept::checkCompileGraph<FullGraph>(FullGraph &);
 template
 void lemon::concept::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 1956)
+++ test/graph_test.cc	(revision 2111)
@@ -44,22 +44,14 @@
     checkConcept<MaxIDableGraphComponent, MaxIDableGraphComponent >();
 
-    checkConcept<BaseExtendableGraphComponent, BaseExtendableGraphComponent >();
-    checkConcept<BaseErasableGraphComponent, BaseErasableGraphComponent >();
-
     checkConcept<IterableGraphComponent, IterableGraphComponent >();
 
     checkConcept<MappableGraphComponent, MappableGraphComponent >();
 
-    checkConcept<ExtendableGraphComponent, ExtendableGraphComponent >();
-    checkConcept<ErasableGraphComponent, ErasableGraphComponent >();
-    checkConcept<ClearableGraphComponent, ClearableGraphComponent >();
   }
   { // checking skeleton graphs
-    checkConcept<StaticGraph, StaticGraph >();
-    checkConcept<ExtendableGraph, ExtendableGraph >();
-    checkConcept<ErasableGraph, ErasableGraph >();
+    checkConcept<Graph, Graph >();
   }
   { // checking list graph
-    checkConcept<ErasableGraph, ListGraph >();
+    checkConcept<Graph, ListGraph >();
 
     checkGraph<ListGraph>();
@@ -68,5 +60,5 @@
   }
   { // checking smart graph
-    checkConcept<ExtendableGraph, SmartGraph >();
+    checkConcept<Graph, SmartGraph >();
 
     checkGraph<SmartGraph>();
@@ -75,8 +67,8 @@
   }
   { // checking full graph
-    checkConcept<StaticGraph, FullGraph >();
+    checkConcept<Graph, FullGraph >();
   }
   { // checking full graph
-    checkConcept<StaticGraph, HyperCubeGraph >();
+    checkConcept<Graph, HyperCubeGraph >();
   }
 
Index: test/kruskal_test.cc
===================================================================
--- test/kruskal_test.cc	(revision 1956)
+++ test/kruskal_test.cc	(revision 2111)
@@ -33,8 +33,8 @@
 void checkCompileKruskal()
 {
-  concept::WriteMap<concept::StaticGraph::Edge,bool> w;
+  concept::WriteMap<concept::Graph::Edge,bool> w;
 
-  kruskal(concept::StaticGraph(),
-	  concept::ReadMap<concept::StaticGraph::Edge,int>(),
+  kruskal(concept::Graph(),
+	  concept::ReadMap<concept::Graph::Edge,int>(),
 	  w);
 }
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 2108)
+++ test/preflow_test.cc	(revision 2111)
@@ -32,5 +32,5 @@
 {
   typedef int VType;
-  typedef concept::StaticGraph Graph;
+  typedef concept::Graph Graph;
 
   typedef Graph::Node Node;
Index: test/ugraph_test.cc
===================================================================
--- test/ugraph_test.cc	(revision 1979)
+++ test/ugraph_test.cc	(revision 2111)
@@ -34,8 +34,6 @@
 void check_concepts() {
   checkConcept<UGraph, ListUGraph>();
-  checkConcept<ErasableUGraph, ListUGraph>();
 
   checkConcept<UGraph, SmartUGraph>();
-  checkConcept<ExtendableUGraph, SmartUGraph>();
 
   checkConcept<UGraph, FullUGraph>();
