using Parent::first;

     //    using Parent::first;

     using Parent::next;

     //    using Parent::next;

   template <typename _Graph>

   template<typename Graph>

   class UndirGraphWrapperBase : 

   class UndirGraphWrapper : public GraphWrapper<Graph> {

     public UndirGraphExtender<GraphWrapperBase<_Graph> > {

   public:

   public:

     typedef GraphWrapper<Graph> Parent; 

     typedef _Graph Graph;

   protected:

     typedef UndirGraphExtender<GraphWrapperBase<_Graph> > Parent;

     UndirGraphWrapper() : GraphWrapper<Graph>() { }

   protected:

     UndirGraphWrapperBase() : Parent() { }

   public:

     typedef typename Parent::UndirEdge UndirEdge;

     typedef typename Parent::Edge Edge;

   public:

     /// \bug Why cant an edge say that it is forward or not??? 

     typedef typename GraphWrapper<Graph>::Node Node;

     /// By this, a pointer to the graph have to be stored

     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;

     /// The implementation

     typedef typename GraphWrapper<Graph>::Edge Edge;

     template <typename T>

     typedef typename GraphWrapper<Graph>::EdgeIt EdgeIt;

     class EdgeMap {

     protected:

     UndirGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }  

       const UndirGraphWrapperBase<_Graph>* g;

       template <typename TT> friend class EdgeMap;

     class OutEdgeIt {

       typename _Graph::template EdgeMap<T> forward_map, backward_map; 

       friend class UndirGraphWrapper<Graph>;

       bool out_or_in; //true iff out

       typename Graph::OutEdgeIt out;

       typename Graph::InEdgeIt in;

       OutEdgeIt() { }

       typedef T Value;

       OutEdgeIt(const Invalid& i) : Edge(i) { }

       typedef Edge Key;

       OutEdgeIt(const UndirGraphWrapper<Graph>& _G, const Node& _n) {

 	out_or_in=true; _G.graph->first(out, _n);

       EdgeMap(const UndirGraphWrapperBase<_Graph>& _g) : g(&_g), 

 	if (!(_G.graph->valid(out))) { out_or_in=false; _G.graph->first(in, _n);	}

 	forward_map(*(g->graph)), backward_map(*(g->graph)) { }

       } 

       operator Edge() const { 

       EdgeMap(const UndirGraphWrapperBase<_Graph>& _g, T a) : g(&_g), 

 	if (out_or_in) return Edge(out); else return Edge(in); 

 	forward_map(*(g->graph), a), backward_map(*(g->graph), a) { }

       void set(Edge e, T a) { 

 	if (g->forward(e)) 

 	  forward_map.set(e, a); 

 	else 

 	  backward_map.set(e, a); 

       }

       T operator[](Edge e) const { 

 	if (g->forward(e)) 

 	  return forward_map[e]; 

 	else 

 	  return backward_map[e]; 

     typedef OutEdgeIt InEdgeIt; 

     template <typename T>

     class UndirEdgeMap {

     using GraphWrapper<Graph>::first;

       template <typename TT> friend class UndirEdgeMap;

     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 

       typename _Graph::template EdgeMap<T> map; 

       i=OutEdgeIt(*this, p); return i;

     public:

     }

       typedef T Value;

       typedef UndirEdge Key;

     using GraphWrapper<Graph>::next;

       UndirEdgeMap(const UndirGraphWrapperBase<_Graph>& g) : 

     OutEdgeIt& next(OutEdgeIt& e) const {

 	map(*(g.graph)) { }

       if (e.out_or_in) {

 	typename Graph::Node n=this->graph->source(e.out);

       UndirEdgeMap(const UndirGraphWrapperBase<_Graph>& g, T a) : 

 	this->graph->next(e.out);

 	map(*(g.graph), a) { }

 	if (!this->graph->valid(e.out)) { 

 	  e.out_or_in=false; this->graph->first(e.in, n); }

       void set(UndirEdge e, T a) { 

       } else {

 	map.set(e, a); 

 	this->graph->next(e.in);

       }

       }

       return e;

       T operator[](UndirEdge e) const { 

     }

 	return map[e]; 

       }

     Node aNode(const OutEdgeIt& e) const { 

     };

       if (e.out_or_in) return this->graph->source(e); else 

 	return this->graph->target(e); }

   };

     Node bNode(const OutEdgeIt& e) const { 

       if (e.out_or_in) return this->graph->target(e); else 

   /// \brief An undirected graph is made from a directed graph by a wrapper

 	return this->graph->source(e); }

   ///

   /// Undocumented, untested!!!

     //    KEEP_MAPS(Parent, UndirGraphWrapper);

   /// If somebody knows nice demo application, let's polulate it.

   /// 

   };

   /// \author Marton Makai

   template<typename _Graph>

 //   /// \brief An undirected graph template.

   class UndirGraphWrapper : 

 //   ///

     public IterableUndirGraphExtender<

 //   ///\warning Graph wrappers are in even more experimental state than the other

     UndirGraphWrapperBase<_Graph> > {

 //   ///parts of the lib. Use them at your own risk.

   public:

 //   ///

     typedef _Graph Graph;

 //   /// An undirected graph template.

     typedef IterableUndirGraphExtender<

 //   /// This class works as an undirected graph and a directed graph of 

       UndirGraphWrapperBase<_Graph> > Parent;

 //   /// class \c Graph is used for the physical storage.

   protected:

 //   /// \ingroup graphs

     UndirGraphWrapper() { }

   template<typename Graph>

   public:

   class UndirGraph : public UndirGraphWrapper<Graph> {

     UndirGraphWrapper(_Graph& _graph) { 

     typedef UndirGraphWrapper<Graph> Parent;

       setGraph(_graph);

   protected:

     }

     Graph gr;

   public:

     UndirGraph() : UndirGraphWrapper<Graph>() { 

       Parent::setGraph(gr); 

     }

     //    KEEP_MAPS(Parent, UndirGraph);