//x\brief Base type for the Graph Adaptors

   ///\brief Base type for the Graph Adaptors

   //x\ingroup graph_adaptors

   ///\ingroup graph_adaptors

   //x    

   ///

   //xBase type for the Graph Adaptors

   ///Base type for the Graph Adaptors

   //x    

   ///

   //x\warning Graph adaptors are in even

   ///\warning Graph adaptors are in even

   //xmore experimental state than the other

   ///more experimental state than the other

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

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

   //x

   ///

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

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

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

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

   //xfunctions 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 

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

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

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

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

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

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

   //xand only the 

   ///and only the 

   //xdifferences should be implemented.

   ///differences should be implemented.

   //x

   ///

   //xauthor Marton Makai 

   ///author Marton Makai 

     //x\e

     ///\e

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

     /// 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  

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

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

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

     //x\e

     ///\e

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

     /// 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  

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

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

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

     //x\e

     ///\e

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

     /// 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 

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

     //x again

     /// again

     //x\e

     ///\e

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

     /// 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 

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

     //x again

     /// again

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

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

     //x\e

     ///\e

     //x

     ///

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

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

     //x\e

     ///\e

     //x

     ///

     //x\e

     ///\e

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

     /// 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  

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

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

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

     //x\e

     ///\e

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

     /// 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  

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

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

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

     //x\e

     ///\e

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

     /// 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 

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

     //x again

     /// again

     //x\e

     ///\e

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

     /// 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 

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

     //x again

     /// again

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

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

     //x\e

     ///\e

     //x

     ///

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

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

     //x\e

     ///\e

     //x

     ///

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

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

   //x\ingroup graph_adaptors

   /// \ingroup graph_adaptors

   //x

   /// 

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

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

   //xstate than the other

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

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

   /// 

   //x

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

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

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

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

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

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

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

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

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

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

   /// implements  \f$  G  \f$ .

   //x\f$G\f$. 

   /// Let moreover  \f$  b_V  \f$  and  \f$  b_A  \f$  be bool-valued functions resp.

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

   /// on the node-set and edge-set.

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

   /// SubGraphAdaptor<...>::NodeIt iterates 

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

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

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

   /// SubGraphAdaptor<...>::EdgeIt iterates 

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

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

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

   /// SubGraphAdaptor<...>::OutEdgeIt and

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

   /// SubGraphAdaptor<...>::InEdgeIt iterates 

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

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

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

   /// 

   //x

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

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

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

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

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

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

   /// This way the edge-map

   //xThis way the edge-map

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

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

   /// node-filter.

   //xnode-filter.

   /// \code

   //x\code

   /// typedef ListGraph Graph;

   //xtypedef ListGraph Graph;

   /// Graph g;

   //xGraph g;

   /// typedef Graph::Node Node;

   //xtypedef Graph::Node Node;

   /// typedef Graph::Edge Edge;

   //xtypedef Graph::Edge Edge;

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

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

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

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

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

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

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

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

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

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

   /// nm.set(u, false);

   //xnm.set(u, false);

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

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

   /// em.set(e, false);

   //xem.set(e, false);

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

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

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

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

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

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

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

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

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

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

   /// \endcode

   //x\endcode

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

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

   /// \code

   //x\code

   /// 1

   //x1

   /// :-)

   //x:-)

   /// 1

   //x1

   /// \endcode

   //x\endcode

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

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

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

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

   /// 

   //x

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

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

   /// EdgeSubGraphAdaptor.

   //xEdgeSubGraphAdaptor.

   /// 

   //x

   /// \author Marton Makai

   //x\author Marton Makai

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

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

   //x\ingroup graph_adaptors

   ///\ingroup graph_adaptors

   //x

   ///

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

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

   //xthan the other

   ///than the other

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

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

   //x

   ///

   //xAn adaptor for hiding nodes from a graph.

   ///An adaptor for hiding nodes from a graph.

   //xThis adaptor specializes SubGraphAdaptor in the way that only

   ///This adaptor specializes SubGraphAdaptor in the way that only

   //xthe node-set 

   ///the node-set 

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

   ///can 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

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

   //xfilter only isolated nodes.

   ///filter only isolated nodes.

   //x\author Marton Makai

   ///\author Marton Makai

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

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

   //x

   ///

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

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

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

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

   //x

   ///

   //xAn adaptor for hiding edges from a graph.

   ///An adaptor for hiding edges from a graph.

   //xThis adaptor specializes SubGraphAdaptor in the way that

   ///This adaptor specializes SubGraphAdaptor in the way that

   //xonly the edge-set 

   ///only the edge-set 

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

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

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

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

   //xbetween 

   ///between 

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

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

   //xnon-negative edge-lengths. Note that 

   ///non-negative edge-lengths. Note that 

   //xthe comprehension of the presented solution 

   ///the comprehension of the presented solution 

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

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

   //x

   ///

   //xIf a single shortest path is to be 

   ///If a single shortest path is to be 

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

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

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

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

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

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

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

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

   //xif it is tight with respect to 

   ///if it is tight with respect to 

   //xthe potential function computed by Dijkstra.

   ///the potential function computed by Dijkstra.

   //xMoreover, any path containing 

   ///Moreover, any path containing 

   //xonly such edges is a shortest one.

   ///only such edges is a shortest one.

   //xThus we have to compute a maximum number 

   ///Thus we have to compute a maximum number 

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

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

   //xthe graph which has edge-set 

   ///the graph which has edge-set 

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

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

   //xon the following 

   ///on the following 

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

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

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

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

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

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

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

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

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

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

   //xthe demo program \ref dim_to_dot.cc.

   ///the demo program \ref dim_to_dot.cc.

   //x

   ///

   //x\dot

   ///\dot

   //xdigraph lemon_dot_example {

   ///digraph lemon_dot_example {

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

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

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

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

   //xn1 [ label="1" ];

   ///n1 [ label="1" ];

   //xn2 [ label="2" ];

   ///n2 [ label="2" ];

   //xn3 [ label="3" ];

   ///n3 [ label="3" ];

   //xn4 [ label="4" ];

   ///n4 [ label="4" ];

   //xn5 [ label="5" ];

   ///n5 [ label="5" ];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   //x}

   ///}

   //x\enddot

   ///\enddot

   //x

   ///

   //x\code

   ///\code

   //xGraph g;

   ///Graph g;

   //xNode s, t;

   ///Node s, t;

   //xLengthMap length(g);

   ///LengthMap length(g);

   //x

   ///

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

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

   //x

   ///

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

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

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

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

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

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

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

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

   //x

   ///

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

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

   //x\endcode

   ///\endcode

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

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

   //x\code

   ///\code

   //xtypedef Dijkstra<Graph, LengthMap> Dijkstra;

   ///typedef Dijkstra<Graph, LengthMap> Dijkstra;

   //xDijkstra dijkstra(g, length);

   ///Dijkstra dijkstra(g, length);

   //xdijkstra.run(s);

   ///dijkstra.run(s);

   //x\endcode

   ///\endcode

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

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

   //x\code

   ///\code

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

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

   //x  TightEdgeFilter;

   ///  TightEdgeFilter;

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

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

   //x

   ///

   //xtypedef EdgeSubGraphAdaptor<Graph, TightEdgeFilter> SubGW;

   ///typedef EdgeSubGraphAdaptor<Graph, TightEdgeFilter> SubGW;

   //xSubGW gw(g, tight_edge_filter);

   ///SubGW gw(g, tight_edge_filter);

   //x\endcode

   ///\endcode

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

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

   //xwith a max flow algorithm Preflow.

   ///with a max flow algorithm Preflow.

   //x\code

   ///\code

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

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

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

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

   //x

   ///

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

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

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

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

   //xpreflow.run();

   ///preflow.run();

   //x\endcode

   ///\endcode

   //xLast, the output is:

   ///Last, the output is:

   //x\code  

   ///\code  

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

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

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

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

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

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

   //x     << endl;

   ///     << endl;

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

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

   //x  if (flow[e])

   ///  if (flow[e])

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

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

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

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

   //x\endcode

   ///\endcode

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

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

   //x\code

   ///\code

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   //xs: 0 t: 6

   ///s: 0 t: 6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   //x\endcode

   ///\endcode

   //x

   ///

   //x\author Marton Makai

   ///\author Marton Makai

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

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

   //x\ingroup graph_adaptors

   ///\ingroup graph_adaptors

   //x

   ///

   //x Undocumented, untested!!!

   /// Undocumented, untested!!!

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

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

   //x 

   /// 

   //x \author Marton Makai

   /// \author Marton Makai

     //x Gives back the opposite edge.

     /// Gives back the opposite edge.

     //x\e

     ///\e

     //x

     ///

     //x\e

     ///\e

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

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

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

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

     //x \todo hmm

     /// \todo hmm

     //x\e

     ///\e

     //x \c SubBidirGraphAdaptorBase<..., ..., ...>::EdgeMap contains two 

     /// \c SubBidirGraphAdaptorBase<..., ..., ...>::EdgeMap contains two 

     //x _Graph::EdgeMap one for the forward edges and 

     /// _Graph::EdgeMap one for the forward edges and 

     //x one for the backward edges.

     /// one for the backward edges.

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

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

   //x bidirected graph made from a directed one. 

   /// bidirected graph made from a directed one. 

   //x\ingroup graph_adaptors

   ///\ingroup graph_adaptors

   //x

   ///

   //x An adaptor for composing a subgraph of a 

   /// An adaptor for composing a subgraph of a 

   //x bidirected graph made from a directed one. 

   /// bidirected graph made from a directed one. 

   //x

   ///

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

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

   //xthan the other

   ///than the other

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

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

   //x

   ///

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

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

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

   ///  \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 

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

   //x maps on the edge-set, 

   /// maps on the edge-set, 

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

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

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

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

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

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

   //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$. 

   ///  \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 The purpose of writing + instead of union is because parallel 

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

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

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

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

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

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

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

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

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

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

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

   //x

   ///

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

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

   //x forward_filter is everywhere false and the backward_filter is 

   /// forward_filter is everywhere false and the backward_filter is 

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

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

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

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

   //x But BidirGraphAdaptor is obtained from 

   /// But BidirGraphAdaptor is obtained from 

   //x SubBidirGraphAdaptor by considering everywhere true 

   /// SubBidirGraphAdaptor by considering everywhere true 

   //x valued maps both for forward_filter and backward_filter. 

   /// valued maps both for forward_filter and backward_filter. 

   //x

   ///

   //x The most important application of SubBidirGraphAdaptor 

   /// The most important application of SubBidirGraphAdaptor 

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

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

   //x flow and circulation problems. 

   /// flow and circulation problems. 

   //x As adaptors usually, the SubBidirGraphAdaptor implements the 

   /// As adaptors usually, the SubBidirGraphAdaptor implements the 

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

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

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

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

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

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

   //x\ingroup graph_adaptors

   ///\ingroup graph_adaptors

   //x

   ///

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

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

   //xthan the other

   ///than the other

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

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

   //x

   ///

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

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

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

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

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

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

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

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

   //x\brief An adaptor for composing the residual

   ///\brief An adaptor for composing the residual

   //xgraph for directed flow and circulation problems.

   ///graph for directed flow and circulation problems.

   //x\ingroup graph_adaptors

   ///\ingroup graph_adaptors

   //x

   ///

   //xAn adaptor for composing the residual graph for

   ///An adaptor for composing the residual graph for

   //xdirected flow and circulation problems. 

   ///directed flow and circulation problems. 

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

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

   //xnumber type. Let moreover 

   ///number type. Let moreover 

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

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

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

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

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

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

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

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

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

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

   //x\code

   ///\code

   //x  ListGraph g;

   ///  ListGraph g;

   //x\endcode

   ///\endcode

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   //xappears twice. 

   ///appears twice. 

   //xThe following code shows how 

   ///The following code shows how 

   //xsuch an instance can be constructed.

   ///such an instance can be constructed.

   //x\code

   ///\code

   //xtypedef ListGraph Graph;

   ///typedef ListGraph Graph;

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

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

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

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

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

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

   //x\endcode

   ///\endcode

   //x\author Marton Makai

   ///\author Marton Makai

   //x

   ///

     //x \brief Residual capacity map.

     /// \brief Residual capacity map.

     //x

     ///

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

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

     //x as a map. 

     /// as a map. 

   //x\brief For blocking flows.

   ///\brief For blocking flows.

   //x\ingroup graph_adaptors

   ///\ingroup graph_adaptors

   //x

   ///

   //x\warning Graph adaptors are in even more

   ///\warning Graph adaptors are in even more

   //xexperimental state than the other

   ///experimental state than the other

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

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

   //x

   ///

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

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

   //xDinits blocking flow computations.

   ///Dinits blocking flow computations.

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

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

   //x\code

   ///\code

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

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

   //x\endcode

   ///\endcode

   //xis called. 

   ///is called. 

   //x

   ///

   //x\author Marton Makai

   ///\author Marton Makai

   //x

   ///

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

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