diff -r 0631847b37e5 -r 09f9abe22df2 src/lemon/graph_wrapper.h
--- a/src/lemon/graph_wrapper.h	Mon Nov 08 15:24:53 2004 +0000
+++ b/src/lemon/graph_wrapper.h	Mon Nov 08 16:33:53 2004 +0000
@@ -108,104 +108,54 @@
   /// differences should be implemented.
   ///
   ///\author Marton Makai 
-  template<typename Graph>
-  class GraphWrapper {
+  template<typename _Graph>
+  class GraphWrapperBase {
+  public:
+    typedef _Graph Graph;
+    /// \todo Is it needed?
+    typedef Graph BaseGraph;
+    typedef Graph ParentGraph;
+
   protected:
     Graph* graph;
-    GraphWrapper() : graph(0) { }
+    GraphWrapperBase() : graph(0) { }
     void setGraph(Graph& _graph) { graph=&_graph; }
 
   public:
-    typedef Graph BaseGraph;
-    typedef Graph ParentGraph;
-
-    GraphWrapper(Graph& _graph) : graph(&_graph) { }
-    GraphWrapper(const GraphWrapper<Graph>& gw) : graph(gw.graph) { }
+    GraphWrapperBase(Graph& _graph) : graph(&_graph) { }
+    GraphWrapperBase(const GraphWrapperBase<_Graph>& gw) : graph(gw.graph) { }
  
     typedef typename Graph::Node Node;
-    class NodeIt : public Node { 
-      const GraphWrapper<Graph>* gw;
-      friend class GraphWrapper<Graph>;
-     public:
-      NodeIt() { }
-      NodeIt(Invalid i) : Node(i) { }
-      NodeIt(const GraphWrapper<Graph>& _gw) : 
-	Node(typename Graph::NodeIt(*(_gw.graph))), gw(&_gw) { }
-      NodeIt(const GraphWrapper<Graph>& _gw, const Node& n) : 
-	Node(n), gw(&_gw) { }
-      NodeIt& operator++() { 
-	*(static_cast<Node*>(this))=
-	  ++(typename Graph::NodeIt(*(gw->graph), *this));
-	return *this; 
-      }
-    };
     typedef typename Graph::Edge Edge;
-    class OutEdgeIt : public Edge { 
-      const GraphWrapper<Graph>* gw;
-      friend class GraphWrapper<Graph>;
-     public:
-      OutEdgeIt() { }
-      OutEdgeIt(Invalid i) : Edge(i) { }
-      OutEdgeIt(const GraphWrapper<Graph>& _gw, const Node& n) : 
-	Edge(typename Graph::OutEdgeIt(*(_gw.graph), n)), gw(&_gw) { }
-      OutEdgeIt(const GraphWrapper<Graph>& _gw, const Edge& e) : 
-	Edge(e), gw(&_gw) { }
-      OutEdgeIt& operator++() { 
-	*(static_cast<Edge*>(this))=
-	  ++(typename Graph::OutEdgeIt(*(gw->graph), *this));
-	return *this; 
-      }
-    };
-    class InEdgeIt : public Edge { 
-      const GraphWrapper<Graph>* gw;
-      friend class GraphWrapper<Graph>;
-     public:
-      InEdgeIt() { }
-      InEdgeIt(Invalid i) : Edge(i) { }
-      InEdgeIt(const GraphWrapper<Graph>& _gw, const Node& n) : 
-	Edge(typename Graph::InEdgeIt(*(_gw.graph), n)), gw(&_gw) { }
-      InEdgeIt(const GraphWrapper<Graph>& _gw, const Edge& e) : 
-	Edge(e), gw(&_gw) { }
-      InEdgeIt& operator++() { 
-	*(static_cast<Edge*>(this))=
-	  ++(typename Graph::InEdgeIt(*(gw->graph), *this));
-	return *this; 
-      }
-    };
-    class EdgeIt : public Edge { 
-      const GraphWrapper<Graph>* gw;
-      friend class GraphWrapper<Graph>;
-     public:
-      EdgeIt() { }
-      EdgeIt(Invalid i) : Edge(i) { }
-      EdgeIt(const GraphWrapper<Graph>& _gw) : 
-	Edge(typename Graph::EdgeIt(*(_gw.graph))), gw(&_gw) { }
-      EdgeIt(const GraphWrapper<Graph>& _gw, const Edge& e) : 
-	Edge(e), gw(&_gw) { }
-      EdgeIt& operator++() { 
-	*(static_cast<Edge*>(this))=
-	  ++(typename Graph::EdgeIt(*(gw->graph), *this));
-	return *this; 
-      }
-    };
    
-    NodeIt& first(NodeIt& i) const { 
-      i=NodeIt(*this); return i;
-    }
-    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
-      i=OutEdgeIt(*this, p); return i;
-    }
-    InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
-      i=InEdgeIt(*this, p); return i;
-    }
-    EdgeIt& first(EdgeIt& i) const { 
-      i=EdgeIt(*this); return i;
-    }
+    void first(Node& i) const { graph->first(i); }
+    void first(Edge& i) const { graph->first(i); }
+    void firstIn(Edge& i, const Node& n) const { graph->firstIn(i, n); }
+    void firstOut(Edge& i, const Node& n ) const { graph->firstOut(i, n); }
+//     NodeIt& first(NodeIt& i) const { 
+//       i=NodeIt(*this); return i;
+//     }
+//     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
+//       i=OutEdgeIt(*this, p); return i;
+//     }
+//     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
+//       i=InEdgeIt(*this, p); return i;
+//     }
+//     EdgeIt& first(EdgeIt& i) const { 
+//       i=EdgeIt(*this); return i;
+//     }
 
