// Graph adaptors

   //x\brief Base type for the Graph Adaptors

   //x\ingroup graph_adaptors

   /*!

   //x    

     \addtogroup graph_adaptors

   //xBase type for the Graph Adaptors

     @{

   //x    

    */

   //x\warning Graph adaptors are in even

   //xmore experimental state than the other

   /*! 

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

     Base type for the Graph Adaptors

   //x

   //xThis is the base type for most of LEMON graph adaptors. 

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

   //xThis class implements a trivial graph adaptor i.e. it only wraps the 

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

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

   //xmake easier implementing graph adaptors. E.g. if an adaptor is 

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

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

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

   //xfunctions or types, then it can be derived from GraphAdaptor,

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

   //xand only the 

     make easier implementing graph adaptors. E.g. if an adaptor is 

   //xdifferences should be implemented.

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

   //x

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

   //xauthor Marton Makai 

     differences should be implemented.

     \author Marton Makai 

   */

   /// A graph adaptor which reverses the orientation of the edges.

   ///\brief A graph adaptor which reverses the orientation of the edges.

   ///\ingroup graph_adaptors

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

   ///

   ///\warning Graph adaptors are in even more experimental 

   ///state than the other

   /// Let \f$G=(V, A)\f$ be a directed graph and 

   /// If \c g is defined as

   /// suppose that a graph instange \c g of type 

   /// \c ListGraph implements \f$G\f$.

   /// For each directed edge 

   /// then

   /// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by 

   /// reversing its orientation. 

   /// Then RevGraphAdaptor implements the graph structure with node-set 

   /// \f$V\f$ and edge-set 

   /// \f$\{\bar e : e\in A \}\f$, i.e. the graph obtained from \f$G\f$ be 

   /// reversing the orientation of its edges. The following code shows how 

   /// such an instance can be constructed.

   ///\author Marton Makai

   ///implements the graph obtained from \c g by 

   /// reversing the orientation of its edges.

     /// This function hides \c n in the graph, i.e. the iteration 

     //x\e

     /// jumps over it. This is done by simply setting the value of \c n  

     /// to be false in the corresponding node-map.

     //x This function hides \c n in the graph, i.e. the iteration 

     //x jumps over it. This is done by simply setting the value of \c n  

     //x to be false in the corresponding node-map.

     /// This function hides \c e in the graph, i.e. the iteration 

     //x\e

     /// jumps over it. This is done by simply setting the value of \c e  

     /// to be false in the corresponding edge-map.

     //x This function hides \c e in the graph, i.e. the iteration 

     //x jumps over it. This is done by simply setting the value of \c e  

     //x to be false in the corresponding edge-map.

     /// The value of \c n is set to be true in the node-map which stores 

     //x\e

     /// hide information. If \c n was hidden previuosly, then it is shown 

     /// again

     //x The value of \c n is set to be true in the node-map which stores 

     //x hide information. If \c n was hidden previuosly, then it is shown 

     //x again

     /// The value of \c e is set to be true in the edge-map which stores 

     //x\e

     /// hide information. If \c e was hidden previuosly, then it is shown 

     /// again

     //x The value of \c e is set to be true in the edge-map which stores 

     //x hide information. If \c e was hidden previuosly, then it is shown 

     //x again

     /// Returns true if \c n is hidden.

     //x Returns true if \c n is hidden.

     //x\e

     //x

     /// Returns true if \c n is hidden.

     //x Returns true if \c n is hidden.

     //x\e

     //x

     /// This function hides \c n in the graph, i.e. the iteration 

     //x\e

     /// jumps over it. This is done by simply setting the value of \c n  

     /// to be false in the corresponding node-map.

     //x This function hides \c n in the graph, i.e. the iteration 

     //x jumps over it. This is done by simply setting the value of \c n  

     //x to be false in the corresponding node-map.

     /// This function hides \c e in the graph, i.e. the iteration 

     //x\e

     /// jumps over it. This is done by simply setting the value of \c e  

     /// to be false in the corresponding edge-map.

     //x This function hides \c e in the graph, i.e. the iteration 

     //x jumps over it. This is done by simply setting the value of \c e  

     //x to be false in the corresponding edge-map.

     /// The value of \c n is set to be true in the node-map which stores 

     //x\e

     /// hide information. If \c n was hidden previuosly, then it is shown 

     /// again

     //x The value of \c n is set to be true in the node-map which stores 

     //x hide information. If \c n was hidden previuosly, then it is shown 

     //x again

     /// The value of \c e is set to be true in the edge-map which stores 

     //x\e

     /// hide information. If \c e was hidden previuosly, then it is shown 

     /// again

     //x The value of \c e is set to be true in the edge-map which stores 

     //x hide information. If \c e was hidden previuosly, then it is shown 

     //x again

     /// Returns true if \c n is hidden.

     //x Returns true if \c n is hidden.

     //x\e

     //x

     /// Returns true if \c n is hidden.

     //x Returns true if \c n is hidden.

     //x\e

     //x

   /*! \brief A graph adaptor for hiding nodes and edges from a graph.

   //x\brief A graph adaptor for hiding nodes and edges from a graph.

   //x\ingroup graph_adaptors

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

   //x

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

   //x\warning Graph adaptors are in even more experimental

   //xstate than the other

   SubGraphAdaptor shows the graph with filtered node-set and 

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

   edge-set. If the \c checked parameter is true then it filters the edgeset

   //x

   to do not get invalid edges without source or target.

   //xSubGraphAdaptor shows the graph with filtered node-set and 

   Let \f$G=(V, A)\f$ be a directed graph 

   //xedge-set. If the \c checked parameter is true then it filters the edgeset

   and suppose that the graph instance \c g of type ListGraph implements 

   //xto do not get invalid edges without source or target.

   \f$G\f$. 

   //xLet \f$G=(V, A)\f$ be a directed graph 

   Let moreover \f$b_V\f$ and 

   //xand suppose that the graph instance \c g of type ListGraph implements 

   \f$b_A\f$ be bool-valued functions resp. on the node-set and edge-set. 

   //x\f$G\f$. 

   SubGraphAdaptor<...>::NodeIt iterates 

   //x/Let moreover \f$b_V\f$ and 

   on the node-set \f$\{v\in V : b_V(v)=true\}\f$ and 

   //x\f$b_A\f$ be bool-valued functions resp. on the node-set and edge-set. 

   SubGraphAdaptor<...>::EdgeIt iterates 

   //xSubGraphAdaptor<...>::NodeIt iterates 

   on the edge-set \f$\{e\in A : b_A(e)=true\}\f$. Similarly, 

   //xon the node-set \f$\{v\in V : b_V(v)=true\}\f$ and 

   SubGraphAdaptor<...>::OutEdgeIt and SubGraphAdaptor<...>::InEdgeIt iterates 

   //xSubGraphAdaptor<...>::EdgeIt iterates 

   only on edges leaving and entering a specific node which have true value.

   //xon the edge-set \f$\{e\in A : b_A(e)=true\}\f$. Similarly, 

   //xSubGraphAdaptor<...>::OutEdgeIt and

   If the \c checked template parameter is false then we have to note that 

   //xSubGraphAdaptor<...>::InEdgeIt iterates 

   the node-iterator cares only the filter on the node-set, and the 

   //xonly on edges leaving and entering a specific node which have true value.

   edge-iterator cares only the filter on the edge-set. This way the edge-map

   //x

   should filter all edges which's source or target is filtered by the 

   //xIf the \c checked template parameter is false then we have to note that 

   node-filter.

   //xthe node-iterator cares only the filter on the node-set, and the 

   \code

   //xedge-iterator cares only the filter on the edge-set.

   typedef ListGraph Graph;

   //xThis way the edge-map

   Graph g;

   //xshould filter all edges which's source or target is filtered by the 

   typedef Graph::Node Node;

   //xnode-filter.

   typedef Graph::Edge Edge;

   //x\code

   Node u=g.addNode(); //node of id 0

   //xtypedef ListGraph Graph;

   Node v=g.addNode(); //node of id 1

   //xGraph g;

   Node e=g.addEdge(u, v); //edge of id 0

   //xtypedef Graph::Node Node;

   Node f=g.addEdge(v, u); //edge of id 1

   //xtypedef Graph::Edge Edge;

   Graph::NodeMap<bool> nm(g, true);

   //xNode u=g.addNode(); //node of id 0

   nm.set(u, false);

   //xNode v=g.addNode(); //node of id 1

   Graph::EdgeMap<bool> em(g, true);

   //xNode e=g.addEdge(u, v); //edge of id 0

   em.set(e, false);

   //xNode f=g.addEdge(v, u); //edge of id 1

   typedef SubGraphAdaptor<Graph, Graph::NodeMap<bool>, Graph::EdgeMap<bool> > SubGW;

   //xGraph::NodeMap<bool> nm(g, true);

   SubGW gw(g, nm, em);

   //xnm.set(u, false);

   for (SubGW::NodeIt n(gw); n!=INVALID; ++n) std::cout << g.id(n) << std::endl;

   //xGraph::EdgeMap<bool> em(g, true);

   std::cout << ":-)" << std::endl;

   //xem.set(e, false);

   for (SubGW::EdgeIt e(gw); e!=INVALID; ++e) std::cout << g.id(e) << std::endl;

   //xtypedef SubGraphAdaptor<Graph, Graph::NodeMap<bool>, Graph::EdgeMap<bool> > SubGW;

   \endcode

   //xSubGW gw(g, nm, em);

   The output of the above code is the following.

   //xfor (SubGW::NodeIt n(gw); n!=INVALID; ++n) std::cout << g.id(n) << std::endl;

   \code

   //xstd::cout << ":-)" << std::endl;

   1

   //xfor (SubGW::EdgeIt e(gw); e!=INVALID; ++e) std::cout << g.id(e) << std::endl;

   :-)

   //x\endcode

   1

   //xThe output of the above code is the following.

   \endcode

   //x\code

   Note that \c n is of type \c SubGW::NodeIt, but it can be converted to

   //x1

   \c Graph::Node that is why \c g.id(n) can be applied.

   //x:-)

   //x1

   For other examples see also the documentation of NodeSubGraphAdaptor and 

   //x\endcode

   EdgeSubGraphAdaptor.

   //xNote that \c n is of type \c SubGW::NodeIt, but it can be converted to

   //x\c Graph::Node that is why \c g.id(n) can be applied.

   \author Marton Makai

   //x

   */

   //xFor other examples see also the documentation of NodeSubGraphAdaptor and 

   //xEdgeSubGraphAdaptor.

   //x

   //x\author Marton Makai

   /*! \brief An adaptor for hiding nodes from a graph.

   //x\brief An adaptor for hiding nodes from a graph.

   //x\ingroup graph_adaptors

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

   //x

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

   //x\warning Graph adaptors are in even more experimental state

   //xthan the other

   An adaptor for hiding nodes from a graph.

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

   This adaptor specializes SubGraphAdaptor in the way that only the node-set 

   //x

   can be filtered. In usual case the checked parameter is true, we get the

   //xAn adaptor for hiding nodes from a graph.

   induced subgraph. But if the checked parameter is false then we can only

   //xThis adaptor specializes SubGraphAdaptor in the way that only

   filter only isolated nodes.

   //xthe node-set 

   \author Marton Makai

   //xcan be filtered. In usual case the checked parameter is true, we get the

   */

   //xinduced subgraph. But if the checked parameter is false then we can only

   //xfilter only isolated nodes.

   //x\author Marton Makai

   /*! \brief An adaptor for hiding edges from a graph.

   //x\brief An adaptor for hiding edges from a graph.

   //x

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

   //x\warning Graph adaptors are in even more experimental state

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

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

   //x

   An adaptor for hiding edges from a graph.

   //xAn adaptor for hiding edges from a graph.

   This adaptor specializes SubGraphAdaptor in the way that only the edge-set 

   //xThis adaptor specializes SubGraphAdaptor in the way that

   can be filtered. The usefulness of this adaptor is demonstrated in the 

   //xonly the edge-set 

   problem of searching a maximum number of edge-disjoint shortest paths 

   //xcan be filtered. The usefulness of this adaptor is demonstrated in the 

   between 

   //xproblem of searching a maximum number of edge-disjoint shortest paths 

   two nodes \c s and \c t. Shortest here means being shortest w.r.t. 

   //xbetween 

   non-negative edge-lengths. Note that 

   //xtwo nodes \c s and \c t. Shortest here means being shortest w.r.t. 

   the comprehension of the presented solution 

   //xnon-negative edge-lengths. Note that 

   need's some elementary knowledge from combinatorial optimization. 

   //xthe comprehension of the presented solution 

   //xneed's some elementary knowledge from combinatorial optimization. 

   If a single shortest path is to be 

   //x

   searched between \c s and \c t, then this can be done easily by 

   //xIf a single shortest path is to be 

   applying the Dijkstra algorithm. What happens, if a maximum number of 

   //xsearched between \c s and \c t, then this can be done easily by 

   edge-disjoint shortest paths is to be computed. It can be proved that an 

   //xapplying the Dijkstra algorithm. What happens, if a maximum number of 

   edge can be in a shortest path if and only if it is tight with respect to 

   //xedge-disjoint shortest paths is to be computed. It can be proved that an 

   the potential function computed by Dijkstra. Moreover, any path containing 

   //xedge can be in a shortest path if and only

   only such edges is a shortest one. Thus we have to compute a maximum number 

   //xif it is tight with respect to 

   of edge-disjoint paths between \c s and \c t in the graph which has edge-set 

   //xthe potential function computed by Dijkstra.

   all the tight edges. The computation will be demonstrated on the following 

   //xMoreover, any path containing 

   graph, which is read from the dimacs file \c sub_graph_adaptor_demo.dim. 

   //xonly such edges is a shortest one.

   The full source code is available in \ref sub_graph_adaptor_demo.cc. 

   //xThus we have to compute a maximum number 

   If you are interested in more demo programs, you can use 

   //xof edge-disjoint paths between \c s and \c t in

   \ref dim_to_dot.cc to generate .dot files from dimacs files. 

   //xthe graph which has edge-set 

   The .dot file of the following figure was generated by  

   //xall the tight edges. The computation will be demonstrated

   the demo program \ref dim_to_dot.cc.

   //xon the following 

   //xgraph, which is read from the dimacs file \c sub_graph_adaptor_demo.dim. 

   \dot

   //xThe full source code is available in \ref sub_graph_adaptor_demo.cc. 

   digraph lemon_dot_example {

   //xIf you are interested in more demo programs, you can use 

   node [ shape=ellipse, fontname=Helvetica, fontsize=10 ];

   //x\ref dim_to_dot.cc to generate .dot files from dimacs files. 

   n0 [ label="0 (s)" ];

   //xThe .dot file of the following figure was generated by  

   n1 [ label="1" ];

   //xthe demo program \ref dim_to_dot.cc.

   n2 [ label="2" ];

   //x

   n3 [ label="3" ];

   //x\dot

   n4 [ label="4" ];

   //xdigraph lemon_dot_example {

   n5 [ label="5" ];

   //xnode [ shape=ellipse, fontname=Helvetica, fontsize=10 ];

   n6 [ label="6 (t)" ];

   //xn0 [ label="0 (s)" ];

   edge [ shape=ellipse, fontname=Helvetica, fontsize=10 ];

   //xn1 [ label="1" ];

   n5 ->  n6 [ label="9, length:4" ];

   //xn2 [ label="2" ];

   n4 ->  n6 [ label="8, length:2" ];

   //xn3 [ label="3" ];

   n3 ->  n5 [ label="7, length:1" ];

   //xn4 [ label="4" ];

   n2 ->  n5 [ label="6, length:3" ];

   //xn5 [ label="5" ];

   n2 ->  n6 [ label="5, length:5" ];

   //xn6 [ label="6 (t)" ];

   n2 ->  n4 [ label="4, length:2" ];

   //xedge [ shape=ellipse, fontname=Helvetica, fontsize=10 ];

   n1 ->  n4 [ label="3, length:3" ];

   //xn5 ->  n6 [ label="9, length:4" ];

   n0 ->  n3 [ label="2, length:1" ];

   //xn4 ->  n6 [ label="8, length:2" ];

   n0 ->  n2 [ label="1, length:2" ];

   //xn3 ->  n5 [ label="7, length:1" ];

   n0 ->  n1 [ label="0, length:3" ];

   //xn2 ->  n5 [ label="6, length:3" ];

   }

   //xn2 ->  n6 [ label="5, length:5" ];

   \enddot

   //xn2 ->  n4 [ label="4, length:2" ];

   //xn1 ->  n4 [ label="3, length:3" ];

   \code

   //xn0 ->  n3 [ label="2, length:1" ];

   Graph g;

   //xn0 ->  n2 [ label="1, length:2" ];

   Node s, t;

   //xn0 ->  n1 [ label="0, length:3" ];

   LengthMap length(g);

   //x}

   //x\enddot

   readDimacs(std::cin, g, length, s, t);

   //x

   //x\code

   cout << "edges with lengths (of form id, source--length->target): " << endl;

   //xGraph g;

   for(EdgeIt e(g); e!=INVALID; ++e) 

   //xNode s, t;

     cout << g.id(e) << ", " << g.id(g.source(e)) << "--" 

   //xLengthMap length(g);

          << length[e] << "->" << g.id(g.target(e)) << endl;

   //x

   //xreadDimacs(std::cin, g, length, s, t);

   cout << "s: " << g.id(s) << " t: " << g.id(t) << endl;

   //x

   \endcode

   //xcout << "edges with lengths (of form id, source--length->target): " << endl;

   Next, the potential function is computed with Dijkstra.

   //xfor(EdgeIt e(g); e!=INVALID; ++e) 

   \code

   //x  cout << g.id(e) << ", " << g.id(g.source(e)) << "--" 

   typedef Dijkstra<Graph, LengthMap> Dijkstra;

   //x       << length[e] << "->" << g.id(g.target(e)) << endl;

   Dijkstra dijkstra(g, length);

   //x

   dijkstra.run(s);

   //xcout << "s: " << g.id(s) << " t: " << g.id(t) << endl;

   \endcode

   //x\endcode

   Next, we consrtruct a map which filters the edge-set to the tight edges.

   //xNext, the potential function is computed with Dijkstra.

   \code

   //x\code

   typedef TightEdgeFilterMap<Graph, const Dijkstra::DistMap, LengthMap> 

   //xtypedef Dijkstra<Graph, LengthMap> Dijkstra;

     TightEdgeFilter;

   //xDijkstra dijkstra(g, length);

   TightEdgeFilter tight_edge_filter(g, dijkstra.distMap(), length);

   //xdijkstra.run(s);

   //x\endcode

   typedef EdgeSubGraphAdaptor<Graph, TightEdgeFilter> SubGW;

   //xNext, we consrtruct a map which filters the edge-set to the tight edges.

   SubGW gw(g, tight_edge_filter);

   //x\code

   \endcode

   //xtypedef TightEdgeFilterMap<Graph, const Dijkstra::DistMap, LengthMap> 

   Then, the maximum nimber of edge-disjoint \c s-\c t paths are computed 

   //x  TightEdgeFilter;

   with a max flow algorithm Preflow.

   //xTightEdgeFilter tight_edge_filter(g, dijkstra.distMap(), length);

   \code

   //x

   ConstMap<Edge, int> const_1_map(1);

   //xtypedef EdgeSubGraphAdaptor<Graph, TightEdgeFilter> SubGW;

   Graph::EdgeMap<int> flow(g, 0);

   //xSubGW gw(g, tight_edge_filter);

   //x\endcode

   Preflow<SubGW, int, ConstMap<Edge, int>, Graph::EdgeMap<int> > 

   //xThen, the maximum nimber of edge-disjoint \c s-\c t paths are computed 

     preflow(gw, s, t, const_1_map, flow);

   //xwith a max flow algorithm Preflow.

   preflow.run();

   //x\code

   \endcode

   //xConstMap<Edge, int> const_1_map(1);

   Last, the output is:

   //xGraph::EdgeMap<int> flow(g, 0);

   \code  

   //x

   cout << "maximum number of edge-disjoint shortest path: " 

   //xPreflow<SubGW, int, ConstMap<Edge, int>, Graph::EdgeMap<int> > 

        << preflow.flowValue() << endl;

   //x  preflow(gw, s, t, const_1_map, flow);

   cout << "edges of the maximum number of edge-disjoint shortest s-t paths: " 

   //xpreflow.run();

        << endl;

   //x\endcode

   for(EdgeIt e(g); e!=INVALID; ++e) 

   //xLast, the output is:

     if (flow[e])

   //x\code  

       cout << " " << g.id(g.source(e)) << "--" 

   //xcout << "maximum number of edge-disjoint shortest path: " 

 	   << length[e] << "->" << g.id(g.target(e)) << endl;

   //x     << preflow.flowValue() << endl;

   \endcode

   //xcout << "edges of the maximum number of edge-disjoint shortest s-t paths: " 

   The program has the following (expected :-)) output:

   //x     << endl;

   \code

   //xfor(EdgeIt e(g); e!=INVALID; ++e) 

   edges with lengths (of form id, source--length->target):

   //x  if (flow[e])

    9, 5--4->6

   //x    cout << " " << g.id(g.source(e)) << "--"

    8, 4--2->6

   //x         << length[e] << "->" << g.id(g.target(e)) << endl;

    7, 3--1->5

   //x\endcode

    6, 2--3->5

   //xThe program has the following (expected :-)) output:

    5, 2--5->6

   //x\code

    4, 2--2->4

   //xedges with lengths (of form id, source--length->target):

    3, 1--3->4

   //x 9, 5--4->6

    2, 0--1->3

   //x 8, 4--2->6

    1, 0--2->2

   //x 7, 3--1->5

    0, 0--3->1

   //x 6, 2--3->5

   s: 0 t: 6

   //x 5, 2--5->6

   maximum number of edge-disjoint shortest path: 2

   //x 4, 2--2->4

   edges of the maximum number of edge-disjoint shortest s-t paths:

   //x 3, 1--3->4

    9, 5--4->6

   //x 2, 0--1->3

    8, 4--2->6

   //x 1, 0--2->2

    7, 3--1->5

   //x 0, 0--3->1

    4, 2--2->4

   //xs: 0 t: 6

    2, 0--1->3

   //xmaximum number of edge-disjoint shortest path: 2

    1, 0--2->2

   //xedges of the maximum number of edge-disjoint shortest s-t paths:

   \endcode

   //x 9, 5--4->6

   //x 8, 4--2->6

   \author Marton Makai

   //x 7, 3--1->5

   */

   //x 4, 2--2->4

   //x 2, 0--1->3

   //x 1, 0--2->2

   //x\endcode

   //x

   //x\author Marton Makai

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

   //x\brief An undirected graph is made from a directed graph by an adaptor

   ///

   //x\ingroup graph_adaptors

   /// Undocumented, untested!!!

   //x

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

   //x Undocumented, untested!!!

   /// 

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

   /// \author Marton Makai

   //x 

   //x \author Marton Makai

     /// SubBidirGraphAdaptorBase<..., ..., ...>::Edge is inherited from 

     // SubBidirGraphAdaptorBase<..., ..., ...>::Edge is inherited from 

     /// _Graph::Edge. It contains an extra bool flag which is true 

     // _Graph::Edge. It contains an extra bool flag which is true 

     /// if and only if the 

     // if and only if the 

     /// edge is the backward version of the original edge.

     // edge is the backward version of the original edge.

       /// \todo =false is needed, or causes problems?

       // \todo =false is needed, or causes problems?

       /// If \c _backward is false, then we get an edge corresponding to the 

       // If \c _backward is false, then we get an edge corresponding to the 

       /// original one, otherwise its oppositely directed pair is obtained.

       // original one, otherwise its oppositely directed pair is obtained.

     /// Gives back the opposite edge.

     //x Gives back the opposite edge.

     //x\e

     //x

     /// \warning This is a linear time operation and works only if 

     //x\e

     /// \c Graph::EdgeIt is defined.

     /// \todo hmm

     //x \warning This is a linear time operation and works only if 

     //x \c Graph::EdgeIt is defined.

     //x \todo hmm

   ///\brief An adaptor for composing a subgraph of a 

   //x\brief An adaptor for composing a subgraph of a 

   /// bidirected graph made from a directed one. 

   //x bidirected graph made from a directed one. 

   ///

   //x\ingroup graph_adaptors

   /// An adaptor for composing a subgraph of a 

   //x

   /// bidirected graph made from a directed one. 

   //x An adaptor for composing a subgraph of a 

   ///

   //x bidirected graph made from a directed one. 

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

   //x

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

   //x\warning Graph adaptors are in even more experimental state

   ///

   //xthan the other

   /// Let \f$G=(V, A)\f$ be a directed graph and for each directed edge 

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

   /// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by

   //x

   /// reversing its orientation. We are given moreover two bool valued 

   //x Let \f$G=(V, A)\f$ be a directed graph and for each directed edge 

   /// maps on the edge-set, 

   //x \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by

   /// \f$forward\_filter\f$, and \f$backward\_filter\f$. 

   //x reversing its orientation. We are given moreover two bool valued 

   /// SubBidirGraphAdaptor implements the graph structure with node-set 

   //x maps on the edge-set, 

   /// \f$V\f$ and edge-set 

   //x \f$forward\_filter\f$, and \f$backward\_filter\f$. 

   /// \f$\{e : e\in A \mbox{ and } forward\_filter(e) \mbox{ is true}\}+\{\bar e : e\in A \mbox{ and } backward\_filter(e) \mbox{ is true}\}\f$. 

   //x SubBidirGraphAdaptor implements the graph structure with node-set 

   /// The purpose of writing + instead of union is because parallel 

   //x \f$V\f$ and edge-set 

   /// edges can arise. (Similarly, antiparallel edges also can arise).

   //x \f$\{e : e\in A \mbox{ and } forward\_filter(e) \mbox{ is true}\}+\{\bar e : e\in A \mbox{ and } backward\_filter(e) \mbox{ is true}\}\f$. 

   /// In other words, a subgraph of the bidirected graph obtained, which 

   //x The purpose of writing + instead of union is because parallel 

   /// is given by orienting the edges of the original graph in both directions.

   //x edges can arise. (Similarly, antiparallel edges also can arise).

   /// As the oppositely directed edges are logically different, 

   //x In other words, a subgraph of the bidirected graph obtained, which 

   /// the maps are able to attach different values for them. 

   //x is given by orienting the edges of the original graph in both directions.

   ///

   //x As the oppositely directed edges are logically different, 

   /// An example for such a construction is \c RevGraphAdaptor where the 

   //x the maps are able to attach different values for them. 

   /// forward_filter is everywhere false and the backward_filter is 

   //x

   /// everywhere true. We note that for sake of efficiency, 

   //x An example for such a construction is \c RevGraphAdaptor where the 

   /// \c RevGraphAdaptor is implemented in a different way. 

   //x forward_filter is everywhere false and the backward_filter is 

   /// But BidirGraphAdaptor is obtained from 

   //x everywhere true. We note that for sake of efficiency, 

   /// SubBidirGraphAdaptor by considering everywhere true 

   //x \c RevGraphAdaptor is implemented in a different way. 

   /// valued maps both for forward_filter and backward_filter. 

   //x But BidirGraphAdaptor is obtained from 

   ///

   //x SubBidirGraphAdaptor by considering everywhere true 

   /// The most important application of SubBidirGraphAdaptor 

   //x valued maps both for forward_filter and backward_filter. 

   /// is ResGraphAdaptor, which stands for the residual graph in directed 

   //x

   /// flow and circulation problems. 

   //x The most important application of SubBidirGraphAdaptor 

   /// As adaptors usually, the SubBidirGraphAdaptor implements the 

   //x is ResGraphAdaptor, which stands for the residual graph in directed 

   /// above mentioned graph structure without its physical storage, 

   //x flow and circulation problems. 

   /// that is the whole stuff is stored in constant memory. 

   //x As adaptors usually, the SubBidirGraphAdaptor implements the 

   //x above mentioned graph structure without its physical storage, 

   //x that is the whole stuff is stored in constant memory. 

   ///\brief An adaptor for composing bidirected graph from a directed one. 

   //x\brief An adaptor for composing bidirected graph from a directed one. 

   ///

   //x\ingroup graph_adaptors

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

   //x

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

   //x\warning Graph adaptors are in even more experimental state

   ///

   //xthan the other

   /// An adaptor for composing bidirected graph from a directed one. 

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

   /// A bidirected graph is composed over the directed one without physical 

   //x

   /// storage. As the oppositely directed edges are logically different ones 

   //x An adaptor for composing bidirected graph from a directed one. 

   /// the maps are able to attach different values for them.

   //x A bidirected graph is composed over the directed one without physical 

   //x storage. As the oppositely directed edges are logically different ones 

   //x the maps are able to attach different values for them.

   /*! \brief An adaptor for composing the residual graph for directed flow and circulation problems.

   //x\brief An adaptor for composing the residual

   //xgraph for directed flow and circulation problems.

   An adaptor for composing the residual graph for directed flow and circulation problems. 

   //x\ingroup graph_adaptors

   Let \f$G=(V, A)\f$ be a directed graph and let \f$F\f$ be a 

   //x

   number type. Let moreover 

   //xAn adaptor for composing the residual graph for

   \f$f,c:A\to F\f$, be functions on the edge-set. 

   //xdirected flow and circulation problems. 

   In the appications of ResGraphAdaptor, \f$f\f$ usually stands for a flow 

   //xLet \f$G=(V, A)\f$ be a directed graph and let \f$F\f$ be a 

   and \f$c\f$ for a capacity function.   

   //xnumber type. Let moreover 

   Suppose that a graph instange \c g of type 

   //x\f$f,c:A\to F\f$, be functions on the edge-set. 

   \c ListGraph implements \f$G\f$.

   //xIn the appications of ResGraphAdaptor, \f$f\f$ usually stands for a flow 

   \code

   //xand \f$c\f$ for a capacity function.   

   ListGraph g;

   //xSuppose that a graph instange \c g of type 

   \endcode

   //x\c ListGraph implements \f$G\f$ .

   Then RevGraphAdaptor implements the graph structure with node-set 

   //x\code

   \f$V\f$ and edge-set \f$A_{forward}\cup A_{backward}\f$, where 

   //x  ListGraph g;

   \f$A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\}\f$ and 

   //x\endcode

   \f$A_{backward}=\{vu : uv\in A, f(uv)>0\}\f$, 

   //xThen RevGraphAdaptor implements the graph structure with node-set 

   i.e. the so called residual graph. 

   //x\f$V\f$ and edge-set \f$A_{forward}\cup A_{backward}\f$, where 

   When we take the union \f$A_{forward}\cup A_{backward}\f$, 

   //x\f$A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\}\f$ and 

   multilicities are counted, i.e. if an edge is in both 

   //x\f$A_{backward}=\{vu : uv\in A, f(uv)>0\}\f$, 

   \f$A_{forward}\f$ and \f$A_{backward}\f$, then in the adaptor it 

   //xi.e. the so called residual graph. 

   appears twice. 

   //xWhen we take the union \f$A_{forward}\cup A_{backward}\f$, 

   The following code shows how 

   //xmultilicities are counted, i.e. if an edge is in both 

   such an instance can be constructed.

   //x\f$A_{forward}\f$ and \f$A_{backward}\f$, then in the adaptor it 

   \code

   //xappears twice. 

   typedef ListGraph Graph;

   //xThe following code shows how 

   Graph::EdgeMap<int> f(g);

   //xsuch an instance can be constructed.

   Graph::EdgeMap<int> c(g);

   //x\code

   ResGraphAdaptor<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > gw(g);

   //xtypedef ListGraph Graph;

   \endcode

   //xGraph::EdgeMap<int> f(g);

   \author Marton Makai

   //xGraph::EdgeMap<int> c(g);

   */

   //xResGraphAdaptor<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > gw(g);

   //x\endcode

   //x\author Marton Makai

   //x

     /// \brief Residual capacity map.

     //x \brief Residual capacity map.

     ///

     //x

     /// In generic residual graphs the residual capacity can be obtained 

     //x In generic residual graphs the residual capacity can be obtained 

     /// as a map. 

     //x as a map. 

   /// For blocking flows.

   //x\brief For blocking flows.

   //x\ingroup graph_adaptors

   ///\warning Graph adaptors are in even more

   //x

   ///experimental state than the other

   //x\warning Graph adaptors are in even more

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

   //xexperimental state than the other

   ///

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

   ///This graph adaptor is used for on-the-fly 

   //x

   ///Dinits blocking flow computations.

   //xThis graph adaptor is used for on-the-fly 

   ///For each node, an out-edge is stored which is used when the 

   //xDinits blocking flow computations.

   ///\code OutEdgeIt& first(OutEdgeIt&, const Node&)\endcode

   //xFor each node, an out-edge is stored which is used when the 

   ///is called. 

   //x\code

   ///

   //xOutEdgeIt& first(OutEdgeIt&, const Node&)

   ///\author Marton Makai

   //x\endcode

   ///

   //xis called. 

   //x

   //x\author Marton Makai

   //x

     /// \todo May we want VARIANT/union type

     //x \todo May we want VARIANT/union type