Index: lemon/concept/ugraph.h
===================================================================
--- lemon/concept/ugraph.h	(revision 1979)
+++ lemon/concept/ugraph.h	(revision 1980)
@@ -865,4 +865,8 @@
 
 
+      void firstInc(UEdge &, bool &, const Node &) const {}
+
+      void nextInc(UEdge &, bool &) const {}
+
       /// \brief Base node of the iterator
       ///
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 1979)
+++ lemon/graph_adaptor.h	(revision 1980)
@@ -699,5 +699,5 @@
 
   template <typename _Graph>
-  class UndirectGraphAdaptorBase : 
+  class UndirGraphAdaptorBase : 
     public UGraphBaseExtender<GraphAdaptorBase<_Graph> > {
   public:
@@ -705,5 +705,5 @@
     typedef UGraphBaseExtender<GraphAdaptorBase<_Graph> > Parent;
   protected:
-    UndirectGraphAdaptorBase() : Parent() { }
+    UndirGraphAdaptorBase() : Parent() { }
   public:
     typedef typename Parent::UEdge UEdge;
@@ -713,5 +713,5 @@
     class EdgeMap {
     protected:
-      const UndirectGraphAdaptorBase<_Graph>* g;
+      const UndirGraphAdaptorBase<_Graph>* g;
       template <typename TT> friend class EdgeMap;
       typename _Graph::template EdgeMap<T> forward_map, backward_map; 
@@ -720,8 +720,8 @@
       typedef Edge Key;
       
-      EdgeMap(const UndirectGraphAdaptorBase<_Graph>& _g) : g(&_g), 
+      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g) : g(&_g), 
 	forward_map(*(g->graph)), backward_map(*(g->graph)) { }
 
-      EdgeMap(const UndirectGraphAdaptorBase<_Graph>& _g, T a) : g(&_g), 
+      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g, T a) : g(&_g), 
 	forward_map(*(g->graph), a), backward_map(*(g->graph), a) { }
       
@@ -749,8 +749,8 @@
       typedef UEdge Key;
       
-      UEdgeMap(const UndirectGraphAdaptorBase<_Graph>& g) : 
+      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) : 
 	map(*(g.graph)) { }
 
-      UEdgeMap(const UndirectGraphAdaptorBase<_Graph>& g, T a) : 
+      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, T a) : 
 	map(*(g.graph), a) { }
       
@@ -774,15 +774,15 @@
   /// \author Marton Makai
   template<typename _Graph>
-  class UndirectGraphAdaptor : 
+  class UndirGraphAdaptor : 
     public UGraphAdaptorExtender<
-    UndirectGraphAdaptorBase<_Graph> > {
+    UndirGraphAdaptorBase<_Graph> > {
   public:
     typedef _Graph Graph;
     typedef UGraphAdaptorExtender<
-      UndirectGraphAdaptorBase<_Graph> > Parent;
+      UndirGraphAdaptorBase<_Graph> > Parent;
   protected:
-    UndirectGraphAdaptor() { }
-  public:
-    UndirectGraphAdaptor(_Graph& _graph) { 
+    UndirGraphAdaptor() { }
+  public:
+    UndirGraphAdaptor(_Graph& _graph) { 
       setGraph(_graph);
     }
Index: lemon/ugraph_adaptor.h
===================================================================
--- lemon/ugraph_adaptor.h	(revision 1979)
+++ lemon/ugraph_adaptor.h	(revision 1980)
@@ -512,7 +512,4 @@
   /// graph.
   /// 
-  /// \warning Graph adaptors are in even more experimental state than the
-  /// other parts of the lib. Use them at you own risk.
-  /// 
   /// SubUGraphAdaptor shows the undirected graph with filtered node-set and 
   /// edge-set. If the \c checked parameter is true then it filters the edgeset
@@ -529,9 +526,4 @@
   /// \c Graph::Node that is why \c g.id(n) can be applied.
   /// 
-  /// For examples see also the documentation of NodeSubUGraphAdaptor and 
-  /// EdgeSubUGraphAdaptor.
-  /// 
-  /// \author Marton Makai
-
   template<typename _UGraph, typename NodeFilterMap, 
 	   typename UEdgeFilterMap, bool checked = true>
@@ -554,11 +546,40 @@
   };
 
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, NodeFilterMap, EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, NodeFilterMap, EdgeFilterMap>
+      (graph, nfm, efm);
+  }
+
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, const NodeFilterMap, EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, const NodeFilterMap, EdgeFilterMap>
+      (graph, nfm, efm);
+  }
+
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, NodeFilterMap, const EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, NodeFilterMap, const EdgeFilterMap>
+      (graph, nfm, efm);
+  }
+
+  template<typename UGraph, typename NodeFilterMap, typename EdgeFilterMap>
+  SubUGraphAdaptor<const UGraph, const NodeFilterMap, const EdgeFilterMap>
+  subUGraphAdaptor(const UGraph& graph, 
+                   NodeFilterMap& nfm, EdgeFilterMap& efm) {
+    return SubUGraphAdaptor<const UGraph, const NodeFilterMap, 
+      const EdgeFilterMap>(graph, nfm, efm);
+  }
+
   /// \ingroup graph_adaptors
   ///
