Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 1875)
+++ lemon/bits/default_map.h	(revision 1909)
@@ -267,35 +267,35 @@
   /// \e
   template <typename _Base> 
-  class MappableUndirGraphExtender : 
+  class MappableUGraphExtender : 
     public MappableGraphExtender<_Base> {
   public:
 
-    typedef MappableUndirGraphExtender Graph;
+    typedef MappableUGraphExtender Graph;
     typedef MappableGraphExtender<_Base> Parent;
 
-    typedef typename Parent::UndirEdge UndirEdge;
-
-    template <typename _Value>
-    class UndirEdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > {
-    public:
-      typedef MappableUndirGraphExtender Graph;
+    typedef typename Parent::UEdge UEdge;
+
+    template <typename _Value>
+    class UEdgeMap 
+      : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
+    public:
+      typedef MappableUGraphExtender Graph;
       typedef IterableMapExtender<
-	DefaultMap<Graph, UndirEdge, _Value> > Parent;
-
-      UndirEdgeMap(const Graph& _g) 
-	: Parent(_g) {}
-      UndirEdgeMap(const Graph& _g, const _Value& _v) 
-	: Parent(_g, _v) {}
-
-      UndirEdgeMap& operator=(const UndirEdgeMap& cmap) {
-	return operator=<UndirEdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      UndirEdgeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<UndirEdge, _Value>, CMap>();
-	const typename Parent::Graph* graph = Parent::getGraph();
-	UndirEdge it;
+	DefaultMap<Graph, UEdge, _Value> > Parent;
+
+      UEdgeMap(const Graph& _g) 
+	: Parent(_g) {}
+      UEdgeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
+
+      UEdgeMap& operator=(const UEdgeMap& cmap) {
+	return operator=<UEdgeMap>(cmap);
+      }
+
+      template <typename CMap>
+      UEdgeMap& operator=(const CMap& cmap) {
+	checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
+	const typename Parent::Graph* graph = Parent::getGraph();
+	UEdge it;
 	for (graph->first(it); it != INVALID; graph->next(it)) {
 	  Parent::set(it, cmap[it]);
@@ -310,35 +310,35 @@
   /// \e
   template <typename _Base> 
-  class MappableUndirEdgeSetExtender : 
+  class MappableUEdgeSetExtender : 
     public MappableEdgeSetExtender<_Base> {
   public:
 
-    typedef MappableUndirEdgeSetExtender Graph;
+    typedef MappableUEdgeSetExtender Graph;
     typedef MappableEdgeSetExtender<_Base> Parent;
 
-    typedef typename Parent::UndirEdge UndirEdge;
-
-    template <typename _Value>
-    class UndirEdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > {
-    public:
-      typedef MappableUndirEdgeSetExtender Graph;
+    typedef typename Parent::UEdge UEdge;
+
+    template <typename _Value>
+    class UEdgeMap 
+      : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
+    public:
+      typedef MappableUEdgeSetExtender Graph;
       typedef IterableMapExtender<
-	DefaultMap<Graph, UndirEdge, _Value> > Parent;
-
-      UndirEdgeMap(const Graph& _g) 
-	: Parent(_g) {}
-      UndirEdgeMap(const Graph& _g, const _Value& _v) 
-	: Parent(_g, _v) {}
-
-      UndirEdgeMap& operator=(const UndirEdgeMap& cmap) {
-	return operator=<UndirEdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      UndirEdgeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<UndirEdge, _Value>, CMap>();
-	const typename Parent::Graph* graph = Parent::getGraph();
-	UndirEdge it;
+	DefaultMap<Graph, UEdge, _Value> > Parent;
+
+      UEdgeMap(const Graph& _g) 
+	: Parent(_g) {}
+      UEdgeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
+
+      UEdgeMap& operator=(const UEdgeMap& cmap) {
+	return operator=<UEdgeMap>(cmap);
+      }
+
+      template <typename CMap>
+      UEdgeMap& operator=(const CMap& cmap) {
+	checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
+	const typename Parent::Graph* graph = Parent::getGraph();
+	UEdge it;
 	for (graph->first(it); it != INVALID; graph->next(it)) {
 	  Parent::set(it, cmap[it]);
@@ -353,9 +353,9 @@
 
   template <typename _Base>
-  class MappableUndirBipartiteGraphExtender : public _Base {
+  class MappableUBipartiteGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef MappableUndirBipartiteGraphExtender Graph;
+    typedef MappableUBipartiteGraphExtender Graph;
 
     typedef typename Parent::Node Node;
@@ -363,5 +363,5 @@
     typedef typename Parent::LowerNode LowerNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
     
     template <typename _Value>
@@ -369,5 +369,5 @@
       : public IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > 
       Parent;
@@ -406,5 +406,5 @@
       : public IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > 
       Parent;
@@ -444,5 +444,5 @@
     class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
 
       typedef Node Key;
@@ -524,5 +524,5 @@
       : public IterableMapExtender<NodeMapBase<_Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
     
@@ -562,5 +562,5 @@
       : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     
@@ -587,25 +587,25 @@
 
     template <typename _Value>
-    class UndirEdgeMap 
-      : public IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > {
-    public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > 
+    class UEdgeMap 
+      : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
+    public:
+      typedef MappableUBipartiteGraphExtender Graph;
+      typedef IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > 
       Parent;
     
-      UndirEdgeMap(const Graph& _g) 
-	: Parent(_g) {}
-      UndirEdgeMap(const Graph& _g, const _Value& _v) 
-	: Parent(_g, _v) {}
-    
-      UndirEdgeMap& operator=(const UndirEdgeMap& cmap) {
-	return operator=<UndirEdgeMap>(cmap);
-      }
-    
-      template <typename CMap>
-      UndirEdgeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<UndirEdge, _Value>, CMap>();
-	const typename Parent::Graph* graph = Parent::getGraph();
-	UndirEdge it;
+      UEdgeMap(const Graph& _g) 
+	: Parent(_g) {}
+      UEdgeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
+    
+      UEdgeMap& operator=(const UEdgeMap& cmap) {
+	return operator=<UEdgeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      UEdgeMap& operator=(const CMap& cmap) {
+	checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
+	const typename Parent::Graph* graph = Parent::getGraph();
+	UEdge it;
 	for (graph->first(it); it != INVALID; graph->next(it)) {
 	  Parent::set(it, cmap[it]);
