/// This adaptor gives a direction for each uedge in the undirected graph.

   /// This adaptor gives a direction for each uedge in the undirected

   /// The direction of the edges stored in the DirectionMap. This map is

   /// graph. The direction of the edges stored in the

   /// a bool map on the undirected edges. If the uedge is mapped to true

   /// DirectionMap. This map is a bool map on the undirected edges. If

   /// then the direction of the directed edge will be the same as the

   /// the uedge is mapped to true then the direction of the directed

   /// default direction of the uedge. The edges can be easily reverted

   /// edge will be the same as the default direction of the uedge. The

   /// by the reverseEdge member in the adaptor.  

   /// edges can be easily reverted by the \ref

   /// DirUGraphAdaptorBase::reverseEdge "reverseEdge()" member in the

   /// adaptor.

   ///

   /// It can be used to solve orientation problems on directed graphs.

   /// By example how can we orient an undirected graph to get the minimum

   /// number of strongly connected components. If we orient the edges with

   /// the dfs algorithm out from the source then we will get such an 

   /// orientation. 

   ///

   /// We use the \ref DfsVisitor "visitor" interface of the 

   /// \ref DfsVisit "dfs" algorithm:

   ///\code

   /// template <typename DirMap>

   /// class OrientVisitor : public DfsVisitor<UGraph> {

   /// public:

   ///

   ///   OrientVisitor(const UGraph& ugraph, DirMap& dirMap)

   ///     : _ugraph(ugraph), _dirMap(dirMap), _processed(ugraph, false) {}

   ///

   ///   void discover(const Edge& edge) {

   ///     _processed.set(edge, true);

   ///     _dirMap.set(edge, _ugraph.direction(edge));

   ///   }

   ///

   ///   void examine(const Edge& edge) {

   ///     if (_processed[edge]) return;

   ///     _processed.set(edge, true);

   ///     _dirMap.set(edge, _ugraph.direction(edge));

   ///   }  

   /// 

   /// private:

   ///   const UGraph& _ugraph;  

   ///   DirMap& _dirMap;

   ///   UGraph::UEdgeMap<bool> _processed;

   /// };

   ///\endcode

   ///

   /// And now we can use the orientation:

   ///\code

   /// UGraph::UEdgeMap<bool> dmap(ugraph);

   ///

   /// typedef OrientVisitor<UGraph::UEdgeMap<bool> > Visitor;

   /// Visitor visitor(ugraph, dmap);

   ///

   /// DfsVisit<UGraph, Visitor> dfs(ugraph, visitor);

   ///

   /// dfs.run();

   ///

   /// typedef DirUGraphAdaptor<UGraph> DGraph;

   /// DGraph dgraph(ugraph, dmap);

   ///

   /// LEMON_ASSERT(countStronglyConnectedComponents(dgraph) == 

   ///              countBiEdgeConnectedComponents(ugraph), "Wrong Orientation");

   ///\endcode

   ///

   /// The number of the bi-connected components is a lower bound for

   /// the number of the strongly connected components in the directed

   /// graph because if we contract the bi-connected components to

   /// nodes we will get a tree therefore we cannot orient edges in

   /// both direction between bi-connected components. In the other way

   /// the algorithm will orient one component to be strongly

   /// connected. The two relations proof that the assertion will

   /// be always true and the found solution is optimal.

   ///

   /// \sa DirUGraphAdaptorBase

   /// \sa dirUGraphAdaptor