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