/// \addtogroup gwrappers

   /*! \addtogroup gwrappers

   /// The main parts of LEMON are the different graph structures, 

     The main parts of LEMON are the different graph structures, 

   /// generic graph algorithms, graph concepts which couple these, and 

     generic graph algorithms, graph concepts which couple these, and 

   /// graph wrappers. While the previous ones are more or less clear, the 

     graph wrappers. While the previous ones are more or less clear, the 

   /// latter notion needs further explanation.

     latter notion needs further explanation.

   /// Graph wrappers are graph classes which serve for considering graph 

     Graph wrappers are graph classes which serve for considering graph 

   /// structures in different ways. A short example makes the notion much 

     structures in different ways. A short example makes the notion much 

   /// clearer. 

     clearer. 

   /// Suppose that we have an instance \c g of a directed graph

     Suppose that we have an instance \c g of a directed graph

   /// type say \c ListGraph and an algorithm 

     type say \c ListGraph and an algorithm 

   /// \code template<typename Graph> int algorithm(const Graph&); \endcode 

     \code template<typename Graph> int algorithm(const Graph&); \endcode 

   /// is needed to run on the reversely oriented graph. 

     is needed to run on the reversely oriented graph. 

   /// It may be expensive (in time or in memory usage) to copy 

     It may be expensive (in time or in memory usage) to copy 

   /// \c g with the reverse orientation. 

     \c g with the reverse orientation. 

   /// Thus, a wrapper class

     Thus, a wrapper class

   /// \code template<typename Graph> class RevGraphWrapper; \endcode is used. 

     \code template<typename Graph> class RevGraphWrapper; \endcode is used. 

   /// The code looks as follows

     The code looks as follows

   /// \code

     \code

   /// ListGraph g;

     ListGraph g;

   /// RevGraphWrapper<ListGraph> rgw(g);

     RevGraphWrapper<ListGraph> rgw(g);

   /// int result=algorithm(rgw);

     int result=algorithm(rgw);

   /// \endcode

     \endcode

   /// After running the algorithm, the original graph \c g 

     After running the algorithm, the original graph \c g 

   /// remains untouched. Thus the graph wrapper used above is to consider the 

     remains untouched. Thus the graph wrapper used above is to consider the 

   /// original graph with reverse orientation. 

     original graph with reverse orientation. 

   /// This techniques gives rise to an elegant code, and 

     This techniques gives rise to an elegant code, and 

   /// based on stable graph wrappers, complex algorithms can be 

     based on stable graph wrappers, complex algorithms can be 

   /// implemented easily. 

     implemented easily. 

   /// In flow, circulation and bipartite matching problems, the residual 

     In flow, circulation and bipartite matching problems, the residual 

   /// graph is of particular importance. Combining a wrapper implementing 

     graph is of particular importance. Combining a wrapper implementing 

   /// this, shortest path algorithms and minimum mean cycle algorithms, 

     this, shortest path algorithms and minimum mean cycle algorithms, 

   /// a range of weighted and cardinality optimization algorithms can be 

     a range of weighted and cardinality optimization algorithms can be 

   /// obtained. For lack of space, for other examples, 

     obtained. For lack of space, for other examples, 

   /// the interested user is referred to the detailed documentation of graph 

     the interested user is referred to the detailed documentation of graph 

   /// wrappers. 

     wrappers. 

   /// The behavior of graph wrappers can be very different. Some of them keep 

     The behavior of graph wrappers can be very different. Some of them keep 

   /// capabilities of the original graph while in other cases this would be 

     capabilities of the original graph while in other cases this would be 

   /// meaningless. This means that the concepts that they are a model of depend 

     meaningless. This means that the concepts that they are a model of depend 

   /// on the graph wrapper, and the wrapped graph(s). 

     on the graph wrapper, and the wrapped graph(s). 

   /// If an edge of \c rgw is deleted, this is carried out by 

     If an edge of \c rgw is deleted, this is carried out by 

   /// deleting the corresponding edge of \c g. But for a residual 

     deleting the corresponding edge of \c g. But for a residual 

   /// graph, this operation has no sense. 

     graph, this operation has no sense. 

   /// Let we stand one more example here to simplify your work. 

     Let we stand one more example here to simplify your work. 

   /// wrapper class

     wrapper class

   /// \code template<typename Graph> class RevGraphWrapper; \endcode 

     \code template<typename Graph> class RevGraphWrapper; \endcode 

   /// has constructor 

     has constructor 

   /// <tt> RevGraphWrapper(Graph& _g)</tt>. 

     <tt> RevGraphWrapper(Graph& _g)</tt>. 

   /// This means that in a situation, 

     This means that in a situation, 

   /// when a <tt> const ListGraph& </tt> reference to a graph is given, 

     when a <tt> const ListGraph& </tt> reference to a graph is given, 

   /// then it have to be instantiated with <tt>Graph=const ListGraph</tt>.

     then it have to be instantiated with <tt>Graph=const ListGraph</tt>.

   /// \code

     \code

   /// int algorithm1(const ListGraph& g) {

     int algorithm1(const ListGraph& g) {

   ///   RevGraphWrapper<const ListGraph> rgw(g);

     RevGraphWrapper<const ListGraph> rgw(g);

   ///   return algorithm2(rgw);

     return algorithm2(rgw);

   /// }

     }

   /// \endcode

     \endcode

   /// \addtogroup gwrappers

     \addtogroup gwrappers

   /// @{

     @{

   ///Base type for the Graph Wrappers

     Base type for the Graph Wrappers

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

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

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

     parts of the lib. Use them at you own risk.

   ///

   /// This is the base type for most of LEMON graph wrappers. 

     This is the base type for most of LEMON graph wrappers. 

   /// This class implements a trivial graph wrapper i.e. it only wraps the 

     This class implements a trivial graph wrapper i.e. it only wraps the 

   /// functions and types of the graph. The purpose of this class is to 

     functions and types of the graph. The purpose of this class is to 

   /// make easier implementing graph wrappers. E.g. if a wrapper is 

     make easier implementing graph wrappers. E.g. if a wrapper is 

   /// considered which differs from the wrapped graph only in some of its 

     considered which differs from the wrapped graph only in some of its 

   /// functions or types, then it can be derived from GraphWrapper, and only the 

     functions or types, then it can be derived from GraphWrapper, and only the 

   /// differences should be implemented.

     differences should be implemented.

   ///

   ///\author Marton Makai 

     \author Marton Makai 

   */