-  /// \brief An adaptor for hiding nodes from an undorected graph.
-  ///
-  /// \warning Graph adaptors are in even more experimental state
-  /// than the other
-  /// parts of the lib. Use them at you own risk.
+  /// \brief An adaptor for hiding nodes from an undirected graph.
+  ///
   ///
   /// An adaptor for hiding nodes from an undirected graph.
@@ -568,5 +589,4 @@
   /// induced subgraph. But if the checked parameter is false then we can only
   /// filter only isolated nodes.
-  /// \author Marton Makai
   template<typename _UGraph, typename NodeFilterMap, bool checked = true>
   class NodeSubUGraphAdaptor : 
@@ -610,6 +630,4 @@
   /// only the edge-set 
   /// can be filtered.
-  ///
-  ///\author Marton Makai
   template<typename _UGraph, typename UEdgeFilterMap>
   class EdgeSubUGraphAdaptor : 
@@ -644,5 +662,5 @@
 
   template <typename _UGraph, typename _DirectionMap>
-  class DirectUGraphAdaptorBase {
+  class DirUGraphAdaptorBase {
   public:
     
@@ -737,7 +755,7 @@
     public:
       typedef typename _UGraph::template NodeMap<_Value> Parent;
-      explicit NodeMap(const DirectUGraphAdaptorBase& ga) 
+      explicit NodeMap(const DirUGraphAdaptorBase& ga) 
 	: Parent(*ga.graph) { }
-      NodeMap(const DirectUGraphAdaptorBase& ga, const _Value& value)
+      NodeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
 	: Parent(*ga.graph, value) { }
     };
@@ -746,8 +764,8 @@
     class EdgeMap : public _UGraph::template UEdgeMap<_Value> {
     public:
-      typedef typename _UGraph::template EdgeMap<_Value> Parent;
-      explicit EdgeMap(const DirectUGraphAdaptorBase& ga) 
+      typedef typename _UGraph::template UEdgeMap<_Value> Parent;
+      explicit EdgeMap(const DirUGraphAdaptorBase& ga) 
 	: Parent(*ga.graph) { }
-      EdgeMap(const DirectUGraphAdaptorBase& ga, const _Value& value)
+      EdgeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
 	: Parent(*ga.graph, value) { }
     };
@@ -770,16 +788,26 @@
 
 
-  template<typename _Graph, typename DirectionMap> 
-  class DirectUGraphAdaptor : 
+  /// \ingroup graph_adaptors
+  /// \brief A directed graph is made from a undirected graph by an adaptor
+  ///
+  /// This adaptor gives a direction for each uedge in the undirected graph.
+  /// The direction of the edges stored in the DirectionMap. This map is
+  /// a bool map on the undirected edges. If the uedge is mapped to true
+  /// then the direction of the directed edge will be the same as the
+  /// default direction of the uedge. The edges can be easily reverted
+  /// by the reverseEdge member in the adaptor.  
+  template<typename _Graph, 
+           typename DirectionMap = typename _Graph::template UEdgeMap<bool> > 
+  class DirUGraphAdaptor : 
     public GraphAdaptorExtender<
-    DirectUGraphAdaptorBase<_Graph, DirectionMap> > {
+    DirUGraphAdaptorBase<_Graph, DirectionMap> > {
   public:
     typedef _Graph Graph;
     typedef GraphAdaptorExtender<
-      DirectUGraphAdaptorBase<_Graph, DirectionMap> > Parent;
+      DirUGraphAdaptorBase<_Graph, DirectionMap> > Parent;
   protected:
-    DirectUGraphAdaptor() { }
-  public:
-    DirectUGraphAdaptor(_Graph& _graph, DirectionMap& _direction_map) { 
+    DirUGraphAdaptor() { }
+  public:
+    DirUGraphAdaptor(_Graph& _graph, DirectionMap& _direction_map) { 
       setGraph(_graph);
       setDirectionMap(_direction_map);
@@ -788,13 +816,13 @@
 
   template<typename UGraph, typename DirectionMap>
-  DirectUGraphAdaptor<const UGraph, DirectionMap>
-  directUGraphAdaptor(const UGraph& graph, DirectionMap& dm) {
-    return DirectUGraphAdaptor<const UGraph, DirectionMap>(graph, dm);
+  DirUGraphAdaptor<const UGraph, DirectionMap>
+  dirUGraphAdaptor(const UGraph& graph, DirectionMap& dm) {
+    return DirUGraphAdaptor<const UGraph, DirectionMap>(graph, dm);
   }
 
   template<typename UGraph, typename DirectionMap>
-  DirectUGraphAdaptor<const UGraph, const DirectionMap>
-  directUGraphAdaptor(const UGraph& graph, const DirectionMap& dm) {
-    return DirectUGraphAdaptor<const UGraph, const DirectionMap>(graph, dm);
+  DirUGraphAdaptor<const UGraph, const DirectionMap>
+  dirUGraphAdaptor(const UGraph& graph, const DirectionMap& dm) {
+    return DirUGraphAdaptor<const UGraph, const DirectionMap>(graph, dm);
   }
 
Index: test/graph_adaptor_test.cc
===================================================================
--- test/graph_adaptor_test.cc	(revision 1979)
+++ test/graph_adaptor_test.cc	(revision 1980)
@@ -27,4 +27,5 @@
 #include<lemon/full_graph.h>
 #include<lemon/graph_adaptor.h>
+#include<lemon/ugraph_adaptor.h>
 
 #include"test/test_tools.h"
@@ -67,6 +68,15 @@
       Graph::NodeMap<Graph::Edge> > >(); 
 
-    /// \bug why does not compile with StaticGraph
-    checkConcept<UGraph, UndirectGraphAdaptor<ListGraph> >();
+    checkConcept<UGraph, UndirGraphAdaptor<Graph> >();
+
+    checkConcept<UGraph, SubUGraphAdaptor<UGraph, 
+      UGraph::NodeMap<bool> , UGraph::UEdgeMap<bool> > >();
+    checkConcept<UGraph, NodeSubUGraphAdaptor<UGraph, 
+      UGraph::NodeMap<bool> > >();
+    checkConcept<UGraph, EdgeSubUGraphAdaptor<UGraph, 
+      UGraph::UEdgeMap<bool> > >();
+
+    checkConcept<StaticGraph, DirUGraphAdaptor<UGraph, 
+      UGraph::UEdgeMap<bool> > >();
   }
   std::cout << __FILE__ ": All tests passed.\n";