-    Node tail(const Edge& e) const { 
-      return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
-    Node head(const Edge& e) const { 
-      return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
+    void next(Node& i) const { graph->next(i); }
+    void next(Edge& i) const { graph->next(i); }
+    void nextIn(Edge& i) const { graph->nextIn(i); }
+    void nextOut(Edge& i) const { graph->nextOut(i); }
+
+    Node tail(const Edge& e) const { return graph->tail(e); }
+    Node head(const Edge& e) const { return graph->head(e); }
+//     Node tail(const Edge& e) const { 
+//       return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
+//     Node head(const Edge& e) const { 
+//       return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
 
     int nodeNum() const { return graph->nodeNum(); }
     int edgeNum() const { return graph->edgeNum(); }
@@ -227,14 +177,38 @@
     
     Edge opposite(const Edge& e) const { return Edge(graph->opposite(e)); }
 
+    template <typename _Value>
+    class NodeMap : public _Graph::template NodeMap<_Value> {
+    public:
+      typedef typename _Graph::template NodeMap<_Value> Parent;
+      NodeMap(const GraphWrapperBase<_Graph>& gw) : Parent(*gw.graph) { }
+      NodeMap(const GraphWrapperBase<_Graph>& gw, const _Value& value)
+      : Parent(*gw.graph, value) { }
+    };
 
-    IMPORT_NODE_MAP(Graph, *(gw.graph), GraphWrapper, gw);    
-    IMPORT_EDGE_MAP(Graph, *(gw.graph), GraphWrapper, gw);
-    
+    template <typename _Value>
+    class EdgeMap : public _Graph::template EdgeMap<_Value> {
+    public:
+      typedef typename _Graph::template EdgeMap<_Value> Parent;
+      EdgeMap(const GraphWrapperBase<_Graph>& gw) : Parent(*gw.graph) { }
+      EdgeMap(const GraphWrapperBase<_Graph>& gw, const _Value& value)
+      : Parent(*gw.graph, value) { }
+    };
 
   };
 
+  template <typename _Graph>
+  class GraphWrapper :
+    public IterableGraphExtender<GraphWrapperBase<_Graph> > { 
+  public:
+    typedef _Graph Graph;
+    typedef IterableGraphExtender<GraphWrapperBase<_Graph> > Parent;
+  protected:
+    GraphWrapper() : Parent() { }
 
+  public:
+    GraphWrapper(Graph& _graph) { setGraph(_graph); }
+  };
 
   /// A graph wrapper which reverses the orientation of the edges.
 
@@ -1103,16 +1077,16 @@
       }
     };
 
-    using GraphWrapper<Graph>::first;
-    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
-      i=OutEdgeIt(*this, p); return i;
-    }
-    InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
-      i=InEdgeIt(*this, p); return i;
-    }
-    EdgeIt& first(EdgeIt& i) const { 
-      i=EdgeIt(*this); return i;
-    }
+//     using GraphWrapper<Graph>::first;
+//     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
+//       i=OutEdgeIt(*this, p); return i;
+//     }
+//     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
+//       i=InEdgeIt(*this, p); return i;
+//     }
+//     EdgeIt& first(EdgeIt& i) const { 
+//       i=EdgeIt(*this); return i;
+//     }
   
 
     Node tail(Edge e) const { 
@@ -1434,10 +1408,10 @@
       }
     };
 
-    using GraphWrapper<Graph>::first;
-    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
-      i=OutEdgeIt(*this, p); return i;
-    }
+//     using GraphWrapper<Graph>::first;
+//     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
+//       i=OutEdgeIt(*this, p); return i;
+//     }
     void erase(const Edge& e) const {
       Node n=tail(e);
       typename Graph::OutEdgeIt f(*Parent::graph, n);