Index: lemon/digraph_adaptor.h
===================================================================
--- lemon/digraph_adaptor.h	(revision 430)
+++ lemon/digraph_adaptor.h	(revision 431)
@@ -24,5 +24,5 @@
 ///\brief Several digraph adaptors.
 ///
-///This file contains several useful digraph adaptor functions.
+///This file contains several useful digraph adaptor classes.
 
 #include <lemon/core.h>
@@ -39,15 +39,4 @@
 namespace lemon {
 
-  ///\brief Base type for the Digraph Adaptors
-  ///
-  ///Base type for the Digraph Adaptors
-  ///
-  ///This is the base type for most of LEMON digraph adaptors. This
-  ///class implements a trivial digraph adaptor i.e. it only wraps the
-  ///functions and types of the digraph. The purpose of this class is
-  ///to make easier implementing digraph adaptors. E.g. if an adaptor
-  ///is considered which differs from the wrapped digraph only in some
-  ///of its functions or types, then it can be derived from
-  ///DigraphAdaptor, and only the differences should be implemented.
   template<typename _Digraph>
   class DigraphAdaptorBase {
@@ -167,33 +156,4 @@
   };
 
-  ///\ingroup graph_adaptors
-  ///
-  ///\brief Trivial Digraph Adaptor
-  /// 
-  /// This class is an adaptor which does not change the adapted
-  /// digraph.  It can be used only to test the digraph adaptors.
-  template <typename _Digraph>
-  class DigraphAdaptor :
-    public DigraphAdaptorExtender<DigraphAdaptorBase<_Digraph> > { 
-  public:
-    typedef _Digraph Digraph;
-    typedef DigraphAdaptorExtender<DigraphAdaptorBase<_Digraph> > Parent;
-  protected:
-    DigraphAdaptor() : Parent() { }
-
-  public:
-    explicit DigraphAdaptor(Digraph& digraph) { setDigraph(digraph); }
-  };
-
-  /// \brief Just gives back a digraph adaptor
-  ///
-  /// Just gives back a digraph adaptor which 
-  /// should be provide original digraph
-  template<typename Digraph>
-  DigraphAdaptor<const Digraph>
-  digraphAdaptor(const Digraph& digraph) {
-    return DigraphAdaptor<const Digraph>(digraph);
-  }
-
 
   template <typename _Digraph>
@@ -232,25 +192,23 @@
   /// If \c g is defined as
   ///\code
-  /// ListDigraph g;
+  /// ListDigraph dg;
   ///\endcode
   /// then
   ///\code
-  /// RevDigraphAdaptor<ListDigraph> ga(g);
+  /// RevDigraphAdaptor<ListDigraph> dga(dg);
   ///\endcode
-  /// implements the digraph obtained from \c g by 
+  /// implements the digraph obtained from \c dg by 
   /// reversing the orientation of its arcs.
   ///
-  /// A good example of using RevDigraphAdaptor is to decide that the
-  /// directed graph is wheter strongly connected or not. If from one
-  /// node each node is reachable and from each node is reachable this
-  /// node then and just then the digraph is strongly
-  /// connected. Instead of this condition we use a little bit
-  /// different. From one node each node ahould be reachable in the
-  /// digraph and in the reversed digraph. Now this condition can be
-  /// checked with the Dfs algorithm class and the RevDigraphAdaptor
-  /// algorithm class.
-  ///
-  /// And look at the code:
-  ///
+  /// A good example of using RevDigraphAdaptor is to decide whether
+  /// the directed graph is strongly connected or not. The digraph is
+  /// strongly connected iff each node is reachable from one node and
+  /// this node is reachable from the others. Instead of this
+  /// condition we use a slightly different, from one node each node
+  /// is reachable both in the digraph and the reversed digraph. Now
+  /// this condition can be checked with the Dfs algorithm and the
+  /// RevDigraphAdaptor class.
+  ///
+  /// The implementation:
   ///\code
   /// bool stronglyConnected(const Digraph& digraph) {
@@ -285,4 +243,8 @@
     RevDigraphAdaptor() { }
   public:
+
+    /// \brief Constructor
+    ///
+    /// Creates a reverse graph adaptor for the given digraph
     explicit RevDigraphAdaptor(Digraph& digraph) { 
       Parent::setDigraph(digraph); 
@@ -375,42 +337,11 @@
     }
 
-    ///\e
-
-    /// This function hides \c n in the digraph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c n  
-    /// to be false in the corresponding node-map.
     void hide(const Node& n) const { _node_filter->set(n, false); }
-
-    ///\e
-
-    /// This function hides \c a in the digraph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c a
-    /// to be false in the corresponding arc-map.
     void hide(const Arc& a) const { _arc_filter->set(a, false); }
 
-    ///\e
-
-    /// The value of \c n is set to be true in the node-map which stores 
-    /// hide information. If \c n was hidden previuosly, then it is shown 
-    /// again
-     void unHide(const Node& n) const { _node_filter->set(n, true); }
-
-    ///\e
-
-    /// The value of \c a is set to be true in the arc-map which stores 
-    /// hide information. If \c a was hidden previuosly, then it is shown 
-    /// again
+    void unHide(const Node& n) const { _node_filter->set(n, true); }
     void unHide(const Arc& a) const { _arc_filter->set(a, true); }
 
-    /// Returns true if \c n is hidden.
-    
-    ///\e
-    ///
     bool hidden(const Node& n) const { return !(*_node_filter)[n]; }
-
-    /// Returns true if \c a is hidden.
-    
-    ///\e
-    ///
     bool hidden(const Arc& a) const { return !(*_arc_filter)[a]; }
 
@@ -549,42 +480,11 @@
     }
 
-    ///\e
-
-    /// This function hides \c n in the digraph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c n  
-    /// to be false in the corresponding node-map.
     void hide(const Node& n) const { _node_filter->set(n, false); }
-
-    ///\e
-
-    /// This function hides \c e in the digraph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c e  
-    /// to be false in the corresponding arc-map.
     void hide(const Arc& e) const { _arc_filter->set(e, false); }
 
-    ///\e
-
-    /// The value of \c n is set to be true in the node-map which stores 
-    /// hide information. If \c n was hidden previuosly, then it is shown 
-    /// again
-     void unHide(const Node& n) const { _node_filter->set(n, true); }
-
-    ///\e
-
-    /// The value of \c e is set to be true in the arc-map which stores 
-    /// hide information. If \c e was hidden previuosly, then it is shown 
-    /// again
+    void unHide(const Node& n) const { _node_filter->set(n, true); }
     void unHide(const Arc& e) const { _arc_filter->set(e, true); }
 
-    /// Returns true if \c n is hidden.
-    
-    ///\e
-    ///
     bool hidden(const Node& n) const { return !(*_node_filter)[n]; }
-
-    /// Returns true if \c n is hidden.
-    
-    ///\e
-    ///
     bool hidden(const Arc& e) const { return !(*_arc_filter)[e]; }
 
@@ -662,24 +562,12 @@
   /// 
   /// SubDigraphAdaptor shows the digraph with filtered node-set and 
-  /// arc-set. If the \c checked parameter is true then it filters the arcset
-  /// to do not get invalid arcs without source or target.
-  /// Let \f$ G=(V, A) \f$ be a directed digraph
-  /// and suppose that the digraph instance \c g of type ListDigraph
-  /// implements \f$ G \f$.
-  /// Let moreover \f$ b_V \f$ and \f$ b_A \f$ be bool-valued functions resp.
-  /// on the node-set and arc-set.
-  /// SubDigraphAdaptor<...>::NodeIt iterates 
-  /// on the node-set \f$ \{v\in V : b_V(v)=true\} \f$ and 
-  /// SubDigraphAdaptor<...>::ArcIt iterates 
-  /// on the arc-set \f$ \{e\in A : b_A(e)=true\} \f$. Similarly, 
-  /// SubDigraphAdaptor<...>::OutArcIt and
-  /// SubDigraphAdaptor<...>::InArcIt iterates 
-  /// only on arcs leaving and entering a specific node which have true value.
+  /// arc-set. If the \c checked parameter is true then it filters the arc-set
+  /// respect to the source and target.
   /// 
-  /// If 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 arc-iterator cares only the filter on the
-  /// arc-set.  This way the arc-map should filter all arcs which's
-  /// source or target is filtered by the node-filter.
+  /// If the \c checked template parameter is false then the
+  /// node-iterator cares only the filter on the node-set, and the
+  /// arc-iterator cares only the filter on the arc-set.  Therefore
+  /// the arc-map have to filter all arcs which's source or target is
+  /// filtered by the node-filter.
   ///\code
   /// typedef ListDigraph Digraph;
@@ -694,10 +582,9 @@
   /// BoolArcMap am(g, true);
   /// am.set(a, false);
-  /// typedef SubDigraphAdaptor<Digraph, BoolNodeMap, BoolArcMap> SubGA;
-  /// SubGA ga(g, nm, am);
-  /// for (SubGA::NodeIt n(ga); n!=INVALID; ++n)
+  /// typedef SubDigraphAdaptor<Digraph, BoolNodeMap, BoolArcMap> SubDGA;
+  /// SubDGA ga(g, nm, am);
+  /// for (SubDGA::NodeIt n(ga); n!=INVALID; ++n)
   ///   std::cout << g.id(n) << std::endl;
-  /// std::cout << ":-)" << std::endl;
-  /// for (SubGA::ArcIt a(ga); a!=INVALID; ++a) 
+  /// for (SubDGA::ArcIt a(ga); a!=INVALID; ++a) 
   ///   std::cout << g.id(a) << std::endl;
   ///\endcode
@@ -705,8 +592,7 @@
   ///\code
   /// 1
-  /// :-)
   /// 1
   ///\endcode
-  /// Note that \c n is of type \c SubGA::NodeIt, but it can be converted to
+  /// Note that \c n is of type \c SubDGA::NodeIt, but it can be converted to
   /// \c Digraph::Node that is why \c g.id(n) can be applied.
   /// 
@@ -729,8 +615,15 @@
     Parent;
 
+    typedef typename Parent::Node Node;
+    typedef typename Parent::Arc Arc;
+
   protected:
     SubDigraphAdaptor() { }
   public:
 
+    /// \brief Constructor
+    ///
+    /// Creates a sub-digraph-adaptor for the given digraph with
+    /// given node and arc map filters.
     SubDigraphAdaptor(Digraph& digraph, NodeFilterMap& node_filter, 
 		      ArcFilterMap& arc_filter) { 
@@ -740,9 +633,49 @@
     }
 
+    /// \brief Hides the node of the graph
+    ///
+    /// This function hides \c n in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c n  
+    /// to be false in the corresponding node-map.
+    void hide(const Node& n) const { Parent::hide(n); }
+
+    /// \brief Hides the arc of the graph
+    ///
+    /// This function hides \c a in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c a
+    /// to be false in the corresponding arc-map.
+    void hide(const Arc& a) const { Parent::hide(a); }
+
+    /// \brief Unhides the node of the graph
+    ///
+    /// The value of \c n is set to be true in the node-map which stores 
+    /// hide information. If \c n was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Node& n) const { Parent::unHide(n); }
+
+    /// \brief Unhides the arc of the graph
+    ///
+    /// The value of \c a is set to be true in the arc-map which stores 
+    /// hide information. If \c a was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Arc& a) const { Parent::unHide(a); }
+
+    /// \brief Returns true if \c n is hidden.
+    ///
+    /// Returns true if \c n is hidden.
+    ///
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+
+    /// \brief Returns true if \c a is hidden.
+    ///
+    /// Returns true if \c a is hidden.
+    ///
+    bool hidden(const Arc& a) const { return Parent::hidden(a); }
+
   };
 
-  /// \brief Just gives back a sub digraph adaptor
-  ///
-  /// Just gives back a sub digraph adaptor
+  /// \brief Just gives back a sub-digraph-adaptor
+  ///
+  /// Just gives back a sub-digraph-adaptor
   template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
   SubDigraphAdaptor<const Digraph, NodeFilterMap, ArcFilterMap>
@@ -775,4 +708,5 @@
     return SubDigraphAdaptor<const Digraph, const NodeFilterMap, 
       const ArcFilterMap>(digraph, nfm, afm);
+
   }
 
@@ -803,4 +737,6 @@
     Parent;
 
+    typedef typename Parent::Node Node;
+
   protected:
     ConstMap<typename Digraph::Arc, bool> const_true_map;
@@ -812,4 +748,8 @@
   public:
 
+    /// \brief Constructor
+    ///
+    /// Creates a node-sub-digraph-adaptor for the given digraph with
+    /// given node map filter.
     NodeSubDigraphAdaptor(Digraph& _digraph, NodeFilterMap& node_filter) : 
       Parent(), const_true_map(true) { 
@@ -819,10 +759,30 @@
     }
 
+    /// \brief Hides the node of the graph
+    ///
+    /// This function hides \c n in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c n  
+    /// to be false in the corresponding node-map.
+    void hide(const Node& n) const { Parent::hide(n); }
+
+    /// \brief Unhides the node of the graph
+    ///
+    /// The value of \c n is set to be true in the node-map which stores 
+    /// hide information. If \c n was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Node& n) const { Parent::unHide(n); }
+
+    /// \brief Returns true if \c n is hidden.
+    ///
+    /// Returns true if \c n is hidden.
+    ///
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+
   };
 
 
-  /// \brief Just gives back a \c NodeSubDigraphAdaptor
-  ///
-  /// Just gives back a \c NodeSubDigraphAdaptor
+  /// \brief Just gives back a  node-sub-digraph adaptor
+  ///
+  /// Just gives back a node-sub-digraph adaptor
   template<typename Digraph, typename NodeFilterMap>
   NodeSubDigraphAdaptor<const Digraph, NodeFilterMap>
@@ -847,7 +807,8 @@
   ///in the problem of searching a maximum number of arc-disjoint
   ///shortest paths between two nodes \c s and \c t. Shortest here
-  ///means being shortest w.r.t.  non-negative arc-lengths. Note that
-  ///the comprehension of the presented solution need's some
-  ///elementary knowlarc from combinatorial optimization.
+  ///means being shortest with respect to non-negative
+  ///arc-lengths. Note that the comprehension of the presented
+  ///solution need's some elementary knowledge from combinatorial
+  ///optimization.
   ///
   ///If a single shortest path is to be searched between \c s and \c
@@ -869,5 +830,5 @@
   ///
   ///\dot
-  ///didigraph lemon_dot_example {
+  ///digraph lemon_dot_example {
   ///node [ shape=ellipse, fontname=Helvetica, fontsize=10 ];
   ///n0 [ label="0 (s)" ];
@@ -975,4 +936,7 @@
     typedef SubDigraphAdaptor<Digraph, ConstMap<typename Digraph::Node, bool>, 
 			      ArcFilterMap, false> Parent;
+
+    typedef typename Parent::Arc Arc;
+
   protected:
     ConstMap<typename Digraph::Node, bool> const_true_map;
@@ -984,4 +948,8 @@
   public:
 
+    /// \brief Constructor
+    ///
+    /// Creates a arc-sub-digraph-adaptor for the given digraph with
+    /// given arc map filter.
     ArcSubDigraphAdaptor(Digraph& digraph, ArcFilterMap& arc_filter) 
       : Parent(), const_true_map(true) { 
@@ -991,9 +959,29 @@
     }
 
+    /// \brief Hides the arc of the graph
+    ///
+    /// This function hides \c a in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c a
+    /// to be false in the corresponding arc-map.
+    void hide(const Arc& a) const { Parent::hide(a); }
+
+    /// \brief Unhides the arc of the graph
+    ///
+    /// The value of \c a is set to be true in the arc-map which stores 
+    /// hide information. If \c a was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Arc& a) const { Parent::unHide(a); }
+
+    /// \brief Returns true if \c a is hidden.
+    ///
+    /// Returns true if \c a is hidden.
+    ///
+    bool hidden(const Arc& a) const { return Parent::hidden(a); }
+
   };
 
-  /// \brief Just gives back an arc sub digraph adaptor
-  ///
-  /// Just gives back an arc sub digraph adaptor
+  /// \brief Just gives back an arc-sub-digraph adaptor
+  ///
+  /// Just gives back an arc-sub-digraph adaptor
   template<typename Digraph, typename ArcFilterMap>
   ArcSubDigraphAdaptor<const Digraph, ArcFilterMap>
@@ -1394,10 +1382,10 @@
   ///\ingroup graph_adaptors
   ///
-  /// \brief An graph is made from a directed digraph by an adaptor
+  /// \brief A graph is made from a directed digraph by an adaptor
   ///
   /// This adaptor makes an undirected graph from a directed
-  /// digraph. All arc of the underlying will be showed in the adaptor
-  /// as an edge. Let's see an informal example about using
-  /// this adaptor:
+  /// graph. All arc of the underlying digraph will be showed in the
+  /// adaptor as an edge. Let's see an informal example about using
+  /// this adaptor.
   ///
   /// There is a network of the streets of a town. Of course there are
@@ -1803,10 +1791,4 @@
   };
 
-  /// \brief Base class for split digraph adaptor
-  ///
-  /// Base class of split digraph adaptor. In most case you do not need to
-  /// use it directly but the documented member functions of this class can 
-  /// be used with the SplitDigraphAdaptor class.
-  /// \sa SplitDigraphAdaptor
   template <typename _Digraph>
   class SplitDigraphAdaptorBase {
@@ -2023,56 +2005,32 @@
     }
 
-    /// \brief Returns true when the node is in-node.
-    ///
-    /// Returns true when the node is in-node.
     static bool inNode(const Node& n) {
       return n._in;
     }
 
-    /// \brief Returns true when the node is out-node.
-    ///
-    /// Returns true when the node is out-node.
     static bool outNode(const Node& n) {
       return !n._in;
     }
 
-    /// \brief Returns true when the arc is arc in the original digraph.
-    ///
-    /// Returns true when the arc is arc in the original digraph.
     static bool origArc(const Arc& e) {
       return e._item.firstState();
     }
 
-    /// \brief Returns true when the arc binds an in-node and an out-node.
-    ///
-    /// Returns true when the arc binds an in-node and an out-node.
     static bool bindArc(const Arc& e) {
       return e._item.secondState();
     }
 
-    /// \brief Gives back the in-node created from the \c node.
-    ///
-    /// Gives back the in-node created from the \c node.
     static Node inNode(const DigraphNode& n) {
       return Node(n, true);
     }
 
-    /// \brief Gives back the out-node created from the \c node.
-    ///
-    /// Gives back the out-node created from the \c node.
     static Node outNode(const DigraphNode& n) {
       return Node(n, false);
     }
 
-    /// \brief Gives back the arc binds the two part of the node.
-    /// 
-    /// Gives back the arc binds the two part of the node.
     static Arc arc(const DigraphNode& n) {
       return Arc(n);
     }
 
-    /// \brief Gives back the arc of the original arc.
-    /// 
-    /// Gives back the arc of the original arc.
     static Arc arc(const DigraphArc& e) {
       return Arc(e);
@@ -2276,5 +2234,5 @@
   /// bind arc in the adapted digraph.
   /// 
-  /// By example a maximum flow algoritm can compute how many arc
+  /// For example a maximum flow algorithm can compute how many arc
   /// disjoint paths are in the digraph. But we would like to know how
   /// many node disjoint paths are in the digraph. First we have to
@@ -2331,4 +2289,7 @@
     typedef DigraphAdaptorExtender<SplitDigraphAdaptorBase<Digraph> > Parent;
 
+    typedef typename Digraph::Node DigraphNode;
+    typedef typename Digraph::Arc DigraphArc;
+
     typedef typename Parent::Node Node;
     typedef typename Parent::Arc Arc;
@@ -2339,4 +2300,60 @@
     SplitDigraphAdaptor(Digraph& g) {
       Parent::setDigraph(g);
+    }
+
+    /// \brief Returns true when the node is in-node.
+    ///
+    /// Returns true when the node is in-node.
+    static bool inNode(const Node& n) {
+      return Parent::inNode(n);
+    }
+
+    /// \brief Returns true when the node is out-node.
+    ///
+    /// Returns true when the node is out-node.
+    static bool outNode(const Node& n) {
+      return Parent::outNode(n);
+    }
+
+    /// \brief Returns true when the arc is arc in the original digraph.
+    ///
+    /// Returns true when the arc is arc in the original digraph.
+    static bool origArc(const Arc& a) {
+      return Parent::origArc(a);
+    }
+
+    /// \brief Returns true when the arc binds an in-node and an out-node.
+    ///
+    /// Returns true when the arc binds an in-node and an out-node.
+    static bool bindArc(const Arc& a) {
+      return Parent::bindArc(a);
+    }
+
+    /// \brief Gives back the in-node created from the \c node.
+    ///
+    /// Gives back the in-node created from the \c node.
+    static Node inNode(const DigraphNode& n) {
+      return Parent::inNode(n);
+    }
+
+    /// \brief Gives back the out-node created from the \c node.
+    ///
+    /// Gives back the out-node created from the \c node.
+    static Node outNode(const DigraphNode& n) {
+      return Parent::outNode(n);
+    }
+
+    /// \brief Gives back the arc binds the two part of the node.
+    /// 
+    /// Gives back the arc binds the two part of the node.
+    static Arc arc(const DigraphNode& n) {
+      return Parent::arc(n);
+    }
+
+    /// \brief Gives back the arc of the original arc.
+    /// 
+    /// Gives back the arc of the original arc.
+    static Arc arc(const DigraphArc& a) {
+      return Parent::arc(a);
     }
 
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 430)
+++ lemon/graph_adaptor.h	(revision 431)
@@ -32,13 +32,4 @@
 namespace lemon {
 
-  /// \brief Base type for the Graph Adaptors
-  ///
-  /// This is the base type for most of LEMON graph adaptors. 
-  /// This class implements a trivial graph adaptor i.e. it only wraps the 
-  /// functions and types of the graph. The purpose of this class is to 
-  /// make easier implementing graph adaptors. E.g. if an adaptor is 
-  /// considered which differs from the wrapped graph only in some of its 
-  /// functions or types, then it can be derived from GraphAdaptor, and only 
-  /// the differences should be implemented.
   template<typename _Graph>
   class GraphAdaptorBase {
@@ -196,23 +187,4 @@
   };
 
-  /// \ingroup graph_adaptors
-  ///
-  /// \brief Trivial graph adaptor
-  ///
-  /// This class is an adaptor which does not change the adapted undirected
-  /// graph. It can be used only to test the graph adaptors.
-  template <typename _Graph>
-  class GraphAdaptor 
-    : public GraphAdaptorExtender< GraphAdaptorBase<_Graph> > { 
-  public:
-    typedef _Graph Graph;
-    typedef GraphAdaptorExtender<GraphAdaptorBase<_Graph> > Parent;
-  protected:
-    GraphAdaptor() : Parent() {}
-
-  public:
-    explicit GraphAdaptor(Graph& graph) { setGraph(graph); }
-  };
-
   template <typename _Graph, typename NodeFilterMap, 
 	    typename EdgeFilterMap, bool checked = true>
@@ -319,40 +291,11 @@
     }
 
-    /// \brief Hide the given node in the graph.
-    ///
-    /// This function hides \c n in the graph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c n  
-    /// to be false in the corresponding node-map.
     void hide(const Node& n) const { _node_filter_map->set(n, false); }
-
-    /// \brief Hide the given edge in the graph.
-    ///
-    /// This function hides \c e in the graph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c e  
-    /// to be false in the corresponding edge-map.
     void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
 
-    /// \brief Unhide the given node in the graph.
-    ///
-    /// The value of \c n is set to be true in the node-map which stores 
-    /// hide information. If \c n was hidden previuosly, then it is shown 
-    /// again
-     void unHide(const Node& n) const { _node_filter_map->set(n, true); }
-
-    /// \brief Hide the given edge in the graph.
-    ///
-    /// The value of \c e is set to be true in the edge-map which stores 
-    /// hide information. If \c e was hidden previuosly, then it is shown 
-    /// again
+    void unHide(const Node& n) const { _node_filter_map->set(n, true); }
     void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
 
-    /// \brief Returns true if \c n is hidden.
-    ///
-    /// Returns true if \c n is hidden.
     bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
-
-    /// \brief Returns true if \c e is hidden.
-    ///
-    /// Returns true if \c e is hidden.
     bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
 
@@ -544,40 +487,11 @@
     }
 
-    /// \brief Hide the given node in the graph.
-    ///
-    /// This function hides \c n in the graph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c n  
-    /// to be false in the corresponding node-map.
     void hide(const Node& n) const { _node_filter_map->set(n, false); }
-
-    /// \brief Hide the given edge in the graph.
-    ///
-    /// This function hides \c e in the graph, i.e. the iteration 
-    /// jumps over it. This is done by simply setting the value of \c e  
-    /// to be false in the corresponding edge-map.
     void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
 
-    /// \brief Unhide the given node in the graph.
-    ///
-    /// The value of \c n is set to be true in the node-map which stores 
-    /// hide information. If \c n was hidden previuosly, then it is shown 
-    /// again
-     void unHide(const Node& n) const { _node_filter_map->set(n, true); }
-
-    /// \brief Hide the given edge in the graph.
-    ///
-    /// The value of \c e is set to be true in the edge-map which stores 
-    /// hide information. If \c e was hidden previuosly, then it is shown 
-    /// again
+    void unHide(const Node& n) const { _node_filter_map->set(n, true); }
     void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
 
-    /// \brief Returns true if \c n is hidden.
-    ///
-    /// Returns true if \c n is hidden.
     bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
-
-    /// \brief Returns true if \c e is hidden.
-    ///
-    /// Returns true if \c e is hidden.
     bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
 
@@ -683,5 +597,5 @@
   /// \ingroup graph_adaptors
   ///
-  /// \brief A graph adaptor for hiding nodes and arcs from an
+  /// \brief A graph adaptor for hiding nodes and edges from an
   /// undirected graph.
   /// 
@@ -705,7 +619,16 @@
     typedef GraphAdaptorExtender<
       SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent;
+
+    typedef typename Parent::Node Node;
+    typedef typename Parent::Edge Edge;
+
   protected:
     SubGraphAdaptor() { }
   public:
+    
+    /// \brief Constructor
+    ///
+    /// Creates a sub-graph-adaptor for the given graph with
+    /// given node and edge map filters.
     SubGraphAdaptor(Graph& _graph, NodeFilterMap& node_filter_map, 
 		    EdgeFilterMap& edge_filter_map) { 
@@ -714,6 +637,49 @@
       setEdgeFilterMap(edge_filter_map);
     }
+
+    /// \brief Hides the node of the graph
+    ///
+    /// This function hides \c n in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c n  
+    /// to be false in the corresponding node-map.
+    void hide(const Node& n) const { Parent::hide(n); }
+
+    /// \brief Hides the edge of the graph
+    ///
+    /// This function hides \c e in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c e
+    /// to be false in the corresponding edge-map.
+    void hide(const Edge& e) const { Parent::hide(e); }
+
+    /// \brief Unhides the node of the graph
+    ///
+    /// The value of \c n is set to be true in the node-map which stores 
+    /// hide information. If \c n was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Node& n) const { Parent::unHide(n); }
+
+    /// \brief Unhides the edge of the graph
+    ///
+    /// The value of \c e is set to be true in the edge-map which stores 
+    /// hide information. If \c e was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Edge& e) const { Parent::unHide(e); }
+
+    /// \brief Returns true if \c n is hidden.
+    ///
+    /// Returns true if \c n is hidden.
+    ///
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+
+    /// \brief Returns true if \c e is hidden.
+    ///
+    /// Returns true if \c e is hidden.
+    ///
+    bool hidden(const Edge& e) const { return Parent::hidden(e); }
   };
 
+  /// \brief Just gives back a sub-graph adaptor
+  ///
+  /// Just gives back a sub-graph adaptor
   template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
   SubGraphAdaptor<const Graph, NodeFilterMap, ArcFilterMap>
@@ -766,4 +732,6 @@
     typedef SubGraphAdaptor<Graph, NodeFilterMap, 
 			    ConstMap<typename Graph::Edge, bool> > Parent;
+
+    typedef typename Parent::Node Node;
   protected:
     ConstMap<typename Graph::Edge, bool> const_true_map;
@@ -774,4 +742,9 @@
 
   public:
+
+    /// \brief Constructor
+    ///
+    /// Creates a node-sub-graph-adaptor for the given graph with
+    /// given node map filters.
     NodeSubGraphAdaptor(Graph& _graph, NodeFilterMap& node_filter_map) : 
       Parent(), const_true_map(true) { 
@@ -780,6 +753,30 @@
       Parent::setEdgeFilterMap(const_true_map);
     }
+
+    /// \brief Hides the node of the graph
+    ///
+    /// This function hides \c n in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c n  
+    /// to be false in the corresponding node-map.
+    void hide(const Node& n) const { Parent::hide(n); }
+
+    /// \brief Unhides the node of the graph
+    ///
+    /// The value of \c n is set to be true in the node-map which stores 
+    /// hide information. If \c n was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Node& n) const { Parent::unHide(n); }
+
+    /// \brief Returns true if \c n is hidden.
+    ///
+    /// Returns true if \c n is hidden.
+    ///
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+
   };
 
+  /// \brief Just gives back a node-sub-graph adaptor
+  ///
+  /// Just gives back a node-sub-graph adaptor
   template<typename Graph, typename NodeFilterMap>
   NodeSubGraphAdaptor<const Graph, NodeFilterMap>
@@ -814,4 +811,5 @@
     typedef SubGraphAdaptor<Graph, ConstMap<typename Graph::Node,bool>, 
 			    EdgeFilterMap, false> Parent;
+    typedef typename Parent::Edge Edge;
   protected:
     ConstMap<typename Graph::Node, bool> const_true_map;
@@ -823,4 +821,8 @@
   public:
 
+    /// \brief Constructor
+    ///
+    /// Creates a edge-sub-graph-adaptor for the given graph with
+    /// given node map filters.
     EdgeSubGraphAdaptor(Graph& _graph, EdgeFilterMap& edge_filter_map) : 
       Parent(), const_true_map(true) { 
@@ -830,6 +832,29 @@
     }
 
+    /// \brief Hides the edge of the graph
+    ///
+    /// This function hides \c e in the digraph, i.e. the iteration 
+    /// jumps over it. This is done by simply setting the value of \c e
+    /// to be false in the corresponding edge-map.
+    void hide(const Edge& e) const { Parent::hide(e); }
+
+    /// \brief Unhides the edge of the graph
+    ///
+    /// The value of \c e is set to be true in the edge-map which stores 
+    /// hide information. If \c e was hidden previuosly, then it is shown 
+    /// again
+    void unHide(const Edge& e) const { Parent::unHide(e); }
+
+    /// \brief Returns true if \c e is hidden.
+    ///
+    /// Returns true if \c e is hidden.
+    ///
+    bool hidden(const Edge& e) const { return Parent::hidden(e); }
+
   };
 
+  /// \brief Just gives back an edge-sub-graph adaptor
+  ///
+  /// Just gives back an edge-sub-graph adaptor
   template<typename Graph, typename EdgeFilterMap>
   EdgeSubGraphAdaptor<const Graph, EdgeFilterMap>
@@ -844,9 +869,4 @@
   }
 
-  /// \brief Base of direct graph adaptor
-  ///
-  /// Base class of the direct graph adaptor. All public member
-  /// of this class can be used with the DirGraphAdaptor too.
-  /// \sa DirGraphAdaptor
   template <typename _Graph, typename _DirectionMap>
   class DirGraphAdaptorBase {
@@ -1104,4 +1124,5 @@
     typedef DigraphAdaptorExtender<
       DirGraphAdaptorBase<_Graph, DirectionMap> > Parent;
+    typedef typename Parent::Arc Arc;
   protected:
     DirGraphAdaptor() { }
@@ -1114,4 +1135,11 @@
       setGraph(graph);
       setDirectionMap(direction);
+    }
+
+    /// \brief Reverse arc
+    /// 
+    /// It reverse the given arc. It simply negate the direction in the map.
+    void reverseArc(const Arc& a) {
+      Parent::reverseArc(a);
     }
   };
Index: test/graph_adaptor_test.cc
===================================================================
--- test/graph_adaptor_test.cc	(revision 430)
+++ test/graph_adaptor_test.cc	(revision 431)
@@ -38,40 +38,4 @@
 using namespace lemon;
 
-void checkDigraphAdaptor() {
-  checkConcept<concepts::Digraph, DigraphAdaptor<concepts::Digraph> >();
-
-  typedef ListDigraph Digraph;
-  typedef DigraphAdaptor<Digraph> Adaptor;
-
-  Digraph digraph;
-  Adaptor adaptor(digraph);
-
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Digraph::Node n3 = digraph.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n1, n3);
-  Digraph::Arc a3 = digraph.addArc(n2, n3);
-  
-  checkGraphNodeList(adaptor, 3);
-  checkGraphArcList(adaptor, 3);
-  checkGraphConArcList(adaptor, 3);
-
-  checkGraphOutArcList(adaptor, n1, 2);
-  checkGraphOutArcList(adaptor, n2, 1);
-  checkGraphOutArcList(adaptor, n3, 0);
-
-  checkGraphInArcList(adaptor, n1, 0);
-  checkGraphInArcList(adaptor, n2, 1);
-  checkGraphInArcList(adaptor, n3, 2);
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-}
-
 void checkRevDigraphAdaptor() {
   checkConcept<concepts::Digraph, RevDigraphAdaptor<concepts::Digraph> >();
@@ -586,54 +550,4 @@
 }
 
-void checkGraphAdaptor() {
-  checkConcept<concepts::Graph, GraphAdaptor<concepts::Graph> >();
-
-  typedef ListGraph Graph;
-  typedef GraphAdaptor<Graph> Adaptor;
-
-  Graph graph;
-  Adaptor adaptor(graph);
-
-  Graph::Node n1 = graph.addNode();
-  Graph::Node n2 = graph.addNode();
-  Graph::Node n3 = graph.addNode();
-  Graph::Node n4 = graph.addNode();
-
-  Graph::Edge a1 = graph.addEdge(n1, n2);
-  Graph::Edge a2 = graph.addEdge(n1, n3);
-  Graph::Edge a3 = graph.addEdge(n2, n3);
-  Graph::Edge a4 = graph.addEdge(n3, n4);
-  
-  checkGraphNodeList(adaptor, 4);
-  checkGraphArcList(adaptor, 8);
-  checkGraphEdgeList(adaptor, 4);
-  checkGraphConArcList(adaptor, 8);
-  checkGraphConEdgeList(adaptor, 4);
-
-  checkGraphOutArcList(adaptor, n1, 2);
-  checkGraphOutArcList(adaptor, n2, 2);
-  checkGraphOutArcList(adaptor, n3, 3);
-  checkGraphOutArcList(adaptor, n4, 1);
-
-  checkGraphInArcList(adaptor, n1, 2);
-  checkGraphInArcList(adaptor, n2, 2);
-  checkGraphInArcList(adaptor, n3, 3);
-  checkGraphInArcList(adaptor, n4, 1);
-
-  checkGraphIncEdgeList(adaptor, n1, 2);
-  checkGraphIncEdgeList(adaptor, n2, 2);
-  checkGraphIncEdgeList(adaptor, n3, 3);
-  checkGraphIncEdgeList(adaptor, n4, 1);
-
-
-  checkNodeIds(adaptor);
-  checkArcIds(adaptor);
-  checkEdgeIds(adaptor);
-
-  checkGraphNodeMap(adaptor);
-  checkGraphArcMap(adaptor);
-  checkGraphEdgeMap(adaptor);
-}
-
 void checkSubGraphAdaptor() {
   checkConcept<concepts::Graph, 
@@ -1054,5 +968,4 @@
 int main(int, const char **) {
 
-  checkDigraphAdaptor();
   checkRevDigraphAdaptor();
   checkSubDigraphAdaptor();
@@ -1063,5 +976,4 @@
   checkSplitDigraphAdaptor();
 
-  checkGraphAdaptor();
   checkSubGraphAdaptor();
   checkNodeSubGraphAdaptor();
