class RevGraphExt : public G

 {

 public:

   //  typedef G BaseGraph;

   typedef typename G::EdgeIt EdgeIt;

   typedef typename G::InEdgeIt OutEdgeIt;

   typedef typename G::OutEdgeIt InEdgeIt;

   typedef typename G::SymEdgeIt SymEdgeIt;

   typedef typename G::EachEdgeIt EachEdgeIt;

   typedef typename G::NodeIt NodeIt;

 //   template<typename I> I &getFirst(I &i); { return graph->getFirst(i); }

 //   template<typename I,typename P> I &getFirst(I &i,const P &p);

 //   { return graph->getFirst(i,p); }

 //   template<typename I> I next(const I i); { return graph->goNext(i); }

 //   template<typename I> I &goNext(I &i); { return graph->goNext(i); }

   NodeIt head(const EdgeIt &e);

   { return G::tail(e); }

   NodeIt tail(const EdgeIt &e);

   { return G::head(e); }

 //   template<typename I> NodeIt aNode(const I e);

 //   { return graph->aNode(e); }

 //   template<typename I> NodeIt bNode(const I e);

 //   { return graph->bNode(e); }

 //   template<typename I> bool valid(const I i);

 //   { return graph->valid(i); }

 //   template<typename I> void setInvalid(const I &i);

 //   { return graph->setInvalid(i); }

 //   NodeIt addNode(); { return graph->addNode(); }

   EdgeIt addEdge(const NodeIt from,const NodeIt to);

   { return G::addEdge(to,from); }

 //   template<I> void delete(I i); { graph->delete(i); }

 //   void clean();  { graph->clean(); }

 //   template<class T> class NodeMap : public typename G::NodeMap<T>;

 //   template<class T> class EdgeMap : public typename G::EdgeMap<T>;

 //   void SetG(G &g) {graph = &g;}

 //   RevGraphWrapper() {graph = NULL;}

 //   RevGraphWrapper(G &g) {graph = &g;}

 };

 template<typename G>