Changeset 1909:2d806130e700 in lemon-0.x

Timestamp:

01/26/06 16:42:13 (18 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2484

Message:

Undir -> U transition

Files:

• demo/coloring.cc (modified) (2 diffs)
• demo/coloring.lgf (modified) (1 diff)
• demo/partitions.lgf (modified) (1 diff)
• demo/topology_demo.cc (modified) (9 diffs)
• demo/undir_components.lgf (modified) (1 diff)
• doc/Makefile.am (modified) (1 diff)
• doc/graph_io.dox (modified) (7 diffs)
• doc/undir_graphs.dox (modified) (1 diff)
• lemon/Makefile.am (modified) (1 diff)
• lemon/bits/alteration_notifier.h (modified) (6 diffs)
• lemon/bits/clearable_graph_extender.h (modified) (4 diffs)
• lemon/bits/default_map.h (modified) (10 diffs)
• lemon/bits/erasable_graph_extender.h (modified) (3 diffs)
• lemon/bits/extendable_graph_extender.h (modified) (6 diffs)
• lemon/bits/graph_extender.h (modified) (35 diffs)
• lemon/bits/iterable_graph_extender.h (modified) (17 diffs)
• lemon/bits/static_map.h (modified) (9 diffs)
• lemon/concept/graph.h (modified) (2 diffs)
• lemon/concept/graph_component.h (modified) (1 diff)
• lemon/concept/ugraph.h (moved) (moved from lemon/concept/undir_graph.h) (55 diffs)
• lemon/edge_set.h (modified) (5 diffs)
• lemon/euler.h (modified) (8 diffs)
• lemon/full_graph.h (modified) (11 diffs)
• lemon/graph_adaptor.h (modified) (5 diffs)
• lemon/graph_reader.h (modified) (33 diffs)
• lemon/graph_to_eps.h (modified) (6 diffs)
• lemon/graph_utils.h (modified) (29 diffs)
• lemon/graph_writer.h (modified) (27 diffs)
• lemon/grid_graph.h (modified) (6 diffs)
• lemon/hypercube_graph.h (modified) (1 diff)
• lemon/kruskal.h (modified) (3 diffs)
• lemon/lemon_reader.h (modified) (47 diffs)
• lemon/lemon_writer.h (modified) (22 diffs)
• lemon/list_graph.h (modified) (5 diffs)
• lemon/max_matching.h (modified) (7 diffs)
• lemon/path.h (modified) (10 diffs)
• lemon/smart_graph.h (modified) (5 diffs)
• lemon/sub_graph.h (modified) (3 diffs)
• lemon/topology.h (modified) (31 diffs)
• lemon/traits.h (modified) (1 diff)
• test/Makefile.am (modified) (2 diffs)
• test/graph_adaptor_test.cc (modified) (2 diffs)
• test/max_matching_test.cc (modified) (2 diffs)
• test/path_test.cc (modified) (1 diff)
• test/test_tools.h (modified) (3 diffs)
• test/ugraph_test.cc (moved) (moved from test/undir_graph_test.cc) (7 diffs)

demo/coloring.cc

@@ -41 +41 @@
 int main() {
 
-  typedef UndirSmartGraph Graph;
+  typedef SmartUGraph Graph;
   typedef Graph::Node Node;
   typedef Graph::NodeIt NodeIt;
-  typedef Graph::UndirEdge UndirEdge;
+  typedef Graph::UEdge UEdge;
   typedef Graph::IncEdgeIt IncEdgeIt;
 
@@ -53 +53 @@
   Graph graph;
 
-  UndirGraphReader<Graph> reader("coloring.lgf", graph);
+  UGraphReader<Graph> reader("coloring.lgf", graph);
   Graph::NodeMap<xy<double> > coords(graph);
   reader.readNodeMap("coords", coords);

demo/coloring.lgf

@@ -12 +12 @@
 (157, -150)     1       
 (-282, -149)    0       
-@undiredgeset 
+@uedgeset 
                 label   
 9       10      17      

demo/partitions.lgf

@@ -24 +24 @@
 -607.82         -246.651        2       
 -274            -131            1       
-@undiredgeset 
+@uedgeset 
                 label   
 12      23      15      

demo/topology_demo.cc

@@ -44 +44 @@
 
 void drawConnectedComponents() {
-  typedef UndirListGraph Graph;
+  typedef ListUGraph Graph;
   typedef Graph::Node Node;
 
@@ -50 +50 @@
   Graph::NodeMap<xy<double> > coords(graph);
 
-  UndirGraphReader<Graph>("undir_components.lgf", graph).
+  UGraphReader<Graph>("u_components.lgf", graph).
     readNodeMap("coordinates_x", xMap(coords)).
     readNodeMap("coordinates_y", yMap(coords)).
@@ -60 +60 @@
   connectedComponents(graph, compMap);
 
-  graphToEps(graph, "connected_components.eps").undir().
+  graphToEps(graph, "connected_components.eps").u().
     coords(coords).scaleToA4().enableParallel().
     parEdgeDist(20.0).edgeWidthScale(2.0).nodeScale(20.0).
@@ -98 +98 @@
 
 void drawNodeBiconnectedComponents() {
-  typedef UndirListGraph Graph;
+  typedef ListUGraph Graph;
   typedef Graph::Node Node;
-  typedef Graph::UndirEdge UndirEdge;
+  typedef Graph::UEdge UEdge;
 
   Graph graph;
   Graph::NodeMap<xy<double> > coords(graph);
 
-  UndirGraphReader<Graph>("undir_components.lgf", graph).
+  UGraphReader<Graph>("u_components.lgf", graph).
     readNodeMap("coordinates_x", xMap(coords)).
     readNodeMap("coordinates_y", yMap(coords)).
@@ -112 +112 @@
   ColorSet colorSet;
 
-  Graph::UndirEdgeMap<int> compMap(graph);
+  Graph::UEdgeMap<int> compMap(graph);
   Graph::NodeMap<bool> cutMap(graph);
   biNodeConnectedComponents(graph, compMap);
   biNodeConnectedCutNodes(graph, cutMap);
-  graphToEps(graph, "bi_node_connected_components.eps").undir().
+  graphToEps(graph, "bi_node_connected_components.eps").u().
     coords(coords).scaleToA4().enableParallel().
     parEdgeDist(20.0).edgeWidthScale(5.0).nodeScale(20.0).
@@ -127 +127 @@
 
 void drawEdgeBiconnectedComponents() {
-  typedef UndirListGraph Graph;
+  typedef ListUGraph Graph;
   typedef Graph::Node Node;
-  typedef Graph::UndirEdge UndirEdge;
+  typedef Graph::UEdge UEdge;
 
   Graph graph;
   Graph::NodeMap<xy<double> > coords(graph);
 
-  UndirGraphReader<Graph>("undir_components.lgf", graph).
+  UGraphReader<Graph>("u_components.lgf", graph).
     readNodeMap("coordinates_x", xMap(coords)).
     readNodeMap("coordinates_y", yMap(coords)).
@@ -142 +142 @@
 
   Graph::NodeMap<int> compMap(graph);
-  Graph::UndirEdgeMap<bool> cutMap(graph);
+  Graph::UEdgeMap<bool> cutMap(graph);
   biEdgeConnectedComponents(graph, compMap);
   biEdgeConnectedCutEdges(graph, cutMap);
 
-  graphToEps(graph, "bi_edge_connected_components.eps").undir().
+  graphToEps(graph, "bi_edge_connected_components.eps").u().
     coords(coords).scaleToA4().enableParallel().
     parEdgeDist(20.0).edgeWidthScale(2.0).nodeScale(20.0).
@@ -156 +156 @@
 
 void drawBipartitePartitions() {
-  typedef UndirListGraph Graph;
+  typedef ListUGraph Graph;
   typedef Graph::Node Node;
-  typedef Graph::UndirEdge UndirEdge;
+  typedef Graph::UEdge UEdge;
 
   Graph graph;
   Graph::NodeMap<xy<double> > coords(graph);
 
-  UndirGraphReader<Graph>("partitions.lgf", graph).
+  UGraphReader<Graph>("partitions.lgf", graph).
     readNodeMap("coordinates_x", xMap(coords)).
     readNodeMap("coordinates_y", yMap(coords)).
@@ -173 +173 @@
   bipartitePartitions(graph, partMap);
 
-  graphToEps(graph, "bipartite_partitions.eps").undir().
+  graphToEps(graph, "bipartite_partitions.eps").u().
     coords(coords).scaleToA4().enableParallel().
     parEdgeDist(20.0).edgeWidthScale(2.0).nodeScale(20.0).

demo/undir_components.lgf

@@ -44 +44 @@
 -689.204        -237.261        32      
 -567.302        43.6423 33      
-@undiredgeset 
+@uedgeset 
                 label   
 41      42      44      

doc/Makefile.am

@@ -20 +20 @@
         namespaces.dox \
         quicktour.dox \
-        undir_graphs.dox
+        ugraphs.dox
 
 html/index.html:

doc/graph_io.dox

@@ -318 +318 @@
 The specialization of writing is very similar to that of reading.
 
-\section undir Undirected graphs
-
-In a file describing an undirected graph (undir graph, for short) you find an
-\c undiredgeset section instead of the \c edgeset section. The first line of
+\section u Undirected graphs
+
+In a file describing an undirected graph (ugraph, for short) you find an
+\c uedgeset section instead of the \c edgeset section. The first line of
 the section describes the names of the maps on the undirected egdes and all
 next lines describe one undirected edge with the the incident nodes and the
@@ -331 +331 @@
 
 \code
-@undiredgeset
+@uedgeset
              label      capacity        +flow   -flow
 32   2       1          4.3             2.0     0.0
@@ -338 +338 @@
 \endcode
 
-The \c edges section is changed to \c undiredges section. This section
+The \c edges section is changed to \c uedges section. This section
 describes labeled edges and undirected edges. The directed edge label
 should start with a \c '+' or a \c '-' prefix to decide the direction
@@ -344 +344 @@
 
 \code
-@undiredges
-undiredge 1
+@uedges
+uedge 1
 +edge 5
 -back 5
@@ -353 +353 @@
 \ref lemon::GraphWriter "GraphWriter" which
 handle the undirected graphs. These classes are
-the \ref lemon::UndirGraphReader "UndirGraphReader"
-and \ref lemon::UndirGraphWriter "UndirGraphWriter".
-
-The \ref lemon::UndirGraphReader::readUndirEdgeMap() "readUndirEdgeMap()"
+the \ref lemon::UGraphReader "UGraphReader"
+and \ref lemon::UGraphWriter "UGraphWriter".
+
+The \ref lemon::UGraphReader::readUEdgeMap() "readUEdgeMap()"
 function reads an undirected map and the
-\ref lemon::UndirGraphReader::readUndirEdge() "readUndirEdge()"
+\ref lemon::UGraphReader::readUEdge() "readUEdge()"
 reads an undirected edge from the file, 
 
 \code
-reader.readUndirEdgeMap("capacity", capacityMap);
+reader.readUEdgeMap("capacity", capacityMap);
 reader.readEdgeMap("flow", flowMap);
 ...
-reader.readUndirEdge("undir_edge", undir_edge);
+reader.readUEdge("u_edge", u_edge);
 reader.readEdge("edge", edge);
 \endcode
@@ -440 +440 @@
 
 \code
-UndirListGraph network;
-UndirListGraph::UndirEdgeMap<double> capacity;
-ListEdgeSet<UndirListGraph> traffic(network);
-ListEdgeSet<UndirListGraph>::EdgeMap<double> request(network);
+ListUGraph network;
+ListUGraph::UEdgeMap<double> capacity;
+ListEdgeSet<ListUGraph> traffic(network);
+ListEdgeSet<ListUGraph>::EdgeMap<double> request(network);
 
 LemonReader reader(std::cin);
-NodeSetReader<UndirListGraph> nodesetReader(reader, network);
-UndirEdgeSetReader<UndirListGraph> 
-  undirEdgesetReader(reader, network, nodesetReader);
-undirEdgesetReader.readEdgeMap("capacity", capacity);
-EdgeSetReader<ListEdgeSet<UndirListGraph> > 
+NodeSetReader<ListUGraph> nodesetReader(reader, network);
+UEdgeSetReader<ListUGraph> 
+  uEdgesetReader(reader, network, nodesetReader);
+uEdgesetReader.readEdgeMap("capacity", capacity);
+EdgeSetReader<ListEdgeSet<ListUGraph> > 
   edgesetReader(reader, traffic, nodesetReader, "traffic");
 edgesetReader.readEdgeMap("request", request);
@@ -458 +458 @@
 
 Because both the \ref lemon::GraphReader "GraphReader"
-and the \ref lemon::UndirGraphReader "UndirGraphReader" can be converted
+and the \ref lemon::UGraphReader "UGraphReader" can be converted
 to \ref lemon::LemonReader "LemonReader"
 and it can resolve the label's of the items, the previous
-result can be achived with the \ref lemon::UndirGraphReader "UndirGraphReader"
+result can be achived with the \ref lemon::UGraphReader "UGraphReader"
 class, too.
 
 
 \code
-UndirListGraph network;
-UndirListGraph::UndirEdgeSet<double> capacity;
-ListEdgeSet<UndirListGraph> traffic(network);
-ListEdgeSet<UndirListGraph>::EdgeMap<double> request(network);
-
-UndirGraphReader<UndirListGraph> reader(std::cin, network);
+ListUGraph network;
+ListUGraph::UEdgeSet<double> capacity;
+ListEdgeSet<ListUGraph> traffic(network);
+ListEdgeSet<ListUGraph>::EdgeMap<double> request(network);
+
+UGraphReader<ListUGraph> reader(std::cin, network);
 reader.readEdgeMap("capacity", capacity);
-EdgeSetReader<ListEdgeSet<UndirListGraph> > 
+EdgeSetReader<ListEdgeSet<ListUGraph> > 
   edgesetReader(reader, traffic, reader, "traffic");
 edgesetReader.readEdgeMap("request", request);

doc/undir_graphs.dox

@@ -1 +1 @@
 /*!
 
-\page undir_graphs Undirected graph structures
+\page ugraphs Undirected graph structures
 
 The primary data structures of LEMON are the graph classes.

lemon/Makefile.am

@@ -91 +91 @@
         concept/graph.h \
         concept/graph_component.h \
-        concept/undir_graph.h \
+        concept/ugraph.h \
         concept/matrix_maps.h \
         concept/maps.h \

lemon/bits/alteration_notifier.h

@@ -443 +443 @@
 
   template <typename _Base> 
-  class AlterableUndirGraphExtender
+  class AlterableUGraphExtender
     : public AlterableGraphExtender<_Base> {
   public:
 
-    typedef AlterableUndirGraphExtender Graph;
+    typedef AlterableUGraphExtender Graph;
     typedef AlterableGraphExtender<_Base> Parent;
 
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
 
     /// The edge observer registry.
-    typedef AlterationNotifier<UndirEdge> UndirEdgeNotifier;
-
-  protected:
-
-    mutable UndirEdgeNotifier undir_edge_notifier;
+    typedef AlterationNotifier<UEdge> UEdgeNotifier;
+
+  protected:
+
+    mutable UEdgeNotifier u_edge_notifier;
 
   public:
 
     using Parent::getNotifier;
-    UndirEdgeNotifier& getNotifier(UndirEdge) const {
-      return undir_edge_notifier;
-    }
-
-    ~AlterableUndirGraphExtender() {
-      undir_edge_notifier.clear();
+    UEdgeNotifier& getNotifier(UEdge) const {
+      return u_edge_notifier;
+    }
+
+    ~AlterableUGraphExtender() {
+      u_edge_notifier.clear();
     }
   };
 
   template <typename _Base> 
-  class AlterableUndirEdgeSetExtender
+  class AlterableUEdgeSetExtender
     : public AlterableEdgeSetExtender<_Base> {
   public:
 
-    typedef AlterableUndirEdgeSetExtender Graph;
+    typedef AlterableUEdgeSetExtender Graph;
     typedef AlterableEdgeSetExtender<_Base> Parent;
 
-    typedef typename Parent::UndirEdge UndirEdge;
-
-    typedef AlterationNotifier<UndirEdge> UndirEdgeNotifier;
-
-  protected:
-
-    mutable UndirEdgeNotifier undir_edge_notifier;
+    typedef typename Parent::UEdge UEdge;
+
+    typedef AlterationNotifier<UEdge> UEdgeNotifier;
+
+  protected:
+
+    mutable UEdgeNotifier u_edge_notifier;
 
   public:
 
     using Parent::getNotifier;
-    UndirEdgeNotifier& getNotifier(UndirEdge) const {
-      return undir_edge_notifier;
-    }
-
-    ~AlterableUndirEdgeSetExtender() {
-      undir_edge_notifier.clear();
+    UEdgeNotifier& getNotifier(UEdge) const {
+      return u_edge_notifier;
+    }
+
+    ~AlterableUEdgeSetExtender() {
+      u_edge_notifier.clear();
     }
   };
@@ -502 +502 @@
 
   template <typename _Base>
-  class AlterableUndirBipartiteGraphExtender : public _Base {
+  class AlterableUBipartiteGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef AlterableUndirBipartiteGraphExtender Graph;
+    typedef AlterableUBipartiteGraphExtender Graph;
   
     typedef typename Parent::Node Node;
@@ -512 +512 @@
     typedef typename Parent::UpperNode UpperNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
   
   
@@ -519 +519 @@
     typedef AlterationNotifier<UpperNode> UpperNodeNotifier;
     typedef AlterationNotifier<Edge> EdgeNotifier;
-    typedef AlterationNotifier<UndirEdge> UndirEdgeNotifier;
+    typedef AlterationNotifier<UEdge> UEdgeNotifier;
 
   protected:
@@ -527 +527 @@
     mutable UpperNodeNotifier upperNodeNotifier;
     mutable EdgeNotifier edgeNotifier;
-    mutable UndirEdgeNotifier undirEdgeNotifier;
+    mutable UEdgeNotifier uEdgeNotifier;
 
   public:
@@ -547 +547 @@
     }
 
-    UndirEdgeNotifier& getNotifier(UndirEdge) const {
-      return undirEdgeNotifier;
-    }
-
-    ~AlterableUndirBipartiteGraphExtender() {
+    UEdgeNotifier& getNotifier(UEdge) const {
+      return uEdgeNotifier;
+    }
+
+    ~AlterableUBipartiteGraphExtender() {
       nodeNotifier.clear();
       lowerNodeNotifier.clear();
       upperNodeNotifier.clear();
       edgeNotifier.clear();
-      undirEdgeNotifier.clear();
+      uEdgeNotifier.clear();
     }
 

lemon/bits/clearable_graph_extender.h

@@ -43 +43 @@
 
   template <typename _Base> 
-  class ClearableUndirGraphExtender : public _Base {
+  class ClearableUGraphExtender : public _Base {
   public:
 
-    typedef ClearableUndirGraphExtender Graph;
+    typedef ClearableUGraphExtender Graph;
     typedef _Base Parent;
     typedef typename Parent::Node Node;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
     typedef typename Parent::Edge Edge;
 
     void clear() {
       Parent::getNotifier(Node()).clear();
-      Parent::getNotifier(UndirEdge()).clear();
+      Parent::getNotifier(UEdge()).clear();
       Parent::getNotifier(Edge()).clear();
       Parent::clear();
@@ -61 +61 @@
 
   template <typename _Base> 
-  class ClearableUndirEdgeSetExtender : public _Base {
+  class ClearableUEdgeSetExtender : public _Base {
   public:
 
-    typedef ClearableUndirEdgeSetExtender Graph;
+    typedef ClearableUEdgeSetExtender Graph;
     typedef _Base Parent;
     typedef typename Parent::Node Node;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
     typedef typename Parent::Edge Edge;
 
     void clear() {
-      Parent::getNotifier(UndirEdge()).clear();
+      Parent::getNotifier(UEdge()).clear();
       Parent::getNotifier(Edge()).clear();
       Parent::clear();
@@ -80 +80 @@
 
   template <typename _Base>
-  class ClearableUndirBipartiteGraphExtender : public _Base {
+  class ClearableUBipartiteGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef ClearableUndirBipartiteGraphExtender Graph;
+    typedef ClearableUBipartiteGraphExtender Graph;
 
     typedef typename Parent::Node Node;
@@ -90 +90 @@
     typedef typename Parent::UpperNode UpperNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
 
     void clear() {
       Parent::getNotifier(Edge()).clear();
-      Parent::getNotifier(UndirEdge()).clear();
+      Parent::getNotifier(UEdge()).clear();
       Parent::getNotifier(Node()).clear();
       Parent::getNotifier(LowerNode()).clear();

lemon/bits/default_map.h

@@ -267 +267 @@
   /// \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 +310 @@
   /// \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 +353 @@
 
   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 +363 @@
     typedef typename Parent::LowerNode LowerNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
     
     template <typename _Value>
@@ -369 +369 @@
       : public IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > 
       Parent;
@@ -406 +406 @@
       : public IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > 
       Parent;
@@ -444 +444 @@
     class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
 
       typedef Node Key;
@@ -524 +524 @@
       : public IterableMapExtender<NodeMapBase<_Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
     
@@ -562 +562 @@
       : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
     public:
-      typedef MappableUndirBipartiteGraphExtender Graph;
+      typedef MappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     
@@ -587 +587 @@
 
     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]);

lemon/bits/erasable_graph_extender.h

@@ -63 +63 @@
 
   template <typename _Base> 
-  class ErasableUndirGraphExtender : public _Base {
+  class ErasableUGraphExtender : public _Base {
   public:
 
-    typedef ErasableUndirGraphExtender Graph;
+    typedef ErasableUGraphExtender Graph;
     typedef _Base Parent;
 
     typedef typename Parent::Node Node;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
     typedef typename Parent::Edge Edge;
 
@@ -85 +85 @@
     }
     
-    void erase(const UndirEdge& uedge) {
+    void erase(const UEdge& uedge) {
       std::vector<Edge> edges;
       edges.push_back(Parent::direct(uedge,true));
       edges.push_back(Parent::direct(uedge,false));
       Parent::getNotifier(Edge()).erase(edges);
-      Parent::getNotifier(UndirEdge()).erase(uedge);
+      Parent::getNotifier(UEdge()).erase(uedge);
       Parent::erase(uedge);
     }
@@ -97 +97 @@
 
   template <typename _Base> 
-  class ErasableUndirEdgeSetExtender : public _Base {
+  class ErasableUEdgeSetExtender : public _Base {
   public:
 
-    typedef ErasableUndirEdgeSetExtender Graph;
+    typedef ErasableUEdgeSetExtender Graph;
     typedef _Base Parent;
 
     typedef typename Parent::Node Node;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
     typedef typename Parent::Edge Edge;
 
-    void erase(const UndirEdge& uedge) {
+    void erase(const UEdge& uedge) {
       std::vector<Edge> edges;
       edges.push_back(Parent::direct(uedge,true));
       edges.push_back(Parent::direct(uedge,false));
       Parent::getNotifier(Edge()).erase(edges);
-      Parent::getNotifier(UndirEdge()).erase(uedge);
+      Parent::getNotifier(UEdge()).erase(uedge);
       Parent::erase(uedge);
     }

lemon/bits/extendable_graph_extender.h

@@ -49 +49 @@
 
   template <typename _Base> 
-  class ExtendableUndirGraphExtender : public _Base {
+  class ExtendableUGraphExtender : public _Base {
   public:
 
-    typedef ExtendableUndirGraphExtender Graph;
+    typedef ExtendableUGraphExtender Graph;
     typedef _Base Parent;
 
     typedef typename Parent::Node Node;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
 
     Node addNode() {
@@ -65 +65 @@
     }
 
-    UndirEdge addEdge(const Node& from, const Node& to) {
-      UndirEdge uedge = Parent::addEdge(from, to);
-      Parent::getNotifier(UndirEdge()).add(uedge);
+    UEdge addEdge(const Node& from, const Node& to) {
+      UEdge uedge = Parent::addEdge(from, to);
+      Parent::getNotifier(UEdge()).add(uedge);
 
       std::vector<Edge> edges;
@@ -80 +80 @@
 
   template <typename _Base> 
-  class ExtendableUndirEdgeSetExtender : public _Base {
+  class ExtendableUEdgeSetExtender : public _Base {
   public:
 
-    typedef ExtendableUndirEdgeSetExtender Graph;
+    typedef ExtendableUEdgeSetExtender Graph;
     typedef _Base Parent;
 
     typedef typename Parent::Node Node;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
 
-    UndirEdge addEdge(const Node& from, const Node& to) {
-      UndirEdge uedge = Parent::addEdge(from, to);
-      Parent::getNotifier(UndirEdge()).add(uedge);
+    UEdge addEdge(const Node& from, const Node& to) {
+      UEdge uedge = Parent::addEdge(from, to);
+      Parent::getNotifier(UEdge()).add(uedge);
 
       std::vector<Edge> edges;
@@ -106 +106 @@
 
   template <typename _Base>
-  class ExtendableUndirBipartiteGraphExtender : public _Base {
+  class ExtendableUBipartiteGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef ExtendableUndirBipartiteGraphExtender Graph;
+    typedef ExtendableUBipartiteGraphExtender Graph;
   
     typedef typename Parent::Node Node;
@@ -116 +116 @@
     typedef typename Parent::UpperNode UpperNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
   
     Node addUpperNode() {
@@ -132 +132 @@
     }
   
-    UndirEdge addEdge(const Node& source, const Node& target) {
-      UndirEdge undiredge = Parent::addEdge(source, target);
-      Parent::getNotifier(UndirEdge()).add(undiredge);
+    UEdge addEdge(const Node& source, const Node& target) {
+      UEdge uedge = Parent::addEdge(source, target);
+      Parent::getNotifier(UEdge()).add(uedge);
     
       std::vector<Edge> edges;
-      edges.push_back(Parent::direct(undiredge, true));
-      edges.push_back(Parent::direct(undiredge, false));
+      edges.push_back(Parent::direct(uedge, true));
+      edges.push_back(Parent::direct(uedge, false));
       Parent::getNotifier(Edge()).add(edges);
     
-      return undiredge;
+      return uedge;
     }
 

lemon/bits/graph_extender.h

@@ -62 +62 @@
 
   template <typename _Base>
-  class UndirGraphExtender : public _Base {
+  class UGraphExtender : public _Base {
     typedef _Base Parent;
-    typedef UndirGraphExtender Graph;
+    typedef UGraphExtender Graph;
 
   public:
 
-    typedef typename Parent::Edge UndirEdge;
+    typedef typename Parent::Edge UEdge;
     typedef typename Parent::Node Node;
 
-    class Edge : public UndirEdge {
-      friend class UndirGraphExtender;
+    class Edge : public UEdge {
+      friend class UGraphExtender;
 
     protected:
@@ -79 +79 @@
       bool forward;
 
-      Edge(const UndirEdge &ue, bool _forward) :
-        UndirEdge(ue), forward(_forward) {}
+      Edge(const UEdge &ue, bool _forward) :
+        UEdge(ue), forward(_forward) {}
 
     public:
@@ -86 +86 @@
 
       /// Invalid edge constructor
-      Edge(Invalid i) : UndirEdge(i), forward(true) {}
+      Edge(Invalid i) : UEdge(i), forward(true) {}
 
       bool operator==(const Edge &that) const {
-        return forward==that.forward && UndirEdge(*this)==UndirEdge(that);
+        return forward==that.forward && UEdge(*this)==UEdge(that);
       }
       bool operator!=(const Edge &that) const {
-        return forward!=that.forward || UndirEdge(*this)!=UndirEdge(that);
+        return forward!=that.forward || UEdge(*this)!=UEdge(that);
       }
       bool operator<(const Edge &that) const {
         return forward<that.forward ||
-          (!(that.forward<forward) && UndirEdge(*this)<UndirEdge(that));
+          (!(that.forward<forward) && UEdge(*this)<UEdge(that));
       }
     };
@@ -127 +127 @@
     }
 
-    Node oppositeNode(const Node &n, const UndirEdge &e) const {
+    Node oppositeNode(const Node &n, const UEdge &e) const {
       if( n == Parent::source(e))
         return Parent::target(e);
@@ -138 +138 @@
     /// \brief Directed edge from an undirected edge and a source node.
     ///
-    /// Returns a (directed) Edge corresponding to the specified UndirEdge
+    /// Returns a (directed) Edge corresponding to the specified UEdge
     /// and source Node.
     ///
-    Edge direct(const UndirEdge &ue, const Node &s) const {
+    Edge direct(const UEdge &ue, const Node &s) const {
       return Edge(ue, s == source(ue));
     }
@@ -147 +147 @@
     /// \brief Directed edge from an undirected edge.
     ///
-    /// Returns a directed edge corresponding to the specified UndirEdge.
+    /// Returns a directed edge corresponding to the specified UEdge.
     /// If the given bool is true the given undirected edge and the
     /// returned edge have the same source node.
-    Edge direct(const UndirEdge &ue, bool d) const {
+    Edge direct(const UEdge &ue, bool d) const {
       return Edge(ue, d);
     }
@@ -183 +183 @@
     void firstOut(Edge &e, const Node &n) const {
       Parent::firstIn(e,n);
-      if( UndirEdge(e) != INVALID ) {
+      if( UEdge(e) != INVALID ) {
         e.forward = false;
       }
@@ -195 +195 @@
         Node n = Parent::target(e);
         Parent::nextIn(e);
-        if( UndirEdge(e) == INVALID ) {
+        if( UEdge(e) == INVALID ) {
           Parent::firstOut(e, n);
           e.forward = true;
@@ -207 +207 @@
     void firstIn(Edge &e, const Node &n) const {
       Parent::firstOut(e,n);
-      if( UndirEdge(e) != INVALID ) {
+      if( UEdge(e) != INVALID ) {
         e.forward = false;
       }
@@ -219 +219 @@
         Node n = Parent::source(e);
         Parent::nextOut(e);
-        if( UndirEdge(e) == INVALID ) {
+        if( UEdge(e) == INVALID ) {
           Parent::firstIn(e, n);
           e.forward = true;
@@ -229 +229 @@
     }
 
-    void firstInc(UndirEdge &e, const Node &n) const {
+    void firstInc(UEdge &e, const Node &n) const {
       Parent::firstOut(e, n);
       if (e != INVALID) return;
       Parent::firstIn(e, n);
     }
-    void nextInc(UndirEdge &e, const Node &n) const {
+    void nextInc(UEdge &e, const Node &n) const {
       if (Parent::source(e) == n) {
         Parent::nextOut(e);
@@ -244 +244 @@
     }
 
-    void firstInc(UndirEdge &e, bool &d, const Node &n) const {
+    void firstInc(UEdge &e, bool &d, const Node &n) const {
       d = true;
       Parent::firstOut(e, n);
@@ -251 +251 @@
       Parent::firstIn(e, n);
     }
-    void nextInc(UndirEdge &e, bool &d) const {
+    void nextInc(UEdge &e, bool &d) const {
       if (d) {
         Node s = Parent::source(e);
@@ -276 +276 @@
     }
 
-    int id(const UndirEdge &e) const {
+    int id(const UEdge &e) const {
       return Parent::id(e);
     }
@@ -292 +292 @@
     }
 
-    int maxUndirEdgeId() const {
+    int maxUEdgeId() const {
       return Parent::maxEdgeId();
     }
@@ -303 +303 @@
       return maxEdgeId();
     }
-    int maxId(UndirEdge) const {
-      return maxUndirEdgeId();
+    int maxId(UEdge) const {
+      return maxUEdgeId();
     }
 
@@ -311 +311 @@
     }
 
-    int undirEdgeNum() const {
+    int uEdgeNum() const {
       return Parent::edgeNum();
     }
@@ -323 +323 @@
     }
 
-    UndirEdge undirEdgeFromId(int id) const {
+    UEdge uEdgeFromId(int id) const {
       return Parent::edgeFromId(id >> 1);
     }
@@ -335 +335 @@
     }
 
-    UndirEdge fromId(int id, UndirEdge) const {
-      return undirEdgeFromId(id);
+    UEdge fromId(int id, UEdge) const {
+      return uEdgeFromId(id);
     }
 
@@ -342 +342 @@
     Edge findEdge(Node source, Node target, Edge prev) const {
       if (prev == INVALID) {
-        UndirEdge edge = Parent::findEdge(source, target);
+        UEdge edge = Parent::findEdge(source, target);
         if (edge != INVALID) return direct(edge, true);
         edge = Parent::findEdge(target, source);
         if (edge != INVALID) return direct(edge, false);
       } else if (direction(prev)) {
-        UndirEdge edge = Parent::findEdge(source, target, prev);
+        UEdge edge = Parent::findEdge(source, target, prev);
         if (edge != INVALID) return direct(edge, true);
         edge = Parent::findEdge(target, source);
         if (edge != INVALID) return direct(edge, false);        
       } else {
-        UndirEdge edge = Parent::findEdge(target, source, prev);
+        UEdge edge = Parent::findEdge(target, source, prev);
         if (edge != INVALID) return direct(edge, false);              
       }
@@ -358 +358 @@
     }
 
-    UndirEdge findUndirEdge(Node source, Node target, UndirEdge prev) const {
+    UEdge findUEdge(Node source, Node target, UEdge prev) const {
       if (prev == INVALID) {
-        UndirEdge edge = Parent::findEdge(source, target);
+        UEdge edge = Parent::findEdge(source, target);
         if (edge != INVALID) return edge;
         edge = Parent::findEdge(target, source);
         if (edge != INVALID) return edge;
       } else if (Parent::source(prev) == source) {
-        UndirEdge edge = Parent::findEdge(source, target, prev);
+        UEdge edge = Parent::findEdge(source, target, prev);
         if (edge != INVALID) return edge;
         edge = Parent::findEdge(target, source);
         if (edge != INVALID) return edge;       
       } else {
-        UndirEdge edge = Parent::findEdge(target, source, prev);
+        UEdge edge = Parent::findEdge(target, source, prev);
         if (edge != INVALID) return edge;             
       }
@@ -380 +380 @@
 
   template <typename _Base>
-  class UndirBipartiteGraphExtender : public _Base {
+  class UBipartiteGraphExtender : public _Base {
   public:
     typedef _Base Parent;
-    typedef UndirBipartiteGraphExtender Graph;
+    typedef UBipartiteGraphExtender Graph;
 
     typedef typename Parent::Node Node;
-    typedef typename Parent::Edge UndirEdge;
+    typedef typename Parent::Edge UEdge;
 
     using Parent::first;
@@ -393 +393 @@
     using Parent::id;
 
-    Node source(const UndirEdge& edge) const {
+    Node source(const UEdge& edge) const {
       return upperNode(edge);
     }
-    Node target(const UndirEdge& edge) const {
+    Node target(const UEdge& edge) const {
       return lowerNode(edge);
     }
 
-    void firstInc(UndirEdge& edge, bool& direction, const Node& node) const {
+    void firstInc(UEdge& edge, bool& direction, const Node& node) const {
       if (Parent::upper(node)) {
         Parent::firstDown(edge, node);
@@ -406 +406 @@
       } else {
         Parent::firstUp(edge, node);
-        direction = static_cast<UndirEdge&>(edge) == INVALID;
-      }
-    }
-    void nextInc(UndirEdge& edge, bool& direction) const {
+        direction = static_cast<UEdge&>(edge) == INVALID;
+      }
+    }
+    void nextInc(UEdge& edge, bool& direction) const {
       if (direction) {
         Parent::nextDown(edge);
@@ -418 +418 @@
     }
 
-    int maxUndirEdgeId() const {
+    int maxUEdgeId() const {
       return Parent::maxEdgeId();
     }
 
-    UndirEdge undirEdgeFromId(int id) const {
+    UEdge uEdgeFromId(int id) const {
       return Parent::edgeFromId(id);
     }
 
-    class Edge : public UndirEdge {
-      friend class UndirBipartiteGraphExtender;
+    class Edge : public UEdge {
+      friend class UBipartiteGraphExtender;
     protected:
       bool forward;
 
-      Edge(const UndirEdge& edge, bool _forward)
-        : UndirEdge(edge), forward(_forward) {}
+      Edge(const UEdge& edge, bool _forward)
+        : UEdge(edge), forward(_forward) {}
 
     public:
       Edge() {}
-      Edge (Invalid) : UndirEdge(INVALID), forward(true) {}
+      Edge (Invalid) : UEdge(INVALID), forward(true) {}
       bool operator==(const Edge& i) const {
-        return UndirEdge::operator==(i) && forward == i.forward;
+        return UEdge::operator==(i) && forward == i.forward;
       }
       bool operator!=(const Edge& i) const {
-        return UndirEdge::operator!=(i) || forward != i.forward;
+        return UEdge::operator!=(i) || forward != i.forward;
       }
       bool operator<(const Edge& i) const {
-        return UndirEdge::operator<(i) || 
-          (!(i.forward<forward) && UndirEdge(*this)<UndirEdge(i));
+        return UEdge::operator<(i) || 
+          (!(i.forward<forward) && UEdge(*this)<UEdge(i));
       }
     };
 
     void first(Edge& edge) const {
-      Parent::first(static_cast<UndirEdge&>(edge));
+      Parent::first(static_cast<UEdge&>(edge));
       edge.forward = true;
     }
@@ -456 +456 @@
     void next(Edge& edge) const {
       if (!edge.forward) {
-        Parent::next(static_cast<UndirEdge&>(edge));
+        Parent::next(static_cast<UEdge&>(edge));
       }
       edge.forward = !edge.forward;
@@ -467 +467 @@
       } else {
         Parent::firstUp(edge, node);
-        edge.forward = static_cast<UndirEdge&>(edge) == INVALID;
+        edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
     }
@@ -475 +475 @@
       } else {
         Parent::nextUp(edge);
-        edge.forward = static_cast<UndirEdge&>(edge) == INVALID;
+        edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
     }
@@ -485 +485 @@
       } else {
         Parent::firstDown(edge, node);
-        edge.forward = static_cast<UndirEdge&>(edge) == INVALID;
+        edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
     }
@@ -493 +493 @@
       } else {
         Parent::nextDown(edge);
-        edge.forward = static_cast<UndirEdge&>(edge) == INVALID;
+        edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
     }
@@ -508 +508 @@
     }
 
-    Edge direct(const UndirEdge& edge, const Node& node) const {
+    Edge direct(const UEdge& edge, const Node& node) const {
       return Edge(edge, node == Parent::source(edge));
     }
 
-    Edge direct(const UndirEdge& edge, bool direction) const {
+    Edge direct(const UEdge& edge, bool direction) const {
       return Edge(edge, direction);
     }
 
-    Node oppositeNode(const UndirEdge& edge, const Node& node) const {
+    Node oppositeNode(const UEdge& edge, const Node& node) const {
       return source(edge) == node ? 
         target(edge) : source(edge);
@@ -529 +529 @@
     }
     Edge edgeFromId(int id) const {
-      return Edge(Parent::fromId(id >> 1, UndirEdge()), (id & 1) == 0);
+      return Edge(Parent::fromId(id >> 1, UEdge()), (id & 1) == 0);
     }
     int maxEdgeId() const {
-      return (Parent::maxId(UndirEdge()) << 1) + 1;
+      return (Parent::maxId(UEdge()) << 1) + 1;
     }
 
     class UpperNode : public Node {
-      friend class UndirBipartiteGraphExtender;
+      friend class UBipartiteGraphExtender;
     public:
       UpperNode() {}
@@ -558 +558 @@
 
     class LowerNode : public Node {
-      friend class UndirBipartiteGraphExtender;
+      friend class UBipartiteGraphExtender;
     public:
       LowerNode() {}
@@ -593 +593 @@
       return maxEdgeId();
     }
-    int maxId(UndirEdge) const {
-      return maxUndirEdgeId();
+    int maxId(UEdge) const {
+      return maxUEdgeId();
     }
 
@@ -610 +610 @@
       return edgeFromId(id);
     }
-    UndirEdge fromId(int id, UndirEdge) const {
-      return undirEdgeFromId(id);
+    UEdge fromId(int id, UEdge) const {
+      return uEdgeFromId(id);
     }
 

lemon/bits/iterable_graph_extender.h

@@ -17 +17 @@
     ///
     ///\bug Should it be here?
-    typedef False UndirTag;
+    typedef False UTag;
 
     typedef _Base Parent;
@@ -175 +175 @@
   
   template <typename _Base>
-  class IterableUndirGraphExtender : public IterableGraphExtender<_Base> {
+  class IterableUGraphExtender : public IterableGraphExtender<_Base> {
   public:
 
@@ -185 +185 @@
     ///\bug Should be tested in the concept checker whether it is defined
     ///correctly.
-    typedef True UndirTag;
+    typedef True UTag;
 
     typedef IterableGraphExtender<_Base> Parent;
-    typedef IterableUndirGraphExtender<_Base> Graph;
+    typedef IterableUGraphExtender<_Base> Graph;
     typedef typename Parent::Node Node;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
-
-    class UndirEdgeIt : public Parent::UndirEdge { 
-      const Graph* graph;
-    public:
-
-      UndirEdgeIt() { }
-
-      UndirEdgeIt(Invalid i) : UndirEdge(i) { }
-
-      explicit UndirEdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<UndirEdge*>(this));
-      }
-
-      UndirEdgeIt(const Graph& _graph, const UndirEdge& e) : 
-        UndirEdge(e), graph(&_graph) { }
-
-      UndirEdgeIt& operator++() { 
+    typedef typename Parent::UEdge UEdge;
+
+    class UEdgeIt : public Parent::UEdge { 
+      const Graph* graph;
+    public:
+
+      UEdgeIt() { }
+
+      UEdgeIt(Invalid i) : UEdge(i) { }
+
+      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
+        _graph.first(*static_cast<UEdge*>(this));
+      }
+
+      UEdgeIt(const Graph& _graph, const UEdge& e) : 
+        UEdge(e), graph(&_graph) { }
+
+      UEdgeIt& operator++() { 
         graph->next(*this);
         return *this; 
@@ -215 +215 @@
     };
 
-    class IncEdgeIt : public Parent::UndirEdge { 
+    class IncEdgeIt : public Parent::UEdge { 
       const Graph* graph;
       bool direction;
-      friend class IterableUndirGraphExtender;
+      friend class IterableUGraphExtender;
     public:
 
       IncEdgeIt() { }
 
-      IncEdgeIt(Invalid i) : UndirEdge(i), direction(false) { }
+      IncEdgeIt(Invalid i) : UEdge(i), direction(false) { }
 
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
@@ -229 +229 @@
       }
 
-      IncEdgeIt(const Graph& _graph, const UndirEdge &ue, const Node &n)
-        : graph(&_graph), UndirEdge(ue) {
+      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+        : graph(&_graph), UEdge(ue) {
         direction = (_graph.source(ue) == n);
       }
@@ -259 +259 @@
     ///
     /// Gives back the opposite on the given undirected edge.
-    Node oppositeNode(const Node& n, const UndirEdge& e) const {
+    Node oppositeNode(const Node& n, const UEdge& e) const {
       if (Parent::source(e) == n) {
         return Parent::target(e);
@@ -271 +271 @@
 
   template <typename _Base>
-  class IterableUndirBipartiteGraphExtender : public _Base {
+  class IterableUBipartiteGraphExtender : public _Base {
   public:
     typedef _Base Parent;
-    typedef IterableUndirBipartiteGraphExtender Graph;
+    typedef IterableUBipartiteGraphExtender Graph;
    
     typedef typename Parent::Node Node;
@@ -280 +280 @@
     typedef typename Parent::LowerNode LowerNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
   
     class NodeIt : public Node { 
@@ -305 +305 @@
 
     class UpperNodeIt : public Node { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -327 +327 @@
 
     class LowerNodeIt : public Node { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -349 +349 @@
 
     class EdgeIt : public Edge { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -371 +371 @@
     };
 
-    class UndirEdgeIt : public UndirEdge { 
-      friend class IterableUndirBipartiteGraphExtender;
-      const Graph* graph;
-    public:
-    
-      UndirEdgeIt() { }
-    
-      UndirEdgeIt(Invalid i) : UndirEdge(INVALID) { }
-    
-      explicit UndirEdgeIt(const Graph& _graph) : graph(&_graph) {
-        graph->first(static_cast<UndirEdge&>(*this));
-      }
-
-      UndirEdgeIt(const Graph& _graph, const UndirEdge& edge) 
-        : UndirEdge(edge), graph(&_graph) { }
-    
-      UndirEdgeIt& operator++() { 
+    class UEdgeIt : public UEdge { 
+      friend class IterableUBipartiteGraphExtender;
+      const Graph* graph;
+    public:
+    
+      UEdgeIt() { }
+    
+      UEdgeIt(Invalid i) : UEdge(INVALID) { }
+    
+      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
+        graph->first(static_cast<UEdge&>(*this));
+      }
+
+      UEdgeIt(const Graph& _graph, const UEdge& edge) 
+        : UEdge(edge), graph(&_graph) { }
+    
+      UEdgeIt& operator++() { 
         graph->next(*this);
         return *this; 
@@ -394 +394 @@
 
     class OutEdgeIt : public Edge { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -419 +419 @@
 
     class InEdgeIt : public Edge { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -470 +470 @@
     }
   
-    class IncEdgeIt : public Parent::UndirEdge { 
-      friend class IterableUndirBipartiteGraphExtender;
+    class IncEdgeIt : public Parent::UEdge { 
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
       bool direction;
@@ -478 +478 @@
       IncEdgeIt() { }
     
-      IncEdgeIt(Invalid i) : UndirEdge(i), direction(true) { }
+      IncEdgeIt(Invalid i) : UEdge(i), direction(true) { }
     
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
@@ -484 +484 @@
       }
 
-      IncEdgeIt(const Graph& _graph, const UndirEdge &ue, const Node &n)
-        : graph(&_graph), UndirEdge(ue) {
+      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+        : graph(&_graph), UEdge(ue) {
         direction = (graph->source(ue) == n);
       }

lemon/bits/static_map.h

@@ -306 +306 @@
   /// \e
   template <typename _Base> 
-  class StaticMappableUndirGraphExtender : 
+  class StaticMappableUGraphExtender : 
     public StaticMappableGraphExtender<_Base> {
   public:
 
-    typedef StaticMappableUndirGraphExtender Graph;
+    typedef StaticMappableUGraphExtender Graph;
     typedef StaticMappableGraphExtender<_Base> Parent;
 
-    typedef typename Parent::UndirEdge UndirEdge;
-
-    template <typename _Value>
-    class UndirEdgeMap 
-      : public IterableMapExtender<StaticMap<Graph, UndirEdge, _Value> > {
-    public:
-      typedef StaticMappableUndirGraphExtender Graph;
+    typedef typename Parent::UEdge UEdge;
+
+    template <typename _Value>
+    class UEdgeMap 
+      : public IterableMapExtender<StaticMap<Graph, UEdge, _Value> > {
+    public:
+      typedef StaticMappableUGraphExtender Graph;
       typedef IterableMapExtender<
-        StaticMap<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;
+        StaticMap<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]);
@@ -347 +347 @@
 
   template <typename _Base>
-  class StaticMappableUndirBipartiteGraphExtender : public _Base {
+  class StaticMappableUBipartiteGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef StaticMappableUndirBipartiteGraphExtender Graph;
+    typedef StaticMappableUBipartiteGraphExtender Graph;
 
     typedef typename Parent::Node Node;
@@ -357 +357 @@
     typedef typename Parent::LowerNode LowerNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
     
     template <typename _Value>
@@ -363 +363 @@
       : public IterableMapExtender<StaticMap<Graph, UpperNode, _Value> > {
     public:
-      typedef StaticMappableUndirBipartiteGraphExtender Graph;
+      typedef StaticMappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<StaticMap<Graph, UpperNode, _Value> > 
       Parent;
@@ -400 +400 @@
       : public IterableMapExtender<StaticMap<Graph, LowerNode, _Value> > {
     public:
-      typedef StaticMappableUndirBipartiteGraphExtender Graph;
+      typedef StaticMappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<StaticMap<Graph, LowerNode, _Value> > 
       Parent;
@@ -438 +438 @@
     class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
     public:
-      typedef StaticMappableUndirBipartiteGraphExtender Graph;
+      typedef StaticMappableUBipartiteGraphExtender Graph;
 
       typedef Node Key;
@@ -518 +518 @@
       : public IterableMapExtender<NodeMapBase<_Value> > {
     public:
-      typedef StaticMappableUndirBipartiteGraphExtender Graph;
+      typedef StaticMappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
     
@@ -556 +556 @@
       : public IterableMapExtender<StaticMap<Graph, Edge, _Value> > {
     public:
-      typedef StaticMappableUndirBipartiteGraphExtender Graph;
+      typedef StaticMappableUBipartiteGraphExtender Graph;
       typedef IterableMapExtender<StaticMap<Graph, Edge, _Value> > Parent;
     
@@ -581 +581 @@
 
     template <typename _Value>
-    class UndirEdgeMap 
-      : public IterableMapExtender<StaticMap<Graph, UndirEdge, _Value> > {
-    public:
-      typedef StaticMappableUndirBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<StaticMap<Graph, UndirEdge, _Value> > 
+    class UEdgeMap 
+      : public IterableMapExtender<StaticMap<Graph, UEdge, _Value> > {
+    public:
+      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef IterableMapExtender<StaticMap<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]);

lemon/concept/graph.h

@@ -43 +43 @@
     public:
 
-      typedef False UndirTag;
+      typedef False UTag;
       
       typedef BaseGraphComponent::Node Node;
@@ -124 +124 @@
       ///\todo undocumented
       ///
-      typedef False UndirTag;
+      typedef False UTag;
 
       /// Defalult constructor.

lemon/concept/graph_component.h

@@ -35 +35 @@
     /// Skeleton class for graph Node and Edge types
 
-    /// This class describes the interface of Node and Edge (and UndirEdge
+    /// This class describes the interface of Node and Edge (and UEdge
     /// in undirected graphs) subtypes of graph types.
     ///

lemon/concept/ugraph.h

@@ -1 +1 @@
 /* -*- C++ -*-
  *
- * lemon/concept/undir_graph_component.h - Part of LEMON, a generic
+ * lemon/concept/ugraph_component.h - Part of LEMON, a generic
  * C++ optimization library
  *
@@ -34 +34 @@
 
 //     /// Skeleton class which describes an edge with direction in \ref
-//     /// UndirGraph "undirected graph".
-    template <typename UndirGraph>
-    class UndirGraphEdge : public UndirGraph::UndirEdge {
-      typedef typename UndirGraph::UndirEdge UndirEdge;
-      typedef typename UndirGraph::Node Node;
+//     /// UGraph "undirected graph".
+    template <typename UGraph>
+    class UGraphEdge : public UGraph::UEdge {
+      typedef typename UGraph::UEdge UEdge;
+      typedef typename UGraph::Node Node;
     public:
 
       /// \e
-      UndirGraphEdge() {}
+      UGraphEdge() {}
 
       /// \e
-      UndirGraphEdge(const UndirGraphEdge& e) : UndirGraph::UndirEdge(e) {}
+      UGraphEdge(const UGraphEdge& e) : UGraph::UEdge(e) {}
 
       /// \e
-      UndirGraphEdge(Invalid) {}
+      UGraphEdge(Invalid) {}
 
       /// \brief Directed edge from undirected edge and a source node.
@@ -55 +55 @@
       ///
       /// \note You have to specify the graph for this constructor.
-      UndirGraphEdge(const UndirGraph &g,
-                     UndirEdge undir_edge, Node n) {
-        ignore_unused_variable_warning(undir_edge);
+      UGraphEdge(const UGraph &g,
+                     UEdge u_edge, Node n) {
+        ignore_unused_variable_warning(u_edge);
         ignore_unused_variable_warning(g);
         ignore_unused_variable_warning(n);
@@ -63 +63 @@
 
       /// \e
-      UndirGraphEdge& operator=(UndirGraphEdge) { return *this; }
+      UGraphEdge& operator=(UGraphEdge) { return *this; }
 
       /// \e
-      bool operator==(UndirGraphEdge) const { return true; }
+      bool operator==(UGraphEdge) const { return true; }
       /// \e
-      bool operator!=(UndirGraphEdge) const { return false; }
+      bool operator!=(UGraphEdge) const { return false; }
 
       /// \e
-      bool operator<(UndirGraphEdge) const { return false; }
+      bool operator<(UGraphEdge) const { return false; }
 
       template <typename Edge>
@@ -80 +80 @@
         void const_constraints() const {
           /// \bug This should be is_base_and_derived ...
-          UndirEdge ue = e;
+          UEdge ue = e;
           ue = e;
 
@@ -87 +87 @@
         }
         Edge e;
-        UndirEdge ue;
-        UndirGraph graph;
+        UEdge ue;
+        UGraph graph;
         Node n;
       };
@@ -94 +94 @@
     
 
-    struct BaseIterableUndirGraphConcept {
+    struct BaseIterableUGraphConcept {
 
       template <typename Graph>
       struct Constraints {
 
-        typedef typename Graph::UndirEdge UndirEdge;
+        typedef typename Graph::UEdge UEdge;
         typedef typename Graph::Edge Edge;
         typedef typename Graph::Node Node;
@@ -105 +105 @@
         void constraints() {
           checkConcept<BaseIterableGraphComponent, Graph>();
-          checkConcept<GraphItem<>, UndirEdge>();
-          //checkConcept<UndirGraphEdge<Graph>, Edge>();
+          checkConcept<GraphItem<>, UEdge>();
+          //checkConcept<UGraphEdge<Graph>, Edge>();
 
           graph.first(ue);
@@ -121 +121 @@
           bool b;
           b = graph.direction(e);
-          Edge e = graph.direct(UndirEdge(), true);
-          e = graph.direct(UndirEdge(), n);
+          Edge e = graph.direct(UEdge(), true);
+          e = graph.direct(UEdge(), n);
  
           ignore_unused_variable_warning(b);
@@ -130 +130 @@
         Edge e;
         Node n0;
-        UndirEdge ue;
+        UEdge ue;
       };
 
@@ -136 +136 @@
 
 
-    struct IterableUndirGraphConcept {
+    struct IterableUGraphConcept {
 
       template <typename Graph>
@@ -143 +143 @@
           /// \todo we don't need the iterable component to be base iterable
           /// Don't we really???
-          //checkConcept< BaseIterableUndirGraphConcept, Graph > ();
+          //checkConcept< BaseIterableUGraphConcept, Graph > ();
 
           checkConcept<IterableGraphComponent, Graph> ();
 
-          typedef typename Graph::UndirEdge UndirEdge;
-          typedef typename Graph::UndirEdgeIt UndirEdgeIt;
+          typedef typename Graph::UEdge UEdge;
+          typedef typename Graph::UEdgeIt UEdgeIt;
           typedef typename Graph::IncEdgeIt IncEdgeIt;
 
-          checkConcept<GraphIterator<Graph, UndirEdge>, UndirEdgeIt>();
-          checkConcept<GraphIncIterator<Graph, UndirEdge>, IncEdgeIt>();
+          checkConcept<GraphIterator<Graph, UEdge>, UEdgeIt>();
+          checkConcept<GraphIncIterator<Graph, UEdge>, IncEdgeIt>();
         }
       };
@@ -158 +158 @@
     };
 
-    struct MappableUndirGraphConcept {
+    struct MappableUGraphConcept {
 
       template <typename Graph>
@@ -172 +172 @@
           checkConcept<MappableGraphComponent, Graph>();
 
-          typedef typename Graph::template UndirEdgeMap<int> IntMap;
-          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, int>,
+          typedef typename Graph::template UEdgeMap<int> IntMap;
+          checkConcept<GraphMap<Graph, typename Graph::UEdge, int>,
             IntMap >();
 
-          typedef typename Graph::template UndirEdgeMap<bool> BoolMap;
-          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, bool>,
+          typedef typename Graph::template UEdgeMap<bool> BoolMap;
+          checkConcept<GraphMap<Graph, typename Graph::UEdge, bool>,
             BoolMap >();
 
-          typedef typename Graph::template UndirEdgeMap<Dummy> DummyMap;
-          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, Dummy>,
+          typedef typename Graph::template UEdgeMap<Dummy> DummyMap;
+          checkConcept<GraphMap<Graph, typename Graph::UEdge, Dummy>,
             DummyMap >();
         }
@@ -188 +188 @@
     };
 
-    struct ExtendableUndirGraphConcept {
+    struct ExtendableUGraphConcept {
 
       template <typename Graph>
@@ -197 +197 @@
         }
         typename Graph::Node node_a, node_b;
-        typename Graph::UndirEdge uedge;
+        typename Graph::UEdge uedge;
         Graph graph;
       };
@@ -203 +203 @@
     };
 
-    struct ErasableUndirGraphConcept {
+    struct ErasableUGraphConcept {
 
       template <typename Graph>
@@ -213 +213 @@
         Graph graph;
         typename Graph::Node n;
-        typename Graph::UndirEdge e;
+        typename Graph::UEdge e;
       };
 
@@ -234 +234 @@
     /// In LEMON undirected graphs also fulfill the concept of directed
     /// graphs (\ref lemon::concept::StaticGraph "Graph Concept"). For
-    /// explanation of this and more see also the page \ref undir_graphs,
+    /// explanation of this and more see also the page \ref ugraphs,
     /// a tutorial about undirected graphs.
     ///
@@ -241 +241 @@
     /// to the StaticGraph concept.
 
-    class UndirGraph {
+    class UGraph {
     public:
       ///\e
@@ -247 +247 @@
       ///\todo undocumented
       ///
-      typedef True UndirTag;
+      typedef True UTag;
 
       /// \brief The base type of node iterators, 
@@ -330 +330 @@
         /// Sets the iterator to the first node of \c g.
         ///
-        NodeIt(const UndirGraph&) { }
+        NodeIt(const UGraph&) { }
         /// Node -> NodeIt conversion.
 
@@ -337 +337 @@
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        NodeIt(const UndirGraph&, const Node&) { }
+        NodeIt(const UGraph&, const Node&) { }
         /// Next node.
 
@@ -350 +350 @@
       /// The base type of the undirected edge iterators.
       ///
-      class UndirEdge {
+      class UEdge {
       public:
         /// Default constructor
@@ -356 +356 @@
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        UndirEdge() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        UndirEdge(const UndirEdge&) { }
-        /// Initialize the iterator to be invalid.
-
-        /// Initialize the iterator to be invalid.
-        ///
-        UndirEdge(Invalid) { }
+        UEdge() { }
+        /// Copy constructor.
+
+        /// Copy constructor.
+        ///
+        UEdge(const UEdge&) { }
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
+        UEdge(Invalid) { }
         /// Equality operator
 
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
-        bool operator==(UndirEdge) const { return true; }
+        bool operator==(UEdge) const { return true; }
         /// Inequality operator
 
-        /// \sa operator==(UndirEdge n)
-        ///
-        bool operator!=(UndirEdge) const { return true; }
+        /// \sa operator==(UEdge n)
+        ///
+        bool operator!=(UEdge) const { return true; }
 
         /// Artificial ordering operator.
@@ -388 +388 @@
         ///
         /// \bug This is a technical requirement. Do we really need this?
-        bool operator<(UndirEdge) const { return false; }
+        bool operator<(UEdge) const { return false; }
       };
 
@@ -398 +398 @@
       /// \code
       /// int count=0;
-      /// for(Graph::UndirEdgeIt e(g); e!=INVALID; ++e) ++count;
+      /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
       /// \endcode
-      class UndirEdgeIt : public UndirEdge {
+      class UEdgeIt : public UEdge {
       public:
         /// Default constructor
@@ -406 +406 @@
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        UndirEdgeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        UndirEdgeIt(const UndirEdgeIt& e) : UndirEdge(e) { }
-        /// Initialize the iterator to be invalid.
-
-        /// Initialize the iterator to be invalid.
-        ///
-        UndirEdgeIt(Invalid) { }
+        UEdgeIt() { }
+        /// Copy constructor.
+
+        /// Copy constructor.
+        ///
+        UEdgeIt(const UEdgeIt& e) : UEdge(e) { }
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
+        UEdgeIt(Invalid) { }
         /// This constructor sets the iterator to the first undirected edge.
     
         /// This constructor sets the iterator to the first undirected edge.
-        UndirEdgeIt(const UndirGraph&) { }
-        /// UndirEdge -> UndirEdgeIt conversion
+        UEdgeIt(const UGraph&) { }
+        /// UEdge -> UEdgeIt conversion
 
         /// Sets the iterator to the value of the trivial iterator.
@@ -427 +427 @@
         /// iterate the undirected edge-set, the iteration order is the 
         /// same.
-        UndirEdgeIt(const UndirGraph&, const UndirEdge&) { } 
+        UEdgeIt(const UGraph&, const UEdge&) { } 
         /// Next undirected edge
         
         /// Assign the iterator to the next undirected edge.
-        UndirEdgeIt& operator++() { return *this; }
+        UEdgeIt& operator++() { return *this; }
       };
 
@@ -448 +448 @@
       /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
       /// \endcode
-      class IncEdgeIt : public UndirEdge {
+      class IncEdgeIt : public UEdge {
       public:
         /// Default constructor
@@ -459 +459 @@
         /// Copy constructor.
         ///
-        IncEdgeIt(const IncEdgeIt& e) : UndirEdge(e) { }
+        IncEdgeIt(const IncEdgeIt& e) : UEdge(e) { }
         /// Initialize the iterator to be invalid.
 
@@ -469 +469 @@
         /// This constructor set the iterator to the first incident edge of
         /// the node.
-        IncEdgeIt(const UndirGraph&, const Node&) { }
-        /// UndirEdge -> IncEdgeIt conversion
+        IncEdgeIt(const UGraph&, const Node&) { }
+        /// UEdge -> IncEdgeIt conversion
 
         /// Sets the iterator to the value of the trivial iterator \c e.
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        IncEdgeIt(const UndirGraph&, const UndirEdge&) { }
+        IncEdgeIt(const UGraph&, const UEdge&) { }
         /// Next incident edge
 
@@ -487 +487 @@
       /// The directed edge type. It can be converted to the
       /// undirected edge.
-      class Edge : public UndirEdge {
+      class Edge : public UEdge {
       public:
         /// Default constructor
@@ -498 +498 @@
         /// Copy constructor.
         ///
-        Edge(const Edge& e) : UndirEdge(e) { }
+        Edge(const Edge& e) : UEdge(e) { }
         /// Initialize the iterator to be invalid.
 
@@ -558 +558 @@
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const UndirGraph &g) { ignore_unused_variable_warning(g); }
+        EdgeIt(const UGraph &g) { ignore_unused_variable_warning(g); }
         /// Edge -> EdgeIt conversion
 
@@ -564 +564 @@
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        EdgeIt(const UndirGraph&, const Edge&) { } 
+        EdgeIt(const UGraph&, const Edge&) { } 
         ///Next edge
         
@@ -606 +606 @@
         ///@param n the node
         ///@param g the graph
-        OutEdgeIt(const UndirGraph& n, const Node& g) {
+        OutEdgeIt(const UGraph& n, const Node& g) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
@@ -615 +615 @@
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        OutEdgeIt(const UndirGraph&, const Edge&) { }
+        OutEdgeIt(const UGraph&, const Edge&) { }
         ///Next outgoing edge
         
@@ -658 +658 @@
         ///@param n the node
         ///@param g the graph
-        InEdgeIt(const UndirGraph& g, const Node& n) { 
+        InEdgeIt(const UGraph& g, const Node& n) { 
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
@@ -667 +667 @@
         /// This feature necessitates that each time we 
         /// iterate the edge-set, the iteration order is the same.
-        InEdgeIt(const UndirGraph&, const Edge&) { }
+        InEdgeIt(const UGraph&, const Edge&) { }
         /// Next incoming edge
 
@@ -688 +688 @@
 
         ///\e
-        NodeMap(const UndirGraph&) { }
+        NodeMap(const UGraph&) { }
         ///\e
-        NodeMap(const UndirGraph&, T) { }
+        NodeMap(const UGraph&, T) { }
 
         ///Copy constructor
@@ -712 +712 @@
 
         ///\e
-        EdgeMap(const UndirGraph&) { }
+        EdgeMap(const UGraph&) { }
         ///\e
-        EdgeMap(const UndirGraph&, T) { }
+        EdgeMap(const UGraph&, T) { }
         ///Copy constructor
         EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
@@ -726 +726 @@
       /// Reference map of the edges to type \c T.
       /// \sa Reference
-      /// \warning Making maps that can handle bool type (UndirEdgeMap<bool>)
+      /// \warning Making maps that can handle bool type (UEdgeMap<bool>)
       /// needs some extra attention!
       /// \todo Wrong documentation
       template<class T> 
-      class UndirEdgeMap : public ReadWriteMap<UndirEdge,T>
+      class UEdgeMap : public ReadWriteMap<UEdge,T>
       {
       public:
 
         ///\e
-        UndirEdgeMap(const UndirGraph&) { }
+        UEdgeMap(const UGraph&) { }
         ///\e
-        UndirEdgeMap(const UndirGraph&, T) { }
+        UEdgeMap(const UGraph&, T) { }
         ///Copy constructor
-        UndirEdgeMap(const UndirEdgeMap& em) : ReadWriteMap<UndirEdge,T>(em) {}
+        UEdgeMap(const UEdgeMap& em) : ReadWriteMap<UEdge,T>(em) {}
         ///Assignment operator
-        UndirEdgeMap &operator=(const UndirEdgeMap&) { return *this; }
+        UEdgeMap &operator=(const UEdgeMap&) { return *this; }
         // \todo fix this concept    
       };
@@ -749 +749 @@
       /// Direct the given undirected edge. The returned edge source
       /// will be the given edge.
-      Edge direct(const UndirEdge&, const Node&) const {
+      Edge direct(const UEdge&, const Node&) const {
         return INVALID;
       }
@@ -758 +758 @@
       /// will be the source of the undirected edge if the given bool
       /// is true.
-      Edge direct(const UndirEdge&, bool) const {
+      Edge direct(const UEdge&, bool) const {
         return INVALID;
       }
@@ -776 +776 @@
       ///
       /// \return the opposite of the given Node on the given Edge
-      Node oppositeNode(Node, UndirEdge) const { return INVALID; }
+      Node oppositeNode(Node, UEdge) const { return INVALID; }
 
       /// \brief First node of the undirected edge.
       ///
-      /// \return the first node of the given UndirEdge.
-      ///
-      /// Naturally undirectected edges don't have direction and thus
+      /// \return the first node of the given UEdge.
+      ///
+      /// Naturally uectected edges don't have direction and thus
       /// don't have source and target node. But we use these two methods
       /// to query the two endnodes of the edge. The direction of the edge
@@ -789 +789 @@
       /// of the directed versions of the edges.
       /// \sa direction
-      Node source(UndirEdge) const { return INVALID; }
+      Node source(UEdge) const { return INVALID; }
 
       /// \brief Second node of the undirected edge.
-      Node target(UndirEdge) const { return INVALID; }
+      Node target(UEdge) const { return INVALID; }
 
       /// \brief Source node of the directed edge.
@@ -818 +818 @@
 //       /// developpers_interface "Developpers' interface", so it shouldn't
 //       /// be used in an end-user program.
-      void first(UndirEdge&) const {}
+      void first(UEdge&) const {}
 //       /// \brief Next undirected edge of the graph
 //       ///
@@ -824 +824 @@
 //       /// developpers_interface "Developpers' interface", so it shouldn't
 //       /// be used in an end-user program.
-      void next(UndirEdge&) const {}
+      void next(UEdge&) const {}
 
 //       /// \brief First directed edge of the graph
@@ -911 +911 @@
       struct Constraints {
         void constraints() {
-          checkConcept<BaseIterableUndirGraphConcept, Graph>();
-          checkConcept<IterableUndirGraphConcept, Graph>();
-          checkConcept<MappableUndirGraphConcept, Graph>();
+          checkConcept<BaseIterableUGraphConcept, Graph>();
+          checkConcept<IterableUGraphConcept, Graph>();
+          checkConcept<MappableUGraphConcept, Graph>();
         }
       };
@@ -921 +921 @@
     /// \brief An empty non-static undirected graph class.
     ///    
-    /// This class provides everything that \ref UndirGraph does.
+    /// This class provides everything that \ref UGraph does.
     /// Additionally it enables building graphs from scratch.
-    class ExtendableUndirGraph : public UndirGraph {
+    class ExtendableUGraph : public UGraph {
     public:
       
@@ -936 +936 @@
       /// Add a new undirected edge to the graph.
       /// \return the new edge.
-      UndirEdge addEdge(const Node& from, const Node& to);
+      UEdge addEdge(const Node& from, const Node& to);
 
       /// \brief Resets the graph.
@@ -947 +947 @@
       struct Constraints {
         void constraints() {
-          checkConcept<BaseIterableUndirGraphConcept, Graph>();
-          checkConcept<IterableUndirGraphConcept, Graph>();
-          checkConcept<MappableUndirGraphConcept, Graph>();
-
-          checkConcept<UndirGraph, Graph>();
-          checkConcept<ExtendableUndirGraphConcept, Graph>();
+          checkConcept<BaseIterableUGraphConcept, Graph>();
+          checkConcept<IterableUGraphConcept, Graph>();
+          checkConcept<MappableUGraphConcept, Graph>();
+
+          checkConcept<UGraph, Graph>();
+          checkConcept<ExtendableUGraphConcept, Graph>();
           checkConcept<ClearableGraphComponent, Graph>();
         }
@@ -961 +961 @@
     /// \brief An empty erasable undirected graph class.
     ///
-    /// This class is an extension of \ref ExtendableUndirGraph. It makes it
+    /// This class is an extension of \ref ExtendableUGraph. It makes it
     /// possible to erase undirected edges or nodes.
-    class ErasableUndirGraph : public ExtendableUndirGraph {
+    class ErasableUGraph : public ExtendableUGraph {
     public:
 
@@ -975 +975 @@
       /// Deletes an undirected edge.
       ///
-      void erase(UndirEdge) { }
+      void erase(UEdge) { }
 
       template <typename Graph>
       struct Constraints {
         void constraints() {
-          checkConcept<ExtendableUndirGraph, Graph>();
-          checkConcept<ErasableUndirGraphConcept, Graph>();
+          checkConcept<ExtendableUGraph, Graph>();
+          checkConcept<ErasableUGraphConcept, Graph>();
         }
       };

lemon/edge_set.h

@@ -295 +295 @@
   ///
   /// \brief Graph using a node set of another graph and an
-  /// own undir edge set.
+  /// own uedge set.
   ///
   /// This structure can be used to establish another graph over a node set
@@ -308 +308 @@
   /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
   template <typename _Graph>
-  class ListUndirEdgeSet :
-    public ErasableUndirEdgeSetExtender<
-    ClearableUndirEdgeSetExtender<
-    ExtendableUndirEdgeSetExtender<
-    MappableUndirEdgeSetExtender<
-    IterableUndirGraphExtender<
-    AlterableUndirEdgeSetExtender<
-    UndirGraphExtender<
+  class ListUEdgeSet :
+    public ErasableUEdgeSetExtender<
+    ClearableUEdgeSetExtender<
+    ExtendableUEdgeSetExtender<
+    MappableUEdgeSetExtender<
+    IterableUGraphExtender<
+    AlterableUEdgeSetExtender<
+    UGraphExtender<
     ListEdgeSetBase<_Graph> > > > > > > > {
 
   public:
 
-    typedef ErasableUndirEdgeSetExtender<
-      ClearableUndirEdgeSetExtender<
-      ExtendableUndirEdgeSetExtender<
-      MappableUndirEdgeSetExtender<
-      IterableUndirGraphExtender<
-      AlterableUndirEdgeSetExtender<
-      UndirGraphExtender<
+    typedef ErasableUEdgeSetExtender<
+      ClearableUEdgeSetExtender<
+      ExtendableUEdgeSetExtender<
+      MappableUEdgeSetExtender<
+      IterableUGraphExtender<
+      AlterableUEdgeSetExtender<
+      UGraphExtender<
       ListEdgeSetBase<_Graph> > > > > > > > Parent;
     
@@ -355 +355 @@
       typedef NodesImplBase Parent;
       
-      NodesImpl(const Graph& graph, ListUndirEdgeSet& edgeset) 
+      NodesImpl(const Graph& graph, ListUEdgeSet& edgeset) 
         : Parent(graph), _edgeset(edgeset) {}
       
@@ -376 +376 @@
 
     private:
-      ListUndirEdgeSet& _edgeset;
+      ListUEdgeSet& _edgeset;
     };
 
@@ -386 +386 @@
     /// 
     /// Constructor of the adaptor.
-    ListUndirEdgeSet(const Graph& graph) : nodes(graph, *this) {
+    ListUEdgeSet(const Graph& graph) : nodes(graph, *this) {
       Parent::initalize(graph, nodes);
     }

lemon/euler.h

@@ -125 +125 @@
   ///Euler tour of \c g.
   ///\code
-  ///  for(UndirEulerIt<UndirListGraph> e(g),e!=INVALID;++e) {
-  ///    std::cout << g.id(UndirEdge(e)) << std::eol;
+  ///  for(UEulerIt<ListUGraph> e(g),e!=INVALID;++e) {
+  ///    std::cout << g.id(UEdge(e)) << std::eol;
   ///  }
   ///\endcode
   ///Although the iterator provides an Euler tour of an undirected graph,
-  ///in order to indicate the direction of the tour, UndirEulerIt
+  ///in order to indicate the direction of the tour, UEulerIt
   ///returns directed edges (that convert to the undirected ones, of course).
   ///
@@ -136 +136 @@
   ///\todo Test required
   template<class Graph>
-  class UndirEulerIt
+  class UEulerIt
   {
     typedef typename Graph::Node Node;
@@ -147 +147 @@
     const Graph &g;
     typename Graph::NodeMap<OutEdgeIt> nedge;
-    typename Graph::UndirEdgeMap<bool> visited;
+    typename Graph::UEdgeMap<bool> visited;
     std::list<Edge> euler;
 
@@ -157 +157 @@
     ///\param start The starting point of the tour. If it is not given
     ///       the tour will start from the first node.
-    UndirEulerIt(const Graph &_g,typename Graph::Node start=INVALID)
+    UEulerIt(const Graph &_g,typename Graph::Node start=INVALID)
       : g(_g), nedge(g), visited(g,false)
     {
@@ -176 +176 @@
     
     ///Next edge of the tour
-    UndirEulerIt &operator++() {
+    UEulerIt &operator++() {
       Node s=g.target(euler.front());
       euler.pop_front();
@@ -197 +197 @@
     
     ///\warning This incrementation
-    ///returns an \c Edge, not an \ref UndirEulerIt, as one may
+    ///returns an \c Edge, not an \ref UEulerIt, as one may
     ///expect.
     Edge operator++(int) 
@@ -225 +225 @@
   bool
 #else
-  typename enable_if<typename Graph::UndirTag,bool>::type
+  typename enable_if<typename Graph::UTag,bool>::type
   euler(const Graph &g) 
   {
@@ -233 +233 @@
   }
   template<class Graph>
-  typename disable_if<typename Graph::UndirTag,bool>::type
+  typename disable_if<typename Graph::UTag,bool>::type
 #endif
   euler(const Graph &g) 

lemon/full_graph.h

@@ -32 +32 @@
 ///\ingroup graphs
 ///\file
-///\brief FullGraph and UndirFullGraph classes.
+///\brief FullGraph and FullUGraph classes.
 
 
@@ -214 +214 @@
 
 
-  class UndirFullGraphBase {
+  class FullUGraphBase {
     int _nodeNum;
     int _edgeNum;
   public:
 
-    typedef UndirFullGraphBase Graph;
+    typedef FullUGraphBase Graph;
 
     class Node;
@@ -226 +226 @@
   public:
 
-    UndirFullGraphBase() {}
+    FullUGraphBase() {}
 
 
@@ -302 +302 @@
       
     class Node {
-      friend class UndirFullGraphBase;
+      friend class FullUGraphBase;
 
     protected:
@@ -318 +318 @@
 
     class Edge {
-      friend class UndirFullGraphBase;
+      friend class FullUGraphBase;
       
     protected:
@@ -378 +378 @@
   };
 
-  typedef StaticMappableUndirGraphExtender<
-    IterableUndirGraphExtender<
-    AlterableUndirGraphExtender<
-    UndirGraphExtender<UndirFullGraphBase> > > > ExtendedUndirFullGraphBase;
+  typedef StaticMappableUGraphExtender<
+    IterableUGraphExtender<
+    AlterableUGraphExtender<
+    UGraphExtender<FullUGraphBase> > > > ExtendedFullUGraphBase;
 
   /// \ingroup graphs
@@ -391 +391 @@
   /// edges or nodes.
   ///
-  /// The main difference beetween the \e FullGraph and \e UndirFullGraph class
+  /// The main difference beetween the \e FullGraph and \e FullUGraph class
   /// is that this class conforms to the undirected graph concept and
   /// it does not contain the loop edges.
@@ -398 +398 @@
   ///
   /// \author Balazs Dezso
-  class UndirFullGraph : public ExtendedUndirFullGraphBase {
-  public:
-    UndirFullGraph(int n) { construct(n); }
+  class FullUGraph : public ExtendedFullUGraphBase {
+  public:
+    FullUGraph(int n) { construct(n); }
   };
 
 
-  class FullUndirBipartiteGraphBase {
+  class FullUBipartiteGraphBase {
   protected:
 
@@ -416 +416 @@
     class NodeSetError : public LogicError {
       virtual const char* exceptionName() const { 
-        return "lemon::FullUndirBipartiteGraph::NodeSetError";
+        return "lemon::FullUBipartiteGraph::NodeSetError";
       }
     };
   
     class Node {
-      friend class FullUndirBipartiteGraphBase;
+      friend class FullUBipartiteGraphBase;
     protected:
       int id;
@@ -435 +435 @@
 
     class Edge {
-      friend class FullUndirBipartiteGraphBase;
+      friend class FullUBipartiteGraphBase;
     protected:
       int id;
@@ -576 +576 @@
 
 
-  typedef StaticMappableUndirBipartiteGraphExtender<
-    IterableUndirBipartiteGraphExtender<
-    AlterableUndirBipartiteGraphExtender<
-    UndirBipartiteGraphExtender <
-    FullUndirBipartiteGraphBase> > > >
-  ExtendedFullUndirBipartiteGraphBase;
-
-
-  class FullUndirBipartiteGraph : 
-    public ExtendedFullUndirBipartiteGraphBase {
-  public:
-    typedef ExtendedFullUndirBipartiteGraphBase Parent;
-    FullUndirBipartiteGraph(int upperNodeNum, int lowerNodeNum) {
+  typedef StaticMappableUBipartiteGraphExtender<
+    IterableUBipartiteGraphExtender<
+    AlterableUBipartiteGraphExtender<
+    UBipartiteGraphExtender <
+    FullUBipartiteGraphBase> > > >
+  ExtendedFullUBipartiteGraphBase;
+
+
+  class FullUBipartiteGraph : 
+    public ExtendedFullUBipartiteGraphBase {
+  public:
+    typedef ExtendedFullUBipartiteGraphBase Parent;
+    FullUBipartiteGraph(int upperNodeNum, int lowerNodeNum) {
       Parent::construct(upperNodeNum, lowerNodeNum);
     }

lemon/graph_adaptor.h

@@ -673 +673 @@
 
   template <typename _Graph>
-  class UndirGraphAdaptorBase : 
-    public UndirGraphExtender<GraphAdaptorBase<_Graph> > {
+  class UGraphAdaptorBase : 
+    public UGraphExtender<GraphAdaptorBase<_Graph> > {
   public:
     typedef _Graph Graph;
-    typedef UndirGraphExtender<GraphAdaptorBase<_Graph> > Parent;
+    typedef UGraphExtender<GraphAdaptorBase<_Graph> > Parent;
   protected:
-    UndirGraphAdaptorBase() : Parent() { }
-  public:
-    typedef typename Parent::UndirEdge UndirEdge;
+    UGraphAdaptorBase() : Parent() { }
+  public:
+    typedef typename Parent::UEdge UEdge;
     typedef typename Parent::Edge Edge;
     
@@ -687 +687 @@
     class EdgeMap {
     protected:
-      const UndirGraphAdaptorBase<_Graph>* g;
+      const UGraphAdaptorBase<_Graph>* g;
       template <typename TT> friend class EdgeMap;
       typename _Graph::template EdgeMap<T> forward_map, backward_map; 
@@ -694 +694 @@
       typedef Edge Key;
       
-      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g) : g(&_g), 
+      EdgeMap(const UGraphAdaptorBase<_Graph>& _g) : g(&_g), 
         forward_map(*(g->graph)), backward_map(*(g->graph)) { }
 
-      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g, T a) : g(&_g), 
+      EdgeMap(const UGraphAdaptorBase<_Graph>& _g, T a) : g(&_g), 
         forward_map(*(g->graph), a), backward_map(*(g->graph), a) { }
       
@@ -716 +716 @@
         
     template <typename T>
-    class UndirEdgeMap {
-      template <typename TT> friend class UndirEdgeMap;
+    class UEdgeMap {
+      template <typename TT> friend class UEdgeMap;
       typename _Graph::template EdgeMap<T> map; 
     public:
       typedef T Value;
-      typedef UndirEdge Key;
-      
-      UndirEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) : 
+      typedef UEdge Key;
+      
+      UEdgeMap(const UGraphAdaptorBase<_Graph>& g) : 
         map(*(g.graph)) { }
 
-      UndirEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, T a) : 
+      UEdgeMap(const UGraphAdaptorBase<_Graph>& g, T a) : 
         map(*(g.graph), a) { }
       
-      void set(UndirEdge e, T a) { 
+      void set(UEdge e, T a) { 
         map.set(e, a); 
       }
 
-      T operator[](UndirEdge e) const { 
+      T operator[](UEdge e) const { 
         return map[e]; 
       }
@@ -747 +747 @@
   /// \author Marton Makai
   template<typename _Graph>
-  class UndirGraphAdaptor : 
-    public IterableUndirGraphExtender<
-    UndirGraphAdaptorBase<_Graph> > {
+  class UGraphAdaptor : 
+    public IterableUGraphExtender<
+    UGraphAdaptorBase<_Graph> > {
   public:
     typedef _Graph Graph;
-    typedef IterableUndirGraphExtender<
-      UndirGraphAdaptorBase<_Graph> > Parent;
+    typedef IterableUGraphExtender<
+      UGraphAdaptorBase<_Graph> > Parent;
   protected:
-    UndirGraphAdaptor() { }
-  public:
-    UndirGraphAdaptor(_Graph& _graph) { 
+    UGraphAdaptor() { }
+  public:
+    UGraphAdaptor(_Graph& _graph) { 
       setGraph(_graph);
     }

lemon/graph_reader.h

@@ -379 +379 @@
   /// \brief The undirected graph reader class.
   ///
-  /// The \c UndirGraphReader class provides the graph input. 
+  /// The \c UGraphReader class provides the graph input. 
   /// Before you read this documentation it might be useful to read the general
   /// description of  \ref graph-io-page "Graph Input-Output".
@@ -391 +391 @@
   ///
   /// If you read a graph you need not read all the maps and items just those
-  /// that you need. The interface of the \c UndirGraphReader is very similar
-  /// to the UndirGraphWriter but the reading method does not depend on the
+  /// that you need. The interface of the \c UGraphReader is very similar
+  /// to the UGraphWriter but the reading method does not depend on the
   /// order of the given commands.
   ///
@@ -400 +400 @@
   ///
   /// \code
-  /// UndirGraphReader<UndirListGraph> reader(std::cin, graph);
+  /// UGraphReader<ListUGraph> reader(std::cin, graph);
   /// \endcode
   ///
@@ -417 +417 @@
   /// \endcode
   ///
-  /// With the \c readUndirEdgeMap() member function you can give an 
-  /// undir edge map reading command similar to the NodeMaps. 
-  ///
-  /// \code
-  /// reader.readUndirEdgeMap("capacity", capacityMap);
+  /// With the \c readUEdgeMap() member function you can give an 
+  /// uedge map reading command similar to the NodeMaps. 
+  ///
+  /// \code
+  /// reader.readUEdgeMap("capacity", capacityMap);
   /// \endcode
   ///
@@ -433 +433 @@
   /// \endcode 
   ///
-  /// With \c readNode() and \c readUndirEdge() functions you can read 
-  /// labeled Nodes and UndirEdges.
+  /// With \c readNode() and \c readUEdge() functions you can read 
+  /// labeled Nodes and UEdges.
   ///
   /// \code
@@ -440 +440 @@
   /// reader.readNode("target", targetNode);
   ///
-  /// reader.readUndirEdge("observed", undirEdge);
+  /// reader.readUEdge("observed", uEdge);
   /// \endcode
   ///
@@ -456 +456 @@
   /// \see GraphReader
   /// \see DefaultReaderTraits
-  /// \see \ref UndirGraphWriter
+  /// \see \ref UGraphWriter
   /// \see \ref graph-io-page
   ///
   /// \author Balazs Dezso
   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 
-  class UndirGraphReader {
+  class UGraphReader {
   public:
     
@@ -467 +467 @@
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::UndirEdge UndirEdge;
+    typedef typename Graph::UEdge UEdge;
 
     typedef _ReaderTraits ReaderTraits;
     typedef typename ReaderTraits::Skipper DefaultSkipper;
 
-    /// \brief Construct a new UndirGraphReader.
-    ///
-    /// Construct a new UndirGraphReader. It reads into the given graph
+    /// \brief Construct a new UGraphReader.
+    ///
+    /// Construct a new UGraphReader. It reads into the given graph
     /// and it use the given reader as the default skipper.
-    UndirGraphReader(std::istream& _is, Graph& _graph, 
+    UGraphReader(std::istream& _is, Graph& _graph, 
                      const DefaultSkipper& _skipper = DefaultSkipper()) 
       : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
         nodeset_reader(*reader, _graph, std::string(), skipper),
-        undir_edgeset_reader(*reader, _graph, nodeset_reader, 
+        u_edgeset_reader(*reader, _graph, nodeset_reader, 
                              std::string(), skipper),
         node_reader(*reader, nodeset_reader, std::string()),
-        undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+        u_edge_reader(*reader, u_edgeset_reader, std::string()),
         attribute_reader(*reader, std::string()) {}
 
-    /// \brief Construct a new UndirGraphReader.
-    ///
-    /// Construct a new UndirGraphReader. It reads into the given graph
+    /// \brief Construct a new UGraphReader.
+    ///
+    /// Construct a new UGraphReader. It reads into the given graph
     /// and it use the given reader as the default skipper.
-    UndirGraphReader(const std::string& _filename, Graph& _graph, 
+    UGraphReader(const std::string& _filename, Graph& _graph, 
                      const DefaultSkipper& _skipper = DefaultSkipper()) 
       : reader(new LemonReader(_filename)), own_reader(true), 
         skipper(_skipper),
         nodeset_reader(*reader, _graph, std::string(), skipper),
-        undir_edgeset_reader(*reader, _graph, nodeset_reader, 
+        u_edgeset_reader(*reader, _graph, nodeset_reader, 
                              std::string(), skipper),
         node_reader(*reader, nodeset_reader, std::string()),
-        undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+        u_edge_reader(*reader, u_edgeset_reader, std::string()),
         attribute_reader(*reader, std::string()) {}
 
-    /// \brief Construct a new UndirGraphReader.
-    ///
-    /// Construct a new UndirGraphReader. It reads into the given graph
+    /// \brief Construct a new UGraphReader.
+    ///
+    /// Construct a new UGraphReader. It reads into the given graph
     /// and it use the given reader as the default skipper.
-    UndirGraphReader(LemonReader& _reader, Graph& _graph, 
+    UGraphReader(LemonReader& _reader, Graph& _graph, 
                      const DefaultSkipper& _skipper = DefaultSkipper()) 
       : reader(_reader), own_reader(false), skipper(_skipper),
         nodeset_reader(*reader, _graph, std::string(), skipper),
-        undir_edgeset_reader(*reader, _graph, nodeset_reader, 
+        u_edgeset_reader(*reader, _graph, nodeset_reader, 
                              std::string(), skipper),
         node_reader(*reader, nodeset_reader, std::string()),
-        undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+        u_edge_reader(*reader, u_edgeset_reader, std::string()),
         attribute_reader(*reader, std::string()) {}
 
@@ -518 +518 @@
     ///
     /// Destruct the graph reader.
-    ~UndirGraphReader() {
+    ~UGraphReader() {
       if (own_reader) 
         delete reader;
@@ -527 +527 @@
     /// Give a new node map reading command to the reader.
     template <typename Map>
-    UndirGraphReader& readNodeMap(std::string name, Map& map) {
+    UGraphReader& readNodeMap(std::string name, Map& map) {
       nodeset_reader.readNodeMap(name, map);
       return *this;
@@ -533 +533 @@
 
     template <typename Map>
-    UndirGraphReader& readNodeMap(std::string name, const Map& map) {
+    UGraphReader& readNodeMap(std::string name, const Map& map) {
       nodeset_reader.readNodeMap(name, map);
       return *this;
@@ -542 +542 @@
     /// Give a new node map reading command to the reader.
     template <typename Reader, typename Map>
-    UndirGraphReader& readNodeMap(std::string name, Map& map, 
+    UGraphReader& readNodeMap(std::string name, Map& map, 
                                   const Reader& reader = Reader()) {
       nodeset_reader.readNodeMap(name, map, reader);
@@ -549 +549 @@
 
     template <typename Reader, typename Map>
-    UndirGraphReader& readNodeMap(std::string name, const Map& map, 
+    UGraphReader& readNodeMap(std::string name, const Map& map, 
                                   const Reader& reader = Reader()) {
       nodeset_reader.readNodeMap(name, map, reader);
@@ -559 +559 @@
     /// Give a new node map skipping command to the reader.
     template <typename Reader>
-    UndirGraphReader& skipNodeMap(std::string name, 
+    UGraphReader& skipNodeMap(std::string name, 
                              const Reader& reader = Reader()) {
       nodeset_reader.skipNodeMap(name, reader);
@@ -569 +569 @@
     /// Give a new undirected edge map reading command to the reader.
     template <typename Map>
-    UndirGraphReader& readUndirEdgeMap(std::string name, Map& map) { 
-      undir_edgeset_reader.readUndirEdgeMap(name, map);
-      return *this;
-    }
-
-    template <typename Map>
-    UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map) { 
-      undir_edgeset_reader.readUndirEdgeMap(name, map);
+    UGraphReader& readUEdgeMap(std::string name, Map& map) { 
+      u_edgeset_reader.readUEdgeMap(name, map);
+      return *this;
+    }
+
+    template <typename Map>
+    UGraphReader& readUEdgeMap(std::string name, const Map& map) { 
+      u_edgeset_reader.readUEdgeMap(name, map);
       return *this;
     }
@@ -585 +585 @@
     /// Give a new undirected edge map reading command to the reader.
     template <typename Reader, typename Map>
-    UndirGraphReader& readUndirEdgeMap(std::string name, Map& map,
+    UGraphReader& readUEdgeMap(std::string name, Map& map,
                                        const Reader& reader = Reader()) {
-      undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
-      return *this;
-    }
-
-    template <typename Reader, typename Map>
-    UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map,
+      u_edgeset_reader.readUEdgeMap(name, map, reader);
+      return *this;
+    }
+
+    template <typename Reader, typename Map>
+    UGraphReader& readUEdgeMap(std::string name, const Map& map,
                                        const Reader& reader = Reader()) {
-      undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
+      u_edgeset_reader.readUEdgeMap(name, map, reader);
       return *this;
     }
@@ -602 +602 @@
     /// Give a new undirected edge map skipping command to the reader.
     template <typename Reader>
-    UndirGraphReader& skipUndirEdgeMap(std::string name,
+    UGraphReader& skipUEdgeMap(std::string name,
                                        const Reader& reader = Reader()) {
-      undir_edgeset_reader.skipUndirMap(name, reader);
+      u_edgeset_reader.skipUMap(name, reader);
       return *this;
     }
@@ -613 +613 @@
     /// Give a new edge map reading command to the reader.
     template <typename Map>
-    UndirGraphReader& readEdgeMap(std::string name, Map& map) { 
-      undir_edgeset_reader.readEdgeMap(name, map);
-      return *this;
-    }
-
-    template <typename Map>
-    UndirGraphReader& readEdgeMap(std::string name, const Map& map) { 
-      undir_edgeset_reader.readEdgeMap(name, map);
+    UGraphReader& readEdgeMap(std::string name, Map& map) { 
+      u_edgeset_reader.readEdgeMap(name, map);
+      return *this;
+    }
+
+    template <typename Map>
+    UGraphReader& readEdgeMap(std::string name, const Map& map) { 
+      u_edgeset_reader.readEdgeMap(name, map);
       return *this;
     }
@@ -629 +629 @@
     /// Give a new edge map reading command to the reader.
     template <typename Reader, typename Map>
-    UndirGraphReader& readEdgeMap(std::string name, Map& map,
+    UGraphReader& readEdgeMap(std::string name, Map& map,
                                        const Reader& reader = Reader()) {
-      undir_edgeset_reader.readEdgeMap(name, map, reader);
-      return *this;
-    }
-
-    template <typename Reader, typename Map>
-    UndirGraphReader& readEdgeMap(std::string name, const Map& map,
+      u_edgeset_reader.readEdgeMap(name, map, reader);
+      return *this;
+    }
+
+    template <typename Reader, typename Map>
+    UGraphReader& readEdgeMap(std::string name, const Map& map,
                                        const Reader& reader = Reader()) {
-      undir_edgeset_reader.readEdgeMap(name, map, reader);
+      u_edgeset_reader.readEdgeMap(name, map, reader);
       return *this;
     }
@@ -646 +646 @@
     /// Give a new edge map skipping command to the reader.
     template <typename Reader>
-    UndirGraphReader& skipEdgeMap(std::string name,
+    UGraphReader& skipEdgeMap(std::string name,
                                        const Reader& reader = Reader()) {
-      undir_edgeset_reader.skipEdgeMap(name, reader);
+      u_edgeset_reader.skipEdgeMap(name, reader);
       return *this;
     }
@@ -655 +655 @@
     ///
     /// Give a new labeled node reading command to the reader.
-    UndirGraphReader& readNode(std::string name, Node& node) {
+    UGraphReader& readNode(std::string name, Node& node) {
       node_reader.readNode(name, node);
       return *this;
@@ -663 +663 @@
     ///
     /// Give a new labeled edge reading command to the reader.
-    UndirGraphReader& readEdge(std::string name, Edge& edge) {
-      undir_edge_reader.readEdge(name, edge);
+    UGraphReader& readEdge(std::string name, Edge& edge) {
+      u_edge_reader.readEdge(name, edge);
     }
 
@@ -671 +671 @@
     ///
     /// Give a new labeled undirected edge reading command to the reader.
-    UndirGraphReader& readUndirEdge(std::string name, UndirEdge& edge) {
-      undir_edge_reader.readUndirEdge(name, edge);
+    UGraphReader& readUEdge(std::string name, UEdge& edge) {
+      u_edge_reader.readUEdge(name, edge);
     }
 
@@ -679 +679 @@
     ///  Give a new attribute reading command.
     template <typename Value>
-    UndirGraphReader& readAttribute(std::string name, Value& value) {
+    UGraphReader& readAttribute(std::string name, Value& value) {
       attribute_reader.readAttribute(name, value);
       return *this;
@@ -688 +688 @@
     ///  Give a new attribute reading command.
     template <typename Reader, typename Value>
-    UndirGraphReader& readAttribute(std::string name, Value& value, 
+    UGraphReader& readAttribute(std::string name, Value& value, 
                                const Reader& reader) {
       attribute_reader.readAttribute<Reader>(name, value, reader);
@@ -717 +717 @@
     bool isLabelReader() const {
       return nodeset_reader.isLabelReader() && 
-        undir_edgeset_reader.isLabelReader();
+        u_edgeset_reader.isLabelReader();
     }
 
@@ -733 +733 @@
     /// it. It is possible only if there was read an "label" named edge map.
     void readLabel(std::istream& is, Edge& edge) const {
-      return undir_edgeset_reader.readLabel(is, edge);
+      return u_edgeset_reader.readLabel(is, edge);
     } 
 
@@ -741 +741 @@
     /// belongs to it. It is possible only if there was read an "label" named 
     /// edge map.
-    void readLabel(std::istream& is, UndirEdge& uedge) const {
-      return undir_edgeset_reader.readLabel(is, uedge);
+    void readLabel(std::istream& is, UEdge& uedge) const {
+      return u_edgeset_reader.readLabel(is, uedge);
     } 
     
@@ -754 +754 @@
 
     NodeSetReader<Graph, ReaderTraits> nodeset_reader;
-    UndirEdgeSetReader<Graph, ReaderTraits> undir_edgeset_reader;
+    UEdgeSetReader<Graph, ReaderTraits> u_edgeset_reader;
 
     NodeReader<Graph> node_reader;
-    UndirEdgeReader<Graph> undir_edge_reader;
+    UEdgeReader<Graph> u_edge_reader;
     
     AttributeReader<ReaderTraits> attribute_reader;
@@ -765 +765 @@
   ///
   /// It is a helper function to read an undirected graph from the given input
-  /// stream. It gives back an UndirGraphReader object and this object
+  /// stream. It gives back an UGraphReader object and this object
   /// can read more maps, labeled nodes, edges, undirected edges and
   /// attributes.
@@ -774 +774 @@
   /// \param g The graph.
   template<typename Graph>
-  UndirGraphReader<Graph> undirGraphReader(std::istream& is, Graph &g) {
+  UGraphReader<Graph> uGraphReader(std::istream& is, Graph &g) {
     return GraphReader<Graph>(is, g);
   }
@@ -781 +781 @@
   ///
   /// It is a helper function to read an undirected graph from the given input
-  /// file. It gives back an UndirGraphReader object and this object
+  /// file. It gives back an UGraphReader object and this object
   /// can read more maps, labeled nodes, edges, undirected edges and 
   /// attributes.
@@ -790 +790 @@
   /// \param g The graph.
   template<typename Graph>
-  UndirGraphReader<Graph> undirGraphReader(const std::string& fn, Graph &g) {
+  UGraphReader<Graph> uGraphReader(const std::string& fn, Graph &g) {
     return GraphReader<Graph>(fn, g);
   }

lemon/graph_to_eps.h

@@ -235 +235 @@
   char *_nodePsTextsPreamble;
   
-  bool _undir;
+  bool _u;
   bool _pleaseRemoveOsStream;
 
@@ -273 +273 @@
     _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
     _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
-    _undir(false),
+    _u(false),
     _pleaseRemoveOsStream(_pros), _scaleToA4(false),
     _nodeTextColorType(SAME_COL), _nodeTextColors(Color(0,0,0)),
@@ -330 +330 @@
   using T::_nodePsTextsPreamble;
   
-  using T::_undir;
+  using T::_u;
   using T::_pleaseRemoveOsStream;
 
@@ -735 +735 @@
   ///Sets whether the the graph is undirected
   ///
-  GraphToEps<T> &undir(bool b=true) {_undir=b;return *this;}
+  GraphToEps<T> &u(bool b=true) {_u=b;return *this;}
   ///Sets whether the the graph is directed
 
   ///Sets whether the the graph is directed.
   ///Use it to show the undirected edges as a pair of directed ones.
-  GraphToEps<T> &bidir(bool b=true) {_undir=!b;return *this;}
+  GraphToEps<T> &bidir(bool b=true) {_u=!b;return *this;}
 
   ///Sets the title.
@@ -959 +959 @@
         std::vector<Edge> el;
         for(EdgeIt e(g);e!=INVALID;++e)
-          if((!_undir||g.source(e)<g.target(e))&&_edgeWidths[e]>0)
+          if((!_u||g.source(e)<g.target(e))&&_edgeWidths[e]>0)
             el.push_back(e);
         std::sort(el.begin(),el.end(),edgeLess(g));
@@ -1047 +1047 @@
       }
       else for(EdgeIt e(g);e!=INVALID;++e)
-        if((!_undir||g.source(e)<g.target(e))&&_edgeWidths[e]>0)
+        if((!_u||g.source(e)<g.target(e))&&_edgeWidths[e]>0)
           if(_drawArrows) {
             xy<double> d(mycoords[g.target(e)]-mycoords[g.source(e)]);

lemon/graph_utils.h

@@ -72 +72 @@
   ///This \c \#define creates the same convenience typedefs as defined by
   ///\ref GRAPH_TYPEDEFS(Graph) and three more, namely it creates
-  ///\c UndirEdge, \c UndirEdgeIt, \c IncEdgeIt,
-  ///\c BoolUndirEdgeMap, \c IntUndirEdgeMap,  \c DoubleUndirEdgeMap.  
+  ///\c UEdge, \c UEdgeIt, \c IncEdgeIt,
+  ///\c BoolUEdgeMap, \c IntUEdgeMap,  \c DoubleUEdgeMap.  
   ///
   ///\note If \c G it a template parameter, it should be used in this way.
@@ -84 +84 @@
 #define UNDIRGRAPH_TYPEDEFS(Graph)                              \
   GRAPH_TYPEDEFS(Graph)                                         \
-    typedef Graph:: UndirEdge   UndirEdge;                      \
-    typedef Graph:: UndirEdgeIt UndirEdgeIt;                    \
+    typedef Graph:: UEdge   UEdge;                      \
+    typedef Graph:: UEdgeIt UEdgeIt;                    \
     typedef Graph:: IncEdgeIt   IncEdgeIt;                     
-//     typedef Graph::template UndirEdgeMap<bool> BoolUndirEdgeMap;      
-//     typedef Graph::template UndirEdgeMap<int> IntUndirEdgeMap;
-//     typedef Graph::template UndirEdgeMap<double> DoubleUndirEdgeMap;
+//     typedef Graph::template UEdgeMap<bool> BoolUEdgeMap;      
+//     typedef Graph::template UEdgeMap<int> IntUEdgeMap;
+//     typedef Graph::template UEdgeMap<double> DoubleUEdgeMap;
   
 
@@ -163 +163 @@
   inline
   typename enable_if<typename Graph::EdgeNumTag, int>::type
-  _countUndirEdges(const Graph &g) {
-    return g.undirEdgeNum();
-  }
-
-  template <typename Graph>
-  inline int _countUndirEdges(Wrap<Graph> w) {
-    return countItems<Graph, typename Graph::UndirEdgeIt>(w.value);
+  _countUEdges(const Graph &g) {
+    return g.uEdgeNum();
+  }
+
+  template <typename Graph>
+  inline int _countUEdges(Wrap<Graph> w) {
+    return countItems<Graph, typename Graph::UEdgeIt>(w.value);
   }
 
@@ -179 +179 @@
 
   template <typename Graph>
-  inline int countUndirEdges(const Graph& g) {
-    return _countUndirEdges<Graph>(g);
+  inline int countUEdges(const Graph& g) {
+    return _countUEdges<Graph>(g);
   }
 
@@ -326 +326 @@
   typename enable_if<
     typename Graph::FindEdgeTag, 
-    typename Graph::UndirEdge>::type 
-  _findUndirEdge(const Graph &g,
+    typename Graph::UEdge>::type 
+  _findUEdge(const Graph &g,
             typename Graph::Node u, typename Graph::Node v,
-            typename Graph::UndirEdge prev = INVALID) {
-    return g.findUndirEdge(u, v, prev);
-  }
-
-  template <typename Graph>
-  inline typename Graph::UndirEdge 
-  _findUndirEdge(Wrap<Graph> w,
+            typename Graph::UEdge prev = INVALID) {
+    return g.findUEdge(u, v, prev);
+  }
+
+  template <typename Graph>
+  inline typename Graph::UEdge 
+  _findUEdge(Wrap<Graph> w,
             typename Graph::Node u, 
             typename Graph::Node v,
-            typename Graph::UndirEdge prev = INVALID) {
+            typename Graph::UEdge prev = INVALID) {
     const Graph& g = w.value;
     if (prev == INVALID) {
@@ -351 +351 @@
   }
 
-  /// \brief Finds an undir edge between two nodes of a graph.
-  ///
-  /// Finds an undir edge from node \c u to node \c v in graph \c g.
+  /// \brief Finds an uedge between two nodes of a graph.
+  ///
+  /// Finds an uedge from node \c u to node \c v in graph \c g.
   ///
   /// If \c prev is \ref INVALID (this is the default value), then
@@ -362 +362 @@
   /// Thus you can iterate through each edge from \c u to \c v as it follows.
   /// \code
-  /// for(UndirEdge e = findUndirEdge(g,u,v); e != INVALID; 
-  ///     e = findUndirEdge(g,u,v,e)) {
+  /// for(UEdge e = findUEdge(g,u,v); e != INVALID; 
+  ///     e = findUEdge(g,u,v,e)) {
   ///   ...
   /// }
@@ -370 +370 @@
   // /// interface here...
   template <typename Graph>
-  inline typename Graph::UndirEdge 
-  findUndirEdge(const Graph &g,
+  inline typename Graph::UEdge 
+  findUEdge(const Graph &g,
                 typename Graph::Node u, 
                 typename Graph::Node v,
-                typename Graph::UndirEdge prev = INVALID) {
-    return _findUndirEdge<Graph>(g, u, v, prev);
-  }
-
-  /// \brief Iterator for iterating on undir edges connected the same nodes.
-  ///
-  /// Iterator for iterating on undir edges connected the same nodes. It is 
-  /// higher level interface for the findUndirEdge() function. You can
+                typename Graph::UEdge prev = INVALID) {
+    return _findUEdge<Graph>(g, u, v, prev);
+  }
+
+  /// \brief Iterator for iterating on uedges connected the same nodes.
+  ///
+  /// Iterator for iterating on uedges connected the same nodes. It is 
+  /// higher level interface for the findUEdge() function. You can
   /// use it the following way:
   /// \code
-  /// for (ConUndirEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
+  /// for (ConUEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
   ///   ...
   /// }
@@ -391 +391 @@
   /// \author Balazs Dezso 
   template <typename _Graph>
-  class ConUndirEdgeIt : public _Graph::UndirEdge {
+  class ConUEdgeIt : public _Graph::UEdge {
   public:
 
     typedef _Graph Graph;
-    typedef typename Graph::UndirEdge Parent;
-
-    typedef typename Graph::UndirEdge UndirEdge;
+    typedef typename Graph::UEdge Parent;
+
+    typedef typename Graph::UEdge UEdge;
     typedef typename Graph::Node Node;
 
     /// \brief Constructor.
     ///
-    /// Construct a new ConUndirEdgeIt iterating on the edges which
+    /// Construct a new ConUEdgeIt iterating on the edges which
     /// connects the \c u and \c v node.
-    ConUndirEdgeIt(const Graph& g, Node u, Node v) : graph(g) {
-      Parent::operator=(findUndirEdge(graph, u, v));
+    ConUEdgeIt(const Graph& g, Node u, Node v) : graph(g) {
+      Parent::operator=(findUEdge(graph, u, v));
     }
 
     /// \brief Constructor.
     ///
-    /// Construct a new ConUndirEdgeIt which continues the iterating from 
+    /// Construct a new ConUEdgeIt which continues the iterating from 
     /// the \c e edge.
-    ConUndirEdgeIt(const Graph& g, UndirEdge e) : Parent(e), graph(g) {}
+    ConUEdgeIt(const Graph& g, UEdge e) : Parent(e), graph(g) {}
     
     /// \brief Increment operator.
     ///
     /// It increments the iterator and gives back the next edge.
-    ConUndirEdgeIt& operator++() {
-      Parent::operator=(findUndirEdge(graph, graph.source(*this), 
+    ConUEdgeIt& operator++() {
+      Parent::operator=(findUEdge(graph, graph.source(*this), 
                                       graph.target(*this), *this));
       return *this;
@@ -597 +597 @@
   ///
   /// Class to copy an undirected graph to an other graph (duplicate a graph).
-  /// The simplest way of using it is through the \c copyUndirGraph() function.
+  /// The simplest way of using it is through the \c copyUGraph() function.
   template <typename Target, typename Source>
-  class UndirGraphCopy {
+  class UGraphCopy {
   public: 
     typedef typename Source::Node Node;
@@ -605 +605 @@
     typedef typename Source::Edge Edge;
     typedef typename Source::EdgeIt EdgeIt;
-    typedef typename Source::UndirEdge UndirEdge;
-    typedef typename Source::UndirEdgeIt UndirEdgeIt;
+    typedef typename Source::UEdge UEdge;
+    typedef typename Source::UEdgeIt UEdgeIt;
 
     typedef typename Source::
@@ -612 +612 @@
     
     typedef typename Source::
-    template UndirEdgeMap<typename Target::UndirEdge> UndirEdgeRefMap;
+    template UEdgeMap<typename Target::UEdge> UEdgeRefMap;
 
   private:
 
     struct EdgeRefMap {
-      EdgeRefMap(UndirGraphCopy& _gc) : gc(_gc) {}
+      EdgeRefMap(UGraphCopy& _gc) : gc(_gc) {}
       typedef typename Source::Edge Key;
       typedef typename Target::Edge Value;
 
       Value operator[](const Key& key) {
-        return gc.target.direct(gc.undirEdgeRef[key], 
+        return gc.target.direct(gc.uEdgeRef[key], 
                                 gc.target.direction(key));
       }
       
-      UndirGraphCopy& gc;
+      UGraphCopy& gc;
     };
     
   public:
 
-    /// \brief Constructor for the UndirGraphCopy.
+    /// \brief Constructor for the UGraphCopy.
     ///
     /// It copies the content of the \c _source graph into the
     /// \c _target graph. It creates also two references, one beetween
     /// the two nodeset and one beetween the two edgesets.
-    UndirGraphCopy(Target& _target, const Source& _source) 
+    UGraphCopy(Target& _target, const Source& _source) 
       : source(_source), target(_target), 
-        nodeRefMap(_source), edgeRefMap(*this), undirEdgeRefMap(_source) {
+        nodeRefMap(_source), edgeRefMap(*this), uEdgeRefMap(_source) {
       for (NodeIt it(source); it != INVALID; ++it) {
         nodeRefMap[it] = target.addNode();
       }
-      for (UndirEdgeIt it(source); it != INVALID; ++it) {
-        undirEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)], 
+      for (UEdgeIt it(source); it != INVALID; ++it) {
+        uEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)], 
                                         nodeRefMap[source.target(it)]);
       }
@@ -652 +652 @@
     /// Copies the node references into the given map.
     template <typename NodeRef>
-    const UndirGraphCopy& nodeRef(NodeRef& map) const {
+    const UGraphCopy& nodeRef(NodeRef& map) const {
       for (NodeIt it(source); it != INVALID; ++it) {
         map.set(it, nodeRefMap[it]);
@@ -663 +663 @@
     /// Reverse and copies the node references into the given map.
     template <typename NodeRef>
-    const UndirGraphCopy& nodeCrossRef(NodeRef& map) const {
+    const UGraphCopy& nodeCrossRef(NodeRef& map) const {
       for (NodeIt it(source); it != INVALID; ++it) {
         map.set(nodeRefMap[it], it);
@@ -674 +674 @@
     /// Copies the edge references into the given map.
     template <typename EdgeRef>
-    const UndirGraphCopy& edgeRef(EdgeRef& map) const {
+    const UGraphCopy& edgeRef(EdgeRef& map) const {
       for (EdgeIt it(source); it != INVALID; ++it) {
         map.set(edgeRefMap[it], it);
@@ -686 +686 @@
     /// Reverse and copies the undirected edge references into the given map.
     template <typename EdgeRef>
-    const UndirGraphCopy& edgeCrossRef(EdgeRef& map) const {
+    const UGraphCopy& edgeCrossRef(EdgeRef& map) const {
       for (EdgeIt it(source); it != INVALID; ++it) {
         map.set(it, edgeRefMap[it]);
@@ -697 +697 @@
     /// Copies the undirected edge references into the given map.
     template <typename EdgeRef>
-    const UndirGraphCopy& undirEdgeRef(EdgeRef& map) const {
-      for (UndirEdgeIt it(source); it != INVALID; ++it) {
-        map.set(it, undirEdgeRefMap[it]);
+    const UGraphCopy& uEdgeRef(EdgeRef& map) const {
+      for (UEdgeIt it(source); it != INVALID; ++it) {
+        map.set(it, uEdgeRefMap[it]);
       }
       return *this;
@@ -709 +709 @@
     /// Reverse and copies the undirected edge references into the given map.
     template <typename EdgeRef>
-    const UndirGraphCopy& undirEdgeCrossRef(EdgeRef& map) const {
-      for (UndirEdgeIt it(source); it != INVALID; ++it) {
-        map.set(undirEdgeRefMap[it], it);
+    const UGraphCopy& uEdgeCrossRef(EdgeRef& map) const {
+      for (UEdgeIt it(source); it != INVALID; ++it) {
+        map.set(uEdgeRefMap[it], it);
       }
       return *this;
@@ -723 +723 @@
     /// type.  
     template <typename TargetMap, typename SourceMap>
-    const UndirGraphCopy& nodeMap(TargetMap& tMap, 
+    const UGraphCopy& nodeMap(TargetMap& tMap, 
                                   const SourceMap& sMap) const {
       copyMap(tMap, sMap, NodeIt(source), nodeRefMap);
@@ -736 +736 @@
     /// type.  
     template <typename TargetMap, typename SourceMap>
-    const UndirGraphCopy& edgeMap(TargetMap& tMap, 
+    const UGraphCopy& edgeMap(TargetMap& tMap, 
                                   const SourceMap& sMap) const {
       copyMap(tMap, sMap, EdgeIt(source), edgeRefMap);
@@ -749 +749 @@
     /// type.  
     template <typename TargetMap, typename SourceMap>
-    const UndirGraphCopy& undirEdgeMap(TargetMap& tMap, 
+    const UGraphCopy& uEdgeMap(TargetMap& tMap, 
                                   const SourceMap& sMap) const {
-      copyMap(tMap, sMap, UndirEdgeIt(source), undirEdgeRefMap);
+      copyMap(tMap, sMap, UEdgeIt(source), uEdgeRefMap);
       return *this;
     }
@@ -769 +769 @@
     }
 
-    /// \brief Gives back the stored undir edge references.
-    ///
-    /// Gives back the stored undir edge references.
-    const UndirEdgeRefMap& undirEdgeRef() const {
-      return undirEdgeRefMap;
+    /// \brief Gives back the stored uedge references.
+    ///
+    /// Gives back the stored uedge references.
+    const UEdgeRefMap& uEdgeRef() const {
+      return uEdgeRefMap;
     }
 
@@ -785 +785 @@
     NodeRefMap nodeRefMap;
     EdgeRefMap edgeRefMap;
-    UndirEdgeRefMap undirEdgeRefMap;
+    UEdgeRefMap uEdgeRefMap;
   };
 
@@ -802 +802 @@
   /// edges.
   template <typename Target, typename Source>
-  UndirGraphCopy<Target, Source> 
-  copyUndirGraph(Target& target, const Source& source) {
-    return UndirGraphCopy<Target, Source>(target, source);
+  UGraphCopy<Target, Source> 
+  copyUGraph(Target& target, const Source& source) {
+    return UGraphCopy<Target, Source>(target, source);
   }
 
@@ -906 +906 @@
     typedef _Graph Graph;
 
-    /// The key type of InvertableMap (Node, Edge, UndirEdge).
+    /// The key type of InvertableMap (Node, Edge, UEdge).
     typedef typename _Map::Key Key;
     /// The value type of the InvertableMap.
@@ -1037 +1037 @@
   /// \param _Graph The graph class the \c DescriptorMap belongs to.
   /// \param _Item The Item is the Key of the Map. It may be Node, Edge or 
-  /// UndirEdge.
+  /// UEdge.
 #ifndef DOXYGEN
   /// \param _Map A ReadWriteMap mapping from the item type to integer.
@@ -1056 +1056 @@
     typedef _Graph Graph;
 
-    /// The key type of DescriptorMap (Node, Edge, UndirEdge).
+    /// The key type of DescriptorMap (Node, Edge, UEdge).
     typedef typename _Map::Key Key;
     /// The value type of DescriptorMap.
@@ -1297 +1297 @@
 
     typedef typename Graph::Edge Value;
-    typedef typename Graph::UndirEdge Key;
+    typedef typename Graph::UEdge Key;
 
     /// \brief Constructor
@@ -1336 +1336 @@
 
     typedef typename Graph::Edge Value;
-    typedef typename Graph::UndirEdge Key;
+    typedef typename Graph::UEdge Key;
 
     /// \brief Constructor

lemon/graph_writer.h

@@ -316 +316 @@
   /// \brief The undirected graph writer class.
   ///
-  /// The \c UndirGraphWriter class provides the undir graph output. To write 
+  /// The \c UGraphWriter class provides the ugraph output. To write 
   /// a graph you should first give writing commands to the writer. You can 
-  /// declare write command as \c NodeMap, \c EdgeMap or \c UndirEdgeMap 
-  /// writing and labeled Node, Edge or UndirEdge writing.
-  ///
-  /// \code
-  /// UndirGraphWriter<UndirListGraph> writer(std::cout, graph);
+  /// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap 
+  /// writing and labeled Node, Edge or UEdge writing.
+  ///
+  /// \code
+  /// UGraphWriter<ListUGraph> writer(std::cout, graph);
   /// \endcode
   ///
   /// The \c writeNodeMap() function declares a \c NodeMap writing 
-  /// command in the \c UndirGraphWriter. You should give as parameter 
+  /// command in the \c UGraphWriter. You should give as parameter 
   /// the name of the map and the map object. The NodeMap writing 
   /// command with name "label" should write a unique map because it 
@@ -332 +332 @@
   ///
   /// \code
-  /// IdMap<UndirListGraph, Node> nodeLabelMap;
+  /// IdMap<ListUGraph, Node> nodeLabelMap;
   /// writer.writeNodeMap("label", nodeLabelMap);
   ///
@@ -339 +339 @@
   /// \endcode
   ///
-  /// With the \c writeUndirEdgeMap() member function you can give an 
+  /// With the \c writeUEdgeMap() member function you can give an 
   /// undirected edge map writing command similar to the NodeMaps.
   ///
@@ -345 +345 @@
   /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 
   ///   edgeDescMap(graph);
-  /// writer.writeUndirEdgeMap("descriptor", edgeDescMap);
-  ///
-  /// writer.writeUndirEdgeMap("weight", weightMap);
-  /// writer.writeUndirEdgeMap("label", labelMap);
+  /// writer.writeUEdgeMap("descriptor", edgeDescMap);
+  ///
+  /// writer.writeUEdgeMap("weight", weightMap);
+  /// writer.writeUEdgeMap("label", labelMap);
   /// \endcode
   /// 
@@ -359 +359 @@
   ///
   ///
-  /// With \c writeNode() and \c writeUndirEdge() functions you can 
+  /// With \c writeNode() and \c writeUEdge() functions you can 
   /// designate nodes and undirected edges in the graph. For example, you can 
   /// write out the source and target of the graph.
@@ -367 +367 @@
   /// writer.writeNode("target", targetNode);
   ///
-  /// writer.writeUndirEdge("observed", undirEdge);
+  /// writer.writeUEdge("observed", uEdge);
   /// \endcode
   ///
@@ -385 +385 @@
   /// \author Balazs Dezso
   template <typename _Graph, typename _WriterTraits = DefaultWriterTraits> 
-  class UndirGraphWriter {
+  class UGraphWriter {
   public:
     
@@ -391 +391 @@
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::UndirEdge UndirEdge;
+    typedef typename Graph::UEdge UEdge;
 
     typedef _WriterTraits WriterTraits;
 
-    /// \brief Construct a new UndirGraphWriter.
-    ///
-    /// Construct a new UndirGraphWriter. It writes the given graph
+    /// \brief Construct a new UGraphWriter.
+    ///
+    /// Construct a new UGraphWriter. It writes the given graph
     /// to the given stream.
-    UndirGraphWriter(std::ostream& _os, const Graph& _graph) 
+    UGraphWriter(std::ostream& _os, const Graph& _graph) 
       : writer(new LemonWriter(_os)), own_writer(true), 
         nodeset_writer(*writer, _graph, std::string()),
-        undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
+        u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
         node_writer(*writer, nodeset_writer, std::string()),
-        undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
+        u_edge_writer(*writer, u_edgeset_writer, std::string()),
         attribute_writer(*writer, std::string()) {}
 
-    /// \brief Construct a new UndirGraphWriter.
-    ///
-    /// Construct a new UndirGraphWriter. It writes the given graph
+    /// \brief Construct a new UGraphWriter.
+    ///
+    /// Construct a new UGraphWriter. It writes the given graph
     /// to the given file.
-    UndirGraphWriter(const std::string& _filename, const Graph& _graph) 
+    UGraphWriter(const std::string& _filename, const Graph& _graph) 
       : writer(new LemonWriter(_filename)), own_writer(true), 
         nodeset_writer(*writer, _graph, std::string()),
-        undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
+        u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
         node_writer(*writer, nodeset_writer, std::string()),
-        undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
+        u_edge_writer(*writer, u_edgeset_writer, std::string()),
         attribute_writer(*writer, std::string()) {}
 
-    /// \brief Construct a new UndirGraphWriter.
-    ///
-    /// Construct a new UndirGraphWriter. It writes the given graph
+    /// \brief Construct a new UGraphWriter.
+    ///
+    /// Construct a new UGraphWriter. It writes the given graph
     /// to given LemonReader.
-    UndirGraphWriter(LemonWriter& _writer, const Graph& _graph)
+    UGraphWriter(LemonWriter& _writer, const Graph& _graph)
       : writer(_writer), own_writer(false), 
         nodeset_writer(*writer, _graph, std::string()),
-        undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
+        u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
         node_writer(*writer, nodeset_writer, std::string()),
-        undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
+        u_edge_writer(*writer, u_edgeset_writer, std::string()),
         attribute_writer(*writer, std::string()) {}
 
@@ -434 +434 @@
     ///
     /// Destruct the graph writer.
-    ~UndirGraphWriter() {
+    ~UGraphWriter() {
       if (own_writer) 
         delete writer;
@@ -443 +443 @@
    /// This function issues a new <i> node map writing command</i> to the writer.
     template <typename Map>
-    UndirGraphWriter& writeNodeMap(std::string name, const Map& map) {
+    UGraphWriter& writeNodeMap(std::string name, const Map& map) {
       nodeset_writer.writeNodeMap(name, map);
       return *this;
@@ -452 +452 @@
    /// This function issues a new <i> node map writing command</i> to the writer.
     template <typename Writer, typename Map>
-    UndirGraphWriter& writeNodeMap(std::string name, const Map& map, 
+    UGraphWriter& writeNodeMap(std::string name, const Map& map, 
                               const Writer& writer = Writer()) {
       nodeset_writer.writeNodeMap(name, map, writer);
@@ -462 +462 @@
    /// This function issues a new <i> edge map writing command</i> to the writer.
     template <typename Map>
-    UndirGraphWriter& writeEdgeMap(std::string name, const Map& map) { 
-      undir_edgeset_writer.writeEdgeMap(name, map);
+    UGraphWriter& writeEdgeMap(std::string name, const Map& map) { 
+      u_edgeset_writer.writeEdgeMap(name, map);
       return *this;
     }
@@ -471 +471 @@
    /// This function issues a new <i> edge map writing command</i> to the writer.
     template <typename Writer, typename Map>
-    UndirGraphWriter& writeEdgeMap(std::string name, const Map& map,
+    UGraphWriter& writeEdgeMap(std::string name, const Map& map,
                                    const Writer& writer = Writer()) {
-      undir_edgeset_writer.writeEdgeMap(name, map, writer);
+      u_edgeset_writer.writeEdgeMap(name, map, writer);
       return *this;
     }
@@ -482 +482 @@
     /// command</i> to the writer.
     template <typename Map>
-    UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map) { 
-      undir_edgeset_writer.writeUndirEdgeMap(name, map);
+    UGraphWriter& writeUEdgeMap(std::string name, const Map& map) { 
+      u_edgeset_writer.writeUEdgeMap(name, map);
       return *this;
     }
@@ -492 +492 @@
     /// command</i> to the writer.
    template <typename Writer, typename Map>
-    UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map,
+    UGraphWriter& writeUEdgeMap(std::string name, const Map& map,
                                         const Writer& writer = Writer()) {
-      undir_edgeset_writer.writeUndirEdgeMap(name, map, writer);
+      u_edgeset_writer.writeUEdgeMap(name, map, writer);
       return *this;
     }
@@ -502 +502 @@
     /// This function issues a new <i> labeled node writing
     /// command</i> to the writer.
-    UndirGraphWriter& writeNode(std::string name, const Node& node) {
+    UGraphWriter& writeNode(std::string name, const Node& node) {
       node_writer.writeNode(name, node);
       return *this;
@@ -511 +511 @@
     /// This function issues a new <i> labeled edge writing
     /// command</i> to the writer.
-    UndirGraphWriter& writeEdge(std::string name, const Edge& edge) {
-      undir_edge_writer.writeEdge(name, edge);
+    UGraphWriter& writeEdge(std::string name, const Edge& edge) {
+      u_edge_writer.writeEdge(name, edge);
     }
 
@@ -520 +520 @@
     /// Issue a new <i>labeled undirected edge writing command</i> to
     /// the writer.
-    UndirGraphWriter& writeUndirEdge(std::string name, const UndirEdge& edge) {
-      undir_edge_writer.writeUndirEdge(name, edge);
+    UGraphWriter& writeUEdge(std::string name, const UEdge& edge) {
+      u_edge_writer.writeUEdge(name, edge);
     }
 
@@ -529 +529 @@
     /// command</i> to the writer.
     template <typename Value>
-    UndirGraphWriter& writeAttribute(std::string name, const Value& value) {
+    UGraphWriter& writeAttribute(std::string name, const Value& value) {
       attribute_writer.writeAttribute(name, value);
       return *this;
@@ -539 +539 @@
     /// command</i> to the writer.
     template <typename Writer, typename Value>
-    UndirGraphWriter& writeAttribute(std::string name, const Value& value, 
+    UGraphWriter& writeAttribute(std::string name, const Value& value, 
                                const Writer& writer) {
       attribute_writer.writeAttribute<Writer>(name, value, writer);
@@ -575 +575 @@
     /// named edge map then it will write the map value belonging to the edge.
     void writeLabel(std::ostream& os, const Edge& item) const {
-      undir_edgeset_writer.writeLabel(os, item);
+      u_edgeset_writer.writeLabel(os, item);
     } 
 
@@ -583 +583 @@
     /// an "label" named edge map then it will write the map value belonging to 
     /// the edge.
-    void writeLabel(std::ostream& os, const UndirEdge& item) const {
-      undir_edgeset_writer.writeLabel(os, item);
+    void writeLabel(std::ostream& os, const UEdge& item) const {
+      u_edgeset_writer.writeLabel(os, item);
     } 
 
@@ -594 +594 @@
 
     NodeSetWriter<Graph, WriterTraits> nodeset_writer;
-    UndirEdgeSetWriter<Graph, WriterTraits> undir_edgeset_writer;
+    UEdgeSetWriter<Graph, WriterTraits> u_edgeset_writer;
 
     NodeWriter<Graph> node_writer;
-    UndirEdgeWriter<Graph> undir_edge_writer;
+    UEdgeWriter<Graph> u_edge_writer;
     
     AttributeWriter<WriterTraits> attribute_writer;
@@ -605 +605 @@
   ///
   /// It is a helper function to write an undirected graph to the given output
-  /// stream. It gives back an UndirGraphWriter object and this object
+  /// stream. It gives back an UGraphWriter object and this object
   /// can write more maps, labeled nodes and edges and attributes.
   /// \warning Do not forget to call the \c run() function.
@@ -612 +612 @@
   /// \param g The graph.
   template <typename Graph>
-  UndirGraphWriter<Graph> undirGraphWriter(std::ostream& os, const Graph &g) {
-    return UndirGraphWriter<Graph>(os, g);
+  UGraphWriter<Graph> uGraphWriter(std::ostream& os, const Graph &g) {
+    return UGraphWriter<Graph>(os, g);
   }
 
@@ -619 +619 @@
   ///
   /// It is a helper function to write an undirected graph to the given output
-  /// file. It gives back an UndirGraphWriter object and this object
+  /// file. It gives back an UGraphWriter object and this object
   /// can write more maps, labeled nodes, edges, undirected edges and 
   /// attributes.
@@ -628 +628 @@
   /// \param g The graph.
   template <typename Graph>
-  UndirGraphWriter<Graph> undirGraphWriter(const std::string& fn, 
+  UGraphWriter<Graph> uGraphWriter(const std::string& fn, 
                                            const Graph &g) {
-    return UndirGraphWriter<Graph>(fn, g);
+    return UGraphWriter<Graph>(fn, g);
   }
 

lemon/grid_graph.h

@@ -339 +339 @@
 
 
-  typedef StaticMappableUndirGraphExtender<
-    IterableUndirGraphExtender<
-    AlterableUndirGraphExtender<
-    UndirGraphExtender<GridGraphBase> > > > ExtendedGridGraphBase;
+  typedef StaticMappableUGraphExtender<
+    IterableUGraphExtender<
+    AlterableUGraphExtender<
+    UGraphExtender<GridGraphBase> > > > ExtendedGridGraphBase;
 
   /// \ingroup graphs
@@ -365 +365 @@
   /// \endcode
   ///
-  /// The graph type is fully conform to the \ref concept::UndirGraph
+  /// The graph type is fully conform to the \ref concept::UGraph
   /// "Undirected Graph" concept.
   ///
@@ -464 +464 @@
     /// outgoing edge then it gives back INVALID.
     Edge down(Node n) const {
-      UndirEdge ue = _down(n);
+      UEdge ue = _down(n);
       return ue != INVALID ? direct(ue, true) : INVALID;
     }
@@ -473 +473 @@
     /// outgoing edge then it gives back INVALID.
     Edge up(Node n) const {
-      UndirEdge ue = _up(n);
+      UEdge ue = _up(n);
       return ue != INVALID ? direct(ue, false) : INVALID;
     }
@@ -482 +482 @@
     /// outgoing edge then it gives back INVALID.
     Edge right(Node n) const {
-      UndirEdge ue = _right(n);
+      UEdge ue = _right(n);
       return ue != INVALID ? direct(ue, true) : INVALID;
     }
@@ -491 +491 @@
     /// outgoing edge then it gives back INVALID.
     Edge left(Node n) const {
-      UndirEdge ue = _left(n);
+      UEdge ue = _left(n);
       return ue != INVALID ? direct(ue, false) : INVALID;
     }

lemon/hypercube_graph.h

@@ -255 +255 @@
   ///
   /// The graph type is fully conform to the \ref concept::StaticGraph
-  /// concept but it does not conform to the \ref concept::UndirGraph.
+  /// concept but it does not conform to the \ref concept::UGraph.
   ///
   /// \see HyperCubeGraphBase

lemon/kruskal.h

@@ -52 +52 @@
   /// \param g The graph the algorithm runs on.
   /// It can be either \ref concept::StaticGraph "directed" or 
-  /// \ref concept::UndirGraph "undirected".
+  /// \ref concept::UGraph "undirected".
   /// If the graph is directed, the algorithm consider it to be 
   /// undirected by disregarding the direction of the edges.
@@ -90 +90 @@
   ///
   /// \warning If kruskal is run on an
-  /// \ref lemon::concept::UndirGraph "undirected graph", be sure that the
+  /// \ref lemon::concept::UGraph "undirected graph", be sure that the
   /// map storing the tree is also undirected
-  /// (e.g. UndirListGraph::UndirEdgeMap<bool>, otherwise the values of the
+  /// (e.g. ListUGraph::UEdgeMap<bool>, otherwise the values of the
   /// half of the edges will not be set.
   ///
   /// \todo Discuss the case of undirected graphs: In this case the algorithm
-  /// also require <tt>Edge</tt>s instead of <tt>UndirEdge</tt>s, as some
+  /// also require <tt>Edge</tt>s instead of <tt>UEdge</tt>s, as some
   /// people would expect. So, one should be careful not to add both of the
-  /// <tt>Edge</tt>s belonging to a certain <tt>UndirEdge</tt>.
+  /// <tt>Edge</tt>s belonging to a certain <tt>UEdge</tt>.
   /// (\ref kruskal() and \ref KruskalMapInput are kind enough to do so.)
 
@@ -226 +226 @@
 
     template<class _GR>
-    typename enable_if<typename _GR::UndirTag,void>::type
+    typename enable_if<typename _GR::UTag,void>::type
     fillWithEdges(const _GR& g, const Map& m,dummy<0> = 0) 
     {
-      for(typename GR::UndirEdgeIt e(g);e!=INVALID;++e) 
+      for(typename GR::UEdgeIt e(g);e!=INVALID;++e) 
         push_back(value_type(g.direct(e, true), m[e]));
     }
 
     template<class _GR>
-    typename disable_if<typename _GR::UndirTag,void>::type
+    typename disable_if<typename _GR::UTag,void>::type
     fillWithEdges(const _GR& g, const Map& m,dummy<1> = 1) 
     {

lemon/lemon_reader.h

@@ -105 +105 @@
     class ForwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -135 +135 @@
     class BackwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -1168 +1168 @@
   ///
   /// The lemon format can store multiple undirected edgesets with several 
-  /// maps. The undirected edgeset section's header line is \c \@undiredgeset 
-  /// \c undiredgeset_name, but the \c undiredgeset_name may be empty.
+  /// maps. The undirected edgeset section's header line is \c \@uedgeset 
+  /// \c uedgeset_name, but the \c uedgeset_name may be empty.
   ///
   /// The first line of the section contains the names of the maps separated
@@ -1184 +1184 @@
   /// as id map. This map should contain only unique values and when the 
   /// \c readLabel() member will read a value from the given stream it will
-  /// give back that undiricted edge which is mapped to this value.
+  /// give back that uicted edge which is mapped to this value.
   ///
   /// The undirected edgeset reader needs a node id reader to identify which 
@@ -1192 +1192 @@
   /// \relates LemonReader
   template <typename _Graph, typename _Traits = DefaultReaderTraits>
-  class UndirEdgeSetReader : public LemonReader::SectionReader {
+  class UEdgeSetReader : public LemonReader::SectionReader {
     typedef LemonReader::SectionReader Parent;
   public:
@@ -1200 +1200 @@
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::UndirEdge UndirEdge;
+    typedef typename Graph::UEdge UEdge;
     typedef typename Traits::Skipper DefaultSkipper;
 
     /// \brief Constructor.
     ///
-    /// Constructor for UndirEdgeSetReader. It creates the UndirEdgeSetReader 
+    /// Constructor for UEdgeSetReader. It creates the UEdgeSetReader 
     /// and attach it into the given LemonReader. The undirected edgeset 
     /// reader will add the readed undirected edges to the given Graph. It 
     /// will use the given node id reader to read the source and target 
     /// nodes of the edges. The reader will read the section only if the 
-    /// \c _name and the \c undiredgset_name are the same. 
+    /// \c _name and the \c uedgset_name are the same. 
     template <typename NodeLabelReader>
-    UndirEdgeSetReader(LemonReader& _reader, 
+    UEdgeSetReader(LemonReader& _reader, 
                        Graph& _graph, 
                        const NodeLabelReader& _nodeLabelReader, 
@@ -1224 +1224 @@
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeSetReader.
-    virtual ~UndirEdgeSetReader() {
+    /// Destructor for UEdgeSetReader.
+    virtual ~UEdgeSetReader() {
       for (typename MapReaders::iterator it = readers.begin(); 
            it != readers.end(); ++it) {
@@ -1233 +1233 @@
 
   private:
-    UndirEdgeSetReader(const UndirEdgeSetReader&);
-    void operator=(const UndirEdgeSetReader&);
+    UEdgeSetReader(const UEdgeSetReader&);
+    void operator=(const UEdgeSetReader&);
 
   public:
@@ -1242 +1242 @@
     /// Add a new edge undirected map reader command for the reader.
     template <typename Map>
-    UndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map) {
+    UEdgeSetReader& readUEdgeMap(std::string name, Map& map) {
       return _readMap<
         typename Traits::template Reader<typename Map::Value>, Map, 
@@ -1249 +1249 @@
 
     template <typename Map>
-    UndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map) {
+    UEdgeSetReader& readUEdgeMap(std::string name, const Map& map) {
       return _readMap<
         typename Traits::template Reader<typename Map::Value>, Map, 
@@ -1259 +1259 @@
     /// Add a new edge undirected map reader command for the reader.
     template <typename Reader, typename Map>
-    UndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map, 
+    UEdgeSetReader& readUEdgeMap(std::string name, Map& map, 
                                          const Reader& reader = Reader()) {
       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
@@ -1266 +1266 @@
 
     template <typename Reader, typename Map>
-    UndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map, 
+    UEdgeSetReader& readUEdgeMap(std::string name, const Map& map, 
                                          const Reader& reader = Reader()) {
       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type >
@@ -1275 +1275 @@
 
     template <typename Reader, typename Map, typename MapParameter>
-    UndirEdgeSetReader& _readMap(std::string name, MapParameter map,
+    UEdgeSetReader& _readMap(std::string name, MapParameter map,
                                  const Reader& reader = Reader()) {
-      checkConcept<concept::WriteMap<UndirEdge, typename Map::Value>, Map>();
+      checkConcept<concept::WriteMap<UEdge, typename Map::Value>, Map>();
       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
       if (readers.find(name) != readers.end()) {
@@ -1286 +1286 @@
       readers.insert(
         make_pair(name, new _reader_bits::
-                  MapReader<UndirEdge, Map, Reader>(map, reader)));
+                  MapReader<UEdge, Map, Reader>(map, reader)));
       return *this;
     }
@@ -1296 +1296 @@
     /// Add a new undirected edge map skipper command for the reader.
     template <typename Reader>
-    UndirEdgeSetReader& skipUndirEdgeMap(std::string name, 
+    UEdgeSetReader& skipUEdgeMap(std::string name, 
                                          const Reader& reader = Reader()) {
       if (readers.find(name) != readers.end()) {
@@ -1304 +1304 @@
       }
       readers.insert(make_pair(name, new _reader_bits::
-                               SkipReader<UndirEdge, Reader>(reader)));
+                               SkipReader<UEdge, Reader>(reader)));
       return *this;
     }
@@ -1312 +1312 @@
     /// Add a new directed edge map reader command for the reader.
     template <typename Map>
-    UndirEdgeSetReader& readEdgeMap(std::string name, Map& map) {
+    UEdgeSetReader& readEdgeMap(std::string name, Map& map) {
       return _readDirMap<
         typename Traits::template Reader<typename Map::Value>, Map,
@@ -1319 +1319 @@
 
     template <typename Map>
-    UndirEdgeSetReader& readEdgeMap(std::string name, const Map& map) {
+    UEdgeSetReader& readEdgeMap(std::string name, const Map& map) {
       return _readDirMap<
         typename Traits::template Reader<typename Map::Value>, Map,
@@ -1329 +1329 @@
     /// Add a new directed edge map reader command for the reader.
     template <typename Reader, typename Map>
-    UndirEdgeSetReader& readEdgeMap(std::string name, Map& map, 
+    UEdgeSetReader& readEdgeMap(std::string name, Map& map, 
                                     const Reader& reader = Reader()) {
       return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
@@ -1336 +1336 @@
 
     template <typename Reader, typename Map>
-    UndirEdgeSetReader& readEdgeMap(std::string name, const Map& map, 
+    UEdgeSetReader& readEdgeMap(std::string name, const Map& map, 
                                     const Reader& reader = Reader()) {
       return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
@@ -1345 +1345 @@
 
     template <typename Reader, typename Map, typename MapParameter>
-    UndirEdgeSetReader& _readDirMap(std::string name, MapParameter map,
+    UEdgeSetReader& _readDirMap(std::string name, MapParameter map,
                                     const Reader& reader = Reader()) { 
       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
@@ -1362 +1362 @@
     /// Add a new directed edge map skipper command for the reader.
     template <typename Reader>
-    UndirEdgeSetReader& skipEdgeMap(std::string name, 
+    UEdgeSetReader& skipEdgeMap(std::string name, 
                                     const Reader& reader = Reader()) {
       skipMap("+" + name, reader);
@@ -1374 +1374 @@
     /// the section with the given header line.
     ///
-    /// It gives back true when the header line starts with \c \@undiredgeset,
+    /// It gives back true when the header line starts with \c \@uedgeset,
     /// and the header line's name and the edgeset's name are the same.
     virtual bool header(const std::string& line) {
@@ -1381 +1381 @@
       std::string id;
       ls >> command >> name;
-      return command == "@undiredgeset" && name == id;
+      return command == "@uedgeset" && name == id;
     }
 
@@ -1391 +1391 @@
         throw DataFormatError("Cannot find nodeset or label map");
       }
-      std::vector<_reader_bits::MapReaderBase<UndirEdge>* > index;
+      std::vector<_reader_bits::MapReaderBase<UEdge>* > index;
       std::string line;
 
@@ -1422 +1422 @@
         Node from = nodeLabelReader->read(ls);
         Node to = nodeLabelReader->read(ls);
-        UndirEdge edge = graph.addEdge(from, to);
+        UEdge edge = graph.addEdge(from, to);
         for (int i = 0; i < (int)index.size(); ++i) {
           index[i]->read(ls, edge);
@@ -1443 +1443 @@
     /// It reads an id from the stream and gives back which undirected edge 
     /// belongs to it. It is possible only if there was read an "label" named map.
-    void readLabel(std::istream& is, UndirEdge& undirEdge) const {
-      undirEdge = inverter->read(is);
+    void readLabel(std::istream& is, UEdge& uEdge) const {
+      uEdge = inverter->read(is);
     } 
 
@@ -1456 +1456 @@
       char c;
       is >> c;
-      UndirEdge undirEdge = inverter->read(is);
+      UEdge uEdge = inverter->read(is);
       if (c == '+') {
-        edge = graph.direct(undirEdge, true);
+        edge = graph.direct(uEdge, true);
       } else if (c == '-') {
-        edge = graph.direct(undirEdge, false);
+        edge = graph.direct(uEdge, false);
       } else {
         throw DataFormatError("Wrong id format for edge "
@@ -1470 +1470 @@
 
     typedef std::map<std::string, 
-                     _reader_bits::MapReaderBase<UndirEdge>*> MapReaders;
+                     _reader_bits::MapReaderBase<UEdge>*> MapReaders;
     MapReaders readers;
    
     Graph& graph;   
     std::string name;
-    _reader_bits::SkipReader<UndirEdge, DefaultSkipper> skipper;
-
-    std::auto_ptr<_reader_bits::MapInverterBase<UndirEdge> > inverter;
+    _reader_bits::SkipReader<UEdge, DefaultSkipper> skipper;
+
+    std::auto_ptr<_reader_bits::MapInverterBase<UEdge> > inverter;
     std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
   };
@@ -1697 +1697 @@
   /// \brief SectionReader for reading labeled undirected edges.
   ///
-  /// The undirected edges section's header line is \c \@undiredges 
-  /// \c undiredges_name, but the \c undiredges_name may be empty.
+  /// The undirected edges section's header line is \c \@uedges 
+  /// \c uedges_name, but the \c uedges_name may be empty.
   ///
   /// Each line in the section contains the name of the undirected edge 
@@ -1705 +1705 @@
   /// \relates LemonReader
   template <typename _Graph>
-  class UndirEdgeReader : public LemonReader::SectionReader {
+  class UEdgeReader : public LemonReader::SectionReader {
     typedef LemonReader::SectionReader Parent;
     typedef _Graph Graph;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::UndirEdge UndirEdge;
+    typedef typename Graph::UEdge UEdge;
   public:
     
     /// \brief Constructor.
     ///
-    /// Constructor for UndirEdgeReader. It creates the UndirEdgeReader and
+    /// Constructor for UEdgeReader. It creates the UEdgeReader and
     /// attach it into the given LemonReader. It will use the given
     /// undirected edge id reader to give back the edges. The reader will 
-    /// read the section only if the \c _name and the \c undiredges_name are 
+    /// read the section only if the \c _name and the \c uedges_name are 
     /// the same. 
     template <typename _LabelReader>
-    UndirEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader, 
+    UEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader, 
                const std::string& _name = std::string()) 
       : Parent(_reader), name(_name) {
-      checkConcept<_reader_bits::ItemLabelReader<UndirEdge>, _LabelReader>();
+      checkConcept<_reader_bits::ItemLabelReader<UEdge>, _LabelReader>();
       checkConcept<_reader_bits::ItemLabelReader<Edge>, _LabelReader>();
-      undirEdgeLabelReader.reset(new _reader_bits::
-                              LabelReader<UndirEdge, _LabelReader>(_labelReader));
+      uEdgeLabelReader.reset(new _reader_bits::
+                              LabelReader<UEdge, _LabelReader>(_labelReader));
       edgeLabelReader.reset(new _reader_bits::
                          LabelReader<Edge, _LabelReader>(_labelReader));
@@ -1733 +1733 @@
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeReader.
-    virtual ~UndirEdgeReader() {}
+    /// Destructor for UEdgeReader.
+    virtual ~UEdgeReader() {}
   private:
-    UndirEdgeReader(const UndirEdgeReader&);
-    void operator=(const UndirEdgeReader&);
-
-  public:
-
-    /// \brief Add an undirected edge reader command for the UndirEdgeReader.
-    ///
-    /// Add an undirected edge reader command for the UndirEdgeReader.
-    void readUndirEdge(const std::string& name, UndirEdge& item) {
-      if (undirEdgeReaders.find(name) != undirEdgeReaders.end()) {
+    UEdgeReader(const UEdgeReader&);
+    void operator=(const UEdgeReader&);
+
+  public:
+
+    /// \brief Add an undirected edge reader command for the UEdgeReader.
+    ///
+    /// Add an undirected edge reader command for the UEdgeReader.
+    void readUEdge(const std::string& name, UEdge& item) {
+      if (uEdgeReaders.find(name) != uEdgeReaders.end()) {
         ErrorMessage msg;
         msg << "Multiple read rule for undirected edge: " << name;
         throw IOParameterError(msg.message());
       }
-      undirEdgeReaders.insert(make_pair(name, _reader_bits::
-                                        ItemStore<UndirEdge>(item)));
-    }
-
-    /// \brief Add an edge reader command for the UndirEdgeReader.
-    ///
-    /// Add an edge reader command for the UndirEdgeReader.
+      uEdgeReaders.insert(make_pair(name, _reader_bits::
+                                        ItemStore<UEdge>(item)));
+    }
+
+    /// \brief Add an edge reader command for the UEdgeReader.
+    ///
+    /// Add an edge reader command for the UEdgeReader.
     void readEdge(const std::string& name, Edge& item) {
       if (edgeReaders.find(name) != edgeReaders.end()) {
@@ -1778 +1778 @@
       std::string id;
       ls >> command >> name;
-      return command == "@undiredges" && name == id;
+      return command == "@uedges" && name == id;
     }
 
@@ -1788 +1788 @@
         throw DataFormatError("Cannot find undirected edgeset or label map");
       }
-      if (!undirEdgeLabelReader->isLabelReader()) {
+      if (!uEdgeLabelReader->isLabelReader()) {
         throw DataFormatError("Cannot find undirected edgeset or label map");
       }
@@ -1797 +1797 @@
         ls >> id;
         {
-          typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id);
-          if (it != undirEdgeReaders.end()) {
-            it->second.read(undirEdgeLabelReader->read(ls));
+          typename UEdgeReaders::iterator it = uEdgeReaders.find(id);
+          if (it != uEdgeReaders.end()) {
+            it->second.read(uEdgeLabelReader->read(ls));
             it->second.touch();
             continue;
@@ -1820 +1820 @@
         }
       }
-      for (typename UndirEdgeReaders::iterator it = undirEdgeReaders.begin();
-           it != undirEdgeReaders.end(); ++it) {
+      for (typename UEdgeReaders::iterator it = uEdgeReaders.begin();
+           it != uEdgeReaders.end(); ++it) {
         if (!it->second.touched()) {
           ErrorMessage msg;
-          msg << "UndirEdge not found in file: " << it->first;
+          msg << "UEdge not found in file: " << it->first;
           throw IOParameterError(msg.message());
         }
@@ -1835 +1835 @@
 
     typedef std::map<std::string, 
-                     _reader_bits::ItemStore<UndirEdge> > UndirEdgeReaders;
-    UndirEdgeReaders undirEdgeReaders;
-    std::auto_ptr<_reader_bits::LabelReaderBase<UndirEdge> > undirEdgeLabelReader;
+                     _reader_bits::ItemStore<UEdge> > UEdgeReaders;
+    UEdgeReaders uEdgeReaders;
+    std::auto_ptr<_reader_bits::LabelReaderBase<UEdge> > uEdgeLabelReader;
 
     typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
@@ -2026 +2026 @@
     ///
     /// Gives back how many undirected edgesets are in the file.
-    int undirEdgeSetNum() const {
-      return undiredgesets.size();
+    int uEdgeSetNum() const {
+      return uedgesets.size();
     }
 
@@ -2034 +2034 @@
     ///
     /// Gives back the name of undirected edgeset on the indiced position.
-    std::string undirEdgeSetName(int index) const {
-      return undiredgesets[index].name;
+    std::string uEdgeSetName(int index) const {
+      return uedgesets[index].name;
     }
 
@@ -2042 +2042 @@
     ///
     /// Gives back the map names of undirected edgeset on the indiced position.
-    const std::vector<std::string>& undirEdgeSetMaps(int index) const {
-      return undiredgesets[index].items;
+    const std::vector<std::string>& uEdgeSetMaps(int index) const {
+      return uedgesets[index].items;
     }
 
@@ -2096 +2096 @@
     ///
     /// Gives back how many labeled undirected edges section are in the file.
-    int undirEdgesNum() const {
-      return undiredges.size();
+    int uEdgesNum() const {
+      return uedges.size();
     }
 
@@ -2105 +2105 @@
     /// Gives back the name of labeled undirected edges section on the 
     /// indiced position.
-    std::string undirEdgesName(int index) const {
-      return undiredges[index].name;
+    std::string uEdgesName(int index) const {
+      return uedges[index].name;
     }
 
@@ -2114 +2114 @@
     /// Gives back the names of the labeled undirected edges in the 
     /// indiced section.
-    const std::vector<std::string>& undirEdgesItems(int index) const {
-      return undiredges[index].items;
+    const std::vector<std::string>& uEdgesItems(int index) const {
+      return uedges[index].items;
     }
 
@@ -2161 +2161 @@
         current = command;
         edgesets.push_back(SectionInfo(name));
-      } else if (command == "@undiredgeset") {
+      } else if (command == "@uedgeset") {
         current = command;
-        undiredgesets.push_back(SectionInfo(name));
+        uedgesets.push_back(SectionInfo(name));
       } else if (command == "@nodes") {
         current = command;
@@ -2170 +2170 @@
         current = command;
         edges.push_back(SectionInfo(name));
-      } else if (command == "@undiredges") {
+      } else if (command == "@uedges") {
         current = command;
-        undiredges.push_back(SectionInfo(name));
+        uedges.push_back(SectionInfo(name));
       } else if (command == "@attributes") {
         current = command;
@@ -2191 +2191 @@
       } else if (current == "@edgeset") {
         readMapNames(is, edgesets.back().items);
-      } else if (current == "@undiredgeset") {
-        readMapNames(is, undiredgesets.back().items);
+      } else if (current == "@uedgeset") {
+        readMapNames(is, uedgesets.back().items);
       } else if (current == "@nodes") {
         readItemNames(is, nodes.back().items);
       } else if (current == "@edges") {
         readItemNames(is, edges.back().items);
-      } else if (current == "@undiredges") {
-        readItemNames(is, undiredges.back().items);
+      } else if (current == "@uedges") {
+        readItemNames(is, uedges.back().items);
       } else if (current == "@attributes") {
         readItemNames(is, attributes.back().items);
@@ -2234 +2234 @@
     std::vector<SectionInfo> nodesets;
     std::vector<SectionInfo> edgesets;
-    std::vector<SectionInfo> undiredgesets;
+    std::vector<SectionInfo> uedgesets;
 
     std::vector<SectionInfo> nodes;
     std::vector<SectionInfo> edges;
-    std::vector<SectionInfo> undiredges;
+    std::vector<SectionInfo> uedges;
 
     std::vector<SectionInfo> attributes;

lemon/lemon_writer.h

@@ -92 +92 @@
     class ForwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -116 +116 @@
     class BackwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -709 +709 @@
   ///
   /// The lemon format can store multiple undirected edgesets with several 
-  /// maps. The undirected edgeset section's header line is \c \@undiredgeset 
-  /// \c undiredgeset_name, but the \c undiredgeset_name may be empty.
+  /// maps. The undirected edgeset section's header line is \c \@uedgeset 
+  /// \c uedgeset_name, but the \c uedgeset_name may be empty.
   ///
   /// The first line of the section contains the names of the maps separated
@@ -735 +735 @@
   /// \relates LemonWriter
   template <typename _Graph, typename _Traits = DefaultWriterTraits>
-  class UndirEdgeSetWriter : public LemonWriter::SectionWriter {
+  class UEdgeSetWriter : public LemonWriter::SectionWriter {
     typedef LemonWriter::SectionWriter Parent;
   public:
@@ -743 +743 @@
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::UndirEdge UndirEdge;
+    typedef typename Graph::UEdge UEdge;
 
     /// \brief Constructor.
     ///
-    /// Constructor for UndirEdgeSetWriter. It creates the UndirEdgeSetWriter
+    /// Constructor for UEdgeSetWriter. It creates the UEdgeSetWriter
     /// and attach it into the given LemonWriter. It will write node labels by
     /// the \c _nodeLabelWriter. If the \c _forceLabelMap parameter is true 
@@ -753 +753 @@
     /// "label" named map.
     template <typename NodeLabelWriter>
-    UndirEdgeSetWriter(LemonWriter& _writer, const Graph& _graph, 
+    UEdgeSetWriter(LemonWriter& _writer, const Graph& _graph, 
                        const NodeLabelWriter& _nodeLabelWriter, 
                        const std::string& _name = std::string(),
@@ -766 +766 @@
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeSetWriter.
-    virtual ~UndirEdgeSetWriter() {
+    /// Destructor for UEdgeSetWriter.
+    virtual ~UEdgeSetWriter() {
       typename MapWriters::iterator it;
       for (it = writers.begin(); it != writers.end(); ++it) {
@@ -775 +775 @@
 
   private:
-    UndirEdgeSetWriter(const UndirEdgeSetWriter&);
-    void operator=(const UndirEdgeSetWriter&);
+    UEdgeSetWriter(const UEdgeSetWriter&);
+    void operator=(const UEdgeSetWriter&);
 
   public:
@@ -784 +784 @@
     /// Add a new undirected map writer command for the writer.
     template <typename Map>
-    UndirEdgeSetWriter& writeUndirEdgeMap(std::string name, const Map& map) {
-      return writeUndirEdgeMap<typename Traits::
+    UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map) {
+      return writeUEdgeMap<typename Traits::
         template Writer<typename Map::Value>, Map>(name, map);
     }
@@ -793 +793 @@
     /// Add a new undirected map writer command for the writer.
     template <typename Writer, typename Map>
-    UndirEdgeSetWriter& writeUndirEdgeMap(std::string name, const Map& map, 
+    UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map, 
                                           const Writer& writer = Writer()) {
-      checkConcept<concept::ReadMap<UndirEdge, typename Map::Value>, Map>();
+      checkConcept<concept::ReadMap<UEdge, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writers.push_back(
         make_pair(name, new _writer_bits::
-                  MapWriter<UndirEdge, Map, Writer>(map, writer)));
+                  MapWriter<UEdge, Map, Writer>(map, writer)));
       return *this;
     }
@@ -807 +807 @@
     /// Add a new directed map writer command for the writer.
     template <typename Map>
-    UndirEdgeSetWriter& writeEdgeMap(std::string name, const Map& map) {
+    UEdgeSetWriter& writeEdgeMap(std::string name, const Map& map) {
       return writeEdgeMap<typename Traits::
         template Writer<typename Map::Value>, Map>(name, map);
@@ -816 +816 @@
     /// Add a new directed map writer command for the writer.
     template <typename Writer, typename Map>
-    UndirEdgeSetWriter& writeEdgeMap(std::string name, const Map& map, 
+    UEdgeSetWriter& writeEdgeMap(std::string name, const Map& map, 
                                      const Writer& writer = Writer()) {
       checkConcept<concept::ReadMap<Edge, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
-      writeUndirEdge("+" + name, 
+      writeUEdge("+" + name, 
                      _writer_bits::forwardComposeMap(graph, map), writer);
-      writeUndirEdge("-" + name, 
+      writeUEdge("-" + name, 
                      _writer_bits::backwardComposeMap(graph, map), writer);
       return *this;
@@ -833 +833 @@
     /// It gives back the header of the section.
     virtual std::string header() {
-      return "@undiredgeset " + name;
+      return "@uedgeset " + name;
     }
 
@@ -858 +858 @@
       }
       os << std::endl;
-      for (typename Graph::UndirEdgeIt it(graph); it != INVALID; ++it) {
+      for (typename Graph::UEdgeIt it(graph); it != INVALID; ++it) {
         nodeLabelWriter->write(os, graph.source(it));
         os << '\t';
@@ -892 +892 @@
     /// undirected edge. Otherwise if the \c forceLabel parameter was true it 
     /// will write its id in the graph. 
-    void writeLabel(std::ostream& os, const UndirEdge& item) const {
+    void writeLabel(std::ostream& os, const UEdge& item) const {
       if (forceLabelMap) {
         os << graph.id(item);
@@ -923 +923 @@
 
     typedef std::vector<std::pair<std::string, _writer_bits::
-                                  MapWriterBase<UndirEdge>*> > MapWriters;
+                                  MapWriterBase<UEdge>*> > MapWriters;
     MapWriters writers;
 
-    _writer_bits::MapWriterBase<UndirEdge>* labelMap;
+    _writer_bits::MapWriterBase<UEdge>* labelMap;
     bool forceLabelMap;
    
@@ -1100 +1100 @@
   /// \brief SectionWriter for writing named undirected edges.
   ///
-  /// The undirected edges section's header line is \c \@undiredges 
-  /// \c undiredges_name, but the \c undiredges_name may be empty.
+  /// The undirected edges section's header line is \c \@uedges 
+  /// \c uedges_name, but the \c uedges_name may be empty.
   ///
   /// Each line in the section contains the name of the undirected edge and 
@@ -1108 +1108 @@
   /// \relates LemonWriter
   template <typename _Graph>
-  class UndirEdgeWriter : public LemonWriter::SectionWriter {
+  class UEdgeWriter : public LemonWriter::SectionWriter {
     typedef LemonWriter::SectionWriter Parent;
     typedef _Graph Graph;
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::UndirEdge UndirEdge;
+    typedef typename Graph::UEdge UEdge;
   public:
     
     /// \brief Constructor.
     ///
-    /// Constructor for UndirEdgeWriter. It creates the UndirEdgeWriter and
+    /// Constructor for UEdgeWriter. It creates the UEdgeWriter and
     /// attach it into the given LemonWriter. The given \c _LabelWriter
     /// will write the undirected edges' label what can be an undirected 
     /// edgeset writer.
     template <typename _LabelWriter>
-    UndirEdgeWriter(LemonWriter& _writer, const _LabelWriter& _labelWriter, 
+    UEdgeWriter(LemonWriter& _writer, const _LabelWriter& _labelWriter, 
                const std::string& _name = std::string()) 
       : Parent(_writer), name(_name) {
       checkConcept<_writer_bits::ItemLabelWriter<Edge>, _LabelWriter>();
-      checkConcept<_writer_bits::ItemLabelWriter<UndirEdge>, _LabelWriter>();
-      undirEdgeLabelWriter.reset(new _writer_bits::
-                              LabelWriter<UndirEdge, _LabelWriter>(_labelWriter));
+      checkConcept<_writer_bits::ItemLabelWriter<UEdge>, _LabelWriter>();
+      uEdgeLabelWriter.reset(new _writer_bits::
+                              LabelWriter<UEdge, _LabelWriter>(_labelWriter));
       edgeLabelWriter.reset(new _writer_bits::
                          LabelWriter<Edge, _LabelWriter>(_labelWriter));
@@ -1136 +1136 @@
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeWriter.
-    virtual ~UndirEdgeWriter() {}
-  private:
-    UndirEdgeWriter(const UndirEdgeWriter&);
-    void operator=(const UndirEdgeWriter&);
-
-  public:
-
-    /// \brief Add an edge writer command for the UndirEdgeWriter.
-    ///
-    /// Add an edge writer command for the UndirEdgeWriter.
+    /// Destructor for UEdgeWriter.
+    virtual ~UEdgeWriter() {}
+  private:
+    UEdgeWriter(const UEdgeWriter&);
+    void operator=(const UEdgeWriter&);
+
+  public:
+
+    /// \brief Add an edge writer command for the UEdgeWriter.
+    ///
+    /// Add an edge writer command for the UEdgeWriter.
     void writeEdge(const std::string& name, const Edge& item) {
       edgeWriters.push_back(make_pair(name, &item));
     }
 
-    /// \brief Add an undirected edge writer command for the UndirEdgeWriter.
-    ///
-    /// Add an undirected edge writer command for the UndirEdgeWriter.
-    void writeUndirEdge(const std::string& name, const UndirEdge& item) {
-      undirEdgeWriters.push_back(make_pair(name, &item));
+    /// \brief Add an undirected edge writer command for the UEdgeWriter.
+    ///
+    /// Add an undirected edge writer command for the UEdgeWriter.
+    void writeUEdge(const std::string& name, const UEdge& item) {
+      uEdgeWriters.push_back(make_pair(name, &item));
     }
 
@@ -1164 +1164 @@
     /// It gives back the header of the section.
     virtual std::string header() {
-      return "@undiredges " + name;
+      return "@uedges " + name;
     }
 
@@ -1174 +1174 @@
         throw DataFormatError("Cannot find undirected edgeset or label map");
       }
-      if (!undirEdgeLabelWriter->isLabelWriter()) {
+      if (!uEdgeLabelWriter->isLabelWriter()) {
         throw DataFormatError("Cannot find undirected edgeset or label map");
       }
-      for (int i = 0; i < (int)undirEdgeWriters.size(); ++i) {
-        os << undirEdgeWriters[i].first << ' ';
-        undirEdgeLabelWriter->write(os, *(undirEdgeWriters[i].second));
+      for (int i = 0; i < (int)uEdgeWriters.size(); ++i) {
+        os << uEdgeWriters[i].first << ' ';
+        uEdgeLabelWriter->write(os, *(uEdgeWriters[i].second));
         os << std::endl;
       }
@@ -1194 +1194 @@
 
     typedef std::vector<std::pair<std::string, 
-                                  const UndirEdge*> > UndirEdgeWriters;
-    UndirEdgeWriters undirEdgeWriters;
-    std::auto_ptr<_writer_bits::LabelWriterBase<UndirEdge> > undirEdgeLabelWriter;
+                                  const UEdge*> > UEdgeWriters;
+    UEdgeWriters uEdgeWriters;
+    std::auto_ptr<_writer_bits::LabelWriterBase<UEdge> > uEdgeLabelWriter;
 
     typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;

lemon/list_graph.h

@@ -20 +20 @@
 ///\ingroup graphs
 ///\file
-///\brief ListGraph, UndirListGraph classes.
+///\brief ListGraph, ListUGraph classes.
 
 #include <lemon/bits/erasable_graph_extender.h>
@@ -577 +577 @@
   /**************** Undirected List Graph ****************/
 
-  typedef ErasableUndirGraphExtender<
-    ClearableUndirGraphExtender<
-    ExtendableUndirGraphExtender<
-    MappableUndirGraphExtender<
-    IterableUndirGraphExtender<
-    AlterableUndirGraphExtender<
-    UndirGraphExtender<ListGraphBase> > > > > > > ExtendedUndirListGraphBase;
+  typedef ErasableUGraphExtender<
+    ClearableUGraphExtender<
+    ExtendableUGraphExtender<
+    MappableUGraphExtender<
+    IterableUGraphExtender<
+    AlterableUGraphExtender<
+    UGraphExtender<ListGraphBase> > > > > > > ExtendedListUGraphBase;
 
   /// \addtogroup graphs
@@ -593 +593 @@
   ///
   ///It conforms to the
-  ///\ref concept::UndirGraph "UndirGraph" concept.
+  ///\ref concept::UGraph "UGraph" concept.
   ///
-  ///\sa concept::UndirGraph.
+  ///\sa concept::UGraph.
   ///
   ///\todo Snapshot, reverseEdge(), changeTarget(), changeSource(), contract()
   ///haven't been implemented yet.
   ///
-  class UndirListGraph : public ExtendedUndirListGraphBase {
+  class ListUGraph : public ExtendedListUGraphBase {
   public:
-    typedef ExtendedUndirListGraphBase Parent;
+    typedef ExtendedListUGraphBase Parent;
     /// \brief Changes the target of \c e to \c n
     ///
@@ -610 +610 @@
     /// referencing the changed edge remain
     /// valid. However <tt>InEdge</tt>'s are invalidated.
-    void changeTarget(UndirEdge e, Node n) { 
+    void changeTarget(UEdge e, Node n) { 
       _changeTarget(e,n); 
     }
@@ -620 +620 @@
     ///referencing the changed edge remain
     ///valid. However <tt>OutEdge</tt>'s are invalidated.
-    void changeSource(UndirEdge e, Node n) { 
+    void changeSource(UEdge e, Node n) { 
       _changeSource(e,n); 
     }

lemon/max_matching.h

@@ -60 +60 @@
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::UndirEdge UndirEdge;
-    typedef typename Graph::UndirEdgeIt UndirEdgeIt;
+    typedef typename Graph::UEdge UEdge;
+    typedef typename Graph::UEdgeIt UEdgeIt;
     typedef typename Graph::NodeIt NodeIt;
     typedef typename Graph::IncEdgeIt IncEdgeIt;
@@ -99 +99 @@
     ///heuristic of postponing shrinks for dense graphs. 
     void run() {
-      if ( countUndirEdges(g) < HEUR_density*countNodes(g) ) {
+      if ( countUEdges(g) < HEUR_density*countNodes(g) ) {
         greedyMatching();
         runEdmonds(0);
@@ -213 +213 @@
     } 
 
-    ///Reads a matching from an \c UndirEdge valued \c Node map.
-
-    ///Reads a matching from an \c UndirEdge valued \c Node map. \c
-    ///map[v] must be an \c UndirEdge incident to \c v. This map must
+    ///Reads a matching from an \c UEdge valued \c Node map.
+
+    ///Reads a matching from an \c UEdge valued \c Node map. \c
+    ///map[v] must be an \c UEdge incident to \c v. This map must
     ///have the property that if \c g.oppositeNode(u,map[u])==v then
     ///\c \c g.oppositeNode(v,map[v])==u holds, and now some edge
@@ -223 +223 @@
     void readNMapEdge(NMapE& map) {
      for(NodeIt v(g); v!=INVALID; ++v) {
-       UndirEdge e=map[v];
+       UEdge e=map[v];
         if ( e!=INVALID )
           _mate.set(v,g.oppositeNode(v,e));
@@ -229 +229 @@
     } 
     
-    ///Writes the matching stored to an \c UndirEdge valued \c Node map.
-
-    ///Writes the stored matching to an \c UndirEdge valued \c Node
-    ///map. \c map[v] will be an \c UndirEdge incident to \c v. This
+    ///Writes the matching stored to an \c UEdge valued \c Node map.
+
+    ///Writes the stored matching to an \c UEdge valued \c Node
+    ///map. \c map[v] will be an \c UEdge incident to \c v. This
     ///map will have the property that if \c g.oppositeNode(u,map[u])
     ///== v then \c map[u]==map[v] holds, and now this edge is an edge
@@ -264 +264 @@
     template<typename EMapB>
     void readEMapBool(EMapB& map) {
-      for(UndirEdgeIt e(g); e!=INVALID; ++e) {
+      for(UEdgeIt e(g); e!=INVALID; ++e) {
         if ( map[e] ) {
           Node u=g.source(e);     
@@ -283 +283 @@
     template<typename EMapB>
     void writeEMapBool (EMapB& map) const {
-      for(UndirEdgeIt e(g); e!=INVALID; ++e) map.set(e,false);
+      for(UEdgeIt e(g); e!=INVALID; ++e) map.set(e,false);
 
       typename Graph::template NodeMap<bool> todo(g,true); 

lemon/path.h

@@ -386 +386 @@
   /// \todo May we need just path for undirected graph instead of this.
   template<typename Graph>
-  class UndirPath {
+  class UPath {
   public:
     /// Edge type of the underlying graph.
@@ -404 +404 @@
     /// \param _G The graph in which the path is.
     ///
-    UndirPath(const Graph &_G) : gr(&_G) {}
+    UPath(const Graph &_G) : gr(&_G) {}
 
     /// \brief Subpath constructor.
@@ -410 +410 @@
     /// Subpath defined by two nodes.
     /// \warning It is an error if the two edges are not in order!
-    UndirPath(const UndirPath &P, const NodeIt &a, const NodeIt &b) {
+    UPath(const UPath &P, const NodeIt &a, const NodeIt &b) {
       gr = P.gr;
       edges.insert(edges.end(), P.edges.begin()+a.idx, P.edges.begin()+b.idx);
@@ -419 +419 @@
     /// Subpath defined by two edges. Contains edges in [a,b)
     /// \warning It is an error if the two edges are not in order!
-    UndirPath(const UndirPath &P, const EdgeIt &a, const EdgeIt &b) {
+    UPath(const UPath &P, const EdgeIt &a, const EdgeIt &b) {
       gr = P.gr;
       edges.insert(edges.end(), P.edges.begin()+a.idx, P.edges.begin()+b.idx);
@@ -501 +501 @@
      */
     class EdgeIt {
-      friend class UndirPath;
+      friend class UPath;
 
       int idx;
-      const UndirPath *p;
+      const UPath *p;
     public:
       /// Default constructor
@@ -511 +511 @@
       EdgeIt(Invalid) : idx(-1), p(0) {}
       /// Constructor with starting point
-      EdgeIt(const UndirPath &_p, int _idx = 0) :
+      EdgeIt(const UPath &_p, int _idx = 0) :
         idx(_idx), p(&_p) { validate(); }
 
@@ -548 +548 @@
      */
     class NodeIt {
-      friend class UndirPath;
+      friend class UPath;
 
       int idx;
-      const UndirPath *p;
+      const UPath *p;
     public:
       /// Default constructor
@@ -558 +558 @@
       NodeIt(Invalid) : idx(-1), p(0) {}
       /// Constructor with starting point
-      NodeIt(const UndirPath &_p, int _idx = 0) :
+      NodeIt(const UPath &_p, int _idx = 0) :
         idx(_idx), p(&_p) { validate(); }
 
@@ -601 +601 @@
      * operation and until the commit()) the original Path is in a
      * "transitional" state (operations ot it have undefined result). But
-     * in the case of UndirPath the original path is unchanged until the
+     * in the case of UPath the original path is unchanged until the
      * commit. However we don't recomend that you use this feature.
      */
     class Builder {
-      UndirPath &P;
+      UPath &P;
       Container front, back;
 
@@ -611 +611 @@
       ///\param _p the path you want to fill in.
       ///
-      Builder(UndirPath &_p) : P(_p) {}
+      Builder(UPath &_p) : P(_p) {}
 
       /// Sets the starting node of the path.

lemon/smart_graph.h

@@ -20 +20 @@
 ///\ingroup graphs
 ///\file
-///\brief SmartGraph and UndirSmartGraph classes.
+///\brief SmartGraph and SmartUGraph classes.
 
 #include <vector>
@@ -354 +354 @@
   /**************** Undirected List Graph ****************/
 
-  typedef ClearableUndirGraphExtender<
-    ExtendableUndirGraphExtender<
-    MappableUndirGraphExtender<
-    IterableUndirGraphExtender<
-    AlterableUndirGraphExtender<
-    UndirGraphExtender<SmartGraphBase> > > > > > ExtendedUndirSmartGraphBase;
-
-  ///A smart undirected graph class.
-
-  ///This is a simple and fast undirected graph implementation.
-  ///It is also quite memory efficient, but at the price
-  ///that <b> it does support only limited (only stack-like)
-  ///node and edge deletions</b>.
-  ///Except from this it conforms to 
-  ///the \ref concept::UndirGraph "UndirGraph" concept.
-  ///\sa concept::UndirGraph.
+  typedef ClearableUGraphExtender<
+    ExtendableUGraphExtender<
+    MappableUGraphExtender<
+    IterableUGraphExtender<
+    AlterableUGraphExtender<
+    UGraphExtender<SmartGraphBase> > > > > > ExtendedSmartUGraphBase;
+
+  /// \ingroup graphs
   ///
-  ///\todo Snapshot hasn't been implemented yet.
+  /// \brief A smart undirected graph class.
   ///
-  class UndirSmartGraph : public ExtendedUndirSmartGraphBase {
+  /// This is a simple and fast undirected graph implementation.
+  /// It is also quite memory efficient, but at the price
+  /// that <b> it does support only limited (only stack-like)
+  /// node and edge deletions</b>.
+  /// Except from this it conforms to 
+  /// the \ref concept::UGraph "UGraph" concept.
+  /// \sa concept::UGraph.
+  ///
+  /// \todo Snapshot hasn't been implemented yet.
+  ///
+  class SmartUGraph : public ExtendedSmartUGraphBase {
   };
 
 
-  class SmartUndirBipartiteGraphBase {
+  class SmartUBipartiteGraphBase {
   public:
 
     class NodeSetError : public LogicError {
       virtual const char* exceptionName() const { 
-        return "lemon::FullUndirBipartiteGraph::NodeSetError";
+        return "lemon::FullUBipartiteGraph::NodeSetError";
       }
     };
@@ -407 +409 @@
   
     class Node {
-      friend class SmartUndirBipartiteGraphBase;
+      friend class SmartUBipartiteGraphBase;
     protected:
       int id;
@@ -421 +423 @@
 
     class Edge {
-      friend class SmartUndirBipartiteGraphBase;
+      friend class SmartUBipartiteGraphBase;
     protected:
       int id;
@@ -584 +586 @@
 
 
-  typedef ClearableUndirBipartiteGraphExtender<
-    ExtendableUndirBipartiteGraphExtender<
-    MappableUndirBipartiteGraphExtender<
-    IterableUndirBipartiteGraphExtender<
-    AlterableUndirBipartiteGraphExtender<
-    UndirBipartiteGraphExtender <
-    SmartUndirBipartiteGraphBase> > > > > >
-  ExtendedSmartUndirBipartiteGraphBase;
-
-
-  class SmartUndirBipartiteGraph : 
-    public ExtendedSmartUndirBipartiteGraphBase {
+  typedef ClearableUBipartiteGraphExtender<
+    ExtendableUBipartiteGraphExtender<
+    MappableUBipartiteGraphExtender<
+    IterableUBipartiteGraphExtender<
+    AlterableUBipartiteGraphExtender<
+    UBipartiteGraphExtender <
+    SmartUBipartiteGraphBase> > > > > >
+  ExtendedSmartUBipartiteGraphBase;
+
+
+  class SmartUBipartiteGraph : 
+    public ExtendedSmartUBipartiteGraphBase {
   };
 

lemon/sub_graph.h

@@ -695 +695 @@
 //   class ResGraph
 //     : public IterableGraphExtender<EdgeSubGraphBase<
-//     UndirGraphAdaptor<Graph> > > {
+//     UGraphAdaptor<Graph> > > {
 //   public:
 //     typedef IterableGraphExtender<EdgeSubGraphBase<
-//       UndirGraphAdaptor<Graph> > > Parent;
+//       UGraphAdaptor<Graph> > > Parent;
 
 //   protected:
-//     UndirGraphAdaptor<Graph> undir;
+//     UGraphAdaptor<Graph> u;
 
 //     const CapacityMap* capacity;
@@ -719 +719 @@
 //   public:
 
-//     typedef typename UndirGraphAdaptor<Graph>::Node Node;
-//     typedef typename UndirGraphAdaptor<Graph>::Edge Edge;
-//     typedef typename UndirGraphAdaptor<Graph>::UndirEdge UndirEdge;
+//     typedef typename UGraphAdaptor<Graph>::Node Node;
+//     typedef typename UGraphAdaptor<Graph>::Edge Edge;
+//     typedef typename UGraphAdaptor<Graph>::UEdge UEdge;
 
 //     ResGraphAdaptor(Graph& _graph, 
 //                  const CapacityMap& _capacity, FlowMap& _flow) 
-//       : Parent(), undir(_graph), capacity(&_capacity), flow(&_flow),
+//       : Parent(), u(_graph), capacity(&_capacity), flow(&_flow),
 //      nodes(*this, _graph), edges(*this, _graph) {
-//       Parent::construct(undir, nodes, edges);
+//       Parent::construct(u, nodes, edges);
 //       setFlowMap(_flow);
 //       setCapacityMap(_capacity);
@@ -771 +771 @@
 //     }
 
-//     Edge direct(const UndirEdge& edge, bool direction) const {
+//     Edge direct(const UEdge& edge, bool direction) const {
 //       return Parent::getGraph().direct(edge, direction);
 //     }
 
-//     Edge direct(const UndirEdge& edge, const Node& node) const {
+//     Edge direct(const UEdge& edge, const Node& node) const {
 //       return Parent::getGraph().direct(edge, node);
 //     }

lemon/topology.h

@@ -25 +25 @@
 
 #include <lemon/concept/graph.h>
-#include <lemon/concept/undir_graph.h>
+#include <lemon/concept/ugraph.h>
 #include <lemon/concept_check.h>
 
@@ -50 +50 @@
   /// \return %True when there is path between any two nodes in the graph.
   /// \note By definition, the empty graph is connected.
-  template <typename UndirGraph>
-  bool connected(const UndirGraph& graph) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::NodeIt NodeIt;
+  template <typename UGraph>
+  bool connected(const UGraph& graph) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::NodeIt NodeIt;
     if (NodeIt(graph) == INVALID) return true;
-    Dfs<UndirGraph> dfs(graph);
+    Dfs<UGraph> dfs(graph);
     dfs.run(NodeIt(graph));
     for (NodeIt it(graph); it != INVALID; ++it) {
@@ -75 +75 @@
   /// \note By definition, the empty graph consists
   /// of zero connected components.
-  template <typename UndirGraph>
-  int countConnectedComponents(const UndirGraph &graph) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::Node Node;
-    typedef typename UndirGraph::Edge Edge;
+  template <typename UGraph>
+  int countConnectedComponents(const UGraph &graph) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::Node Node;
+    typedef typename UGraph::Edge Edge;
 
     typedef NullMap<Node, Edge> PredMap;
@@ -85 +85 @@
 
     int compNum = 0;
-    typename Bfs<UndirGraph>::
+    typename Bfs<UGraph>::
       template DefPredMap<PredMap>::
       template DefDistMap<DistMap>::
@@ -97 +97 @@
 
     bfs.init();
-    for(typename UndirGraph::NodeIt n(graph); n != INVALID; ++n) {
+    for(typename UGraph::NodeIt n(graph); n != INVALID; ++n) {
       if (!bfs.reached(n)) {
         bfs.addSource(n);
@@ -123 +123 @@
   /// \return The number of components
   ///
-  template <class UndirGraph, class NodeMap>
-  int connectedComponents(const UndirGraph &graph, NodeMap &compMap) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::Node Node;
-    typedef typename UndirGraph::Edge Edge;
+  template <class UGraph, class NodeMap>
+  int connectedComponents(const UGraph &graph, NodeMap &compMap) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::Node Node;
+    typedef typename UGraph::Edge Edge;
     checkConcept<concept::WriteMap<Node, int>, NodeMap>();
 
@@ -134 +134 @@
 
     int compNum = 0;
-    typename Bfs<UndirGraph>::
+    typename Bfs<UGraph>::
       template DefPredMap<PredMap>::
       template DefDistMap<DistMap>::
@@ -146 +146 @@
     
     bfs.init();
-    for(typename UndirGraph::NodeIt n(graph); n != INVALID; ++n) {
+    for(typename UGraph::NodeIt n(graph); n != INVALID; ++n) {
       if(!bfs.reached(n)) {
         bfs.addSource(n);
@@ -485 +485 @@
       typedef typename Graph::Node Node;
       typedef typename Graph::Edge Edge;
-      typedef typename Graph::UndirEdge UndirEdge;
+      typedef typename Graph::UEdge UEdge;
 
       CountBiNodeConnectedComponentsVisitor(const Graph& graph, int &compNum) 
@@ -543 +543 @@
       typedef typename Graph::Node Node;
       typedef typename Graph::Edge Edge;
-      typedef typename Graph::UndirEdge UndirEdge;
+      typedef typename Graph::UEdge UEdge;
 
       BiNodeConnectedComponentsVisitor(const Graph& graph, 
@@ -613 +613 @@
       typename Graph::template NodeMap<int> _retMap;
       typename Graph::template NodeMap<Edge> _predMap;
-      std::stack<UndirEdge> _edgeStack;
+      std::stack<UEdge> _edgeStack;
       int _num;
     };
@@ -623 +623 @@
       typedef typename Graph::Node Node;
       typedef typename Graph::Edge Edge;
-      typedef typename Graph::UndirEdge UndirEdge;
+      typedef typename Graph::UEdge UEdge;
 
       BiNodeConnectedCutNodesVisitor(const Graph& graph, NodeMap& cutMap,
@@ -689 +689 @@
       typename Graph::template NodeMap<int> _retMap;
       typename Graph::template NodeMap<Node> _predMap;
-      std::stack<UndirEdge> _edgeStack;
+      std::stack<UEdge> _edgeStack;
       int _num;
       bool rootCut;
@@ -696 +696 @@
   }
 
-  template <typename UndirGraph>
-  int countBiNodeConnectedComponents(const UndirGraph& graph);
+  template <typename UGraph>
+  int countBiNodeConnectedComponents(const UGraph& graph);
 
   /// \ingroup topology
@@ -710 +710 @@
   /// \return %True when the graph bi-node-connected.
   /// \todo Make it faster.
-  template <typename UndirGraph>
-  bool biNodeConnected(const UndirGraph& graph) {
+  template <typename UGraph>
+  bool biNodeConnected(const UGraph& graph) {
     return countBiNodeConnectedComponents(graph) == 1;
   }
@@ -726 +726 @@
   /// \param graph The graph.
   /// \return The number of components.
-  template <typename UndirGraph>
-  int countBiNodeConnectedComponents(const UndirGraph& graph) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::NodeIt NodeIt;
+  template <typename UGraph>
+  int countBiNodeConnectedComponents(const UGraph& graph) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::NodeIt NodeIt;
 
     using namespace _topology_bits;
 
-    typedef CountBiNodeConnectedComponentsVisitor<UndirGraph> Visitor;
+    typedef CountBiNodeConnectedComponentsVisitor<UGraph> Visitor;
 
     int compNum = 0;
     Visitor visitor(graph, compNum);
 
-    DfsVisit<UndirGraph, Visitor> dfs(graph, visitor);
+    DfsVisit<UGraph, Visitor> dfs(graph, visitor);
     dfs.init();
     
@@ -763 +763 @@
   ///
   /// \param graph The graph.
-  /// \retval compMap A writable undir edge map. The values will be set from 0
+  /// \retval compMap A writable uedge map. The values will be set from 0
   /// to the number of the biconnected components minus one. Each values 
   /// of the map will be set exactly once, the values of a certain component 
@@ -769 +769 @@
   /// \return The number of components.
   ///
-  template <typename UndirGraph, typename UndirEdgeMap>
-  int biNodeConnectedComponents(const UndirGraph& graph, 
-                                UndirEdgeMap& compMap) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::NodeIt NodeIt;
-    typedef typename UndirGraph::UndirEdge UndirEdge;
-    checkConcept<concept::WriteMap<UndirEdge, int>, UndirEdgeMap>();
+  template <typename UGraph, typename UEdgeMap>
+  int biNodeConnectedComponents(const UGraph& graph, 
+                                UEdgeMap& compMap) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::NodeIt NodeIt;
+    typedef typename UGraph::UEdge UEdge;
+    checkConcept<concept::WriteMap<UEdge, int>, UEdgeMap>();
 
     using namespace _topology_bits;
 
-    typedef BiNodeConnectedComponentsVisitor<UndirGraph, UndirEdgeMap> Visitor;
+    typedef BiNodeConnectedComponentsVisitor<UGraph, UEdgeMap> Visitor;
     
     int compNum = 0;
     Visitor visitor(graph, compMap, compNum);
 
-    DfsVisit<UndirGraph, Visitor> dfs(graph, visitor);
+    DfsVisit<UGraph, Visitor> dfs(graph, visitor);
     dfs.init();
     
@@ -810 +810 @@
   /// the node separate two or more components.
   /// \return The number of the cut nodes.
-  template <typename UndirGraph, typename NodeMap>
-  int biNodeConnectedCutNodes(const UndirGraph& graph, NodeMap& cutMap) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::Node Node;
-    typedef typename UndirGraph::NodeIt NodeIt;
+  template <typename UGraph, typename NodeMap>
+  int biNodeConnectedCutNodes(const UGraph& graph, NodeMap& cutMap) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::Node Node;
+    typedef typename UGraph::NodeIt NodeIt;
     checkConcept<concept::WriteMap<Node, bool>, NodeMap>();
 
     using namespace _topology_bits;
 
-    typedef BiNodeConnectedCutNodesVisitor<UndirGraph, NodeMap> Visitor;
+    typedef BiNodeConnectedCutNodesVisitor<UGraph, NodeMap> Visitor;
     
     int cutNum = 0;
     Visitor visitor(graph, cutMap, cutNum);
 
-    DfsVisit<UndirGraph, Visitor> dfs(graph, visitor);
+    DfsVisit<UGraph, Visitor> dfs(graph, visitor);
     dfs.init();
     
@@ -843 +843 @@
       typedef typename Graph::Node Node;
       typedef typename Graph::Edge Edge;
-      typedef typename Graph::UndirEdge UndirEdge;
+      typedef typename Graph::UEdge UEdge;
 
       CountBiEdgeConnectedComponentsVisitor(const Graph& graph, int &compNum) 
@@ -899 +899 @@
       typedef typename Graph::Node Node;
       typedef typename Graph::Edge Edge;
-      typedef typename Graph::UndirEdge UndirEdge;
+      typedef typename Graph::UEdge UEdge;
 
       BiEdgeConnectedComponentsVisitor(const Graph& graph, 
@@ -966 +966 @@
       typedef typename Graph::Node Node;
       typedef typename Graph::Edge Edge;
-      typedef typename Graph::UndirEdge UndirEdge;
+      typedef typename Graph::UEdge UEdge;
 
       BiEdgeConnectedCutEdgesVisitor(const Graph& graph, 
@@ -1023 +1023 @@
   }
 
-  template <typename UndirGraph>
-  int countbiEdgeConnectedComponents(const UndirGraph& graph);
+  template <typename UGraph>
+  int countbiEdgeConnectedComponents(const UGraph& graph);
 
   /// \ingroup topology
@@ -1037 +1037 @@
   /// \return The number of components.
   /// \todo Make it faster.
-  template <typename UndirGraph>
-  bool biEdgeConnected(const UndirGraph& graph) { 
+  template <typename UGraph>
+  bool biEdgeConnected(const UGraph& graph) { 
     return countBiEdgeConnectedComponents(graph) == 1;
   }
@@ -1053 +1053 @@
   /// \param graph The undirected graph.
   /// \return The number of components.
-  template <typename UndirGraph>
-  int countBiEdgeConnectedComponents(const UndirGraph& graph) { 
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::NodeIt NodeIt;
+  template <typename UGraph>
+  int countBiEdgeConnectedComponents(const UGraph& graph) { 
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::NodeIt NodeIt;
 
     using namespace _topology_bits;
 
-    typedef CountBiEdgeConnectedComponentsVisitor<UndirGraph> Visitor;
+    typedef CountBiEdgeConnectedComponentsVisitor<UGraph> Visitor;
     
     int compNum = 0;
     Visitor visitor(graph, compNum);
 
-    DfsVisit<UndirGraph, Visitor> dfs(graph, visitor);
+    DfsVisit<UGraph, Visitor> dfs(graph, visitor);
     dfs.init();
     
@@ -1096 +1096 @@
   /// \return The number of components.
   ///
-  template <typename UndirGraph, typename NodeMap>
-  int biEdgeConnectedComponents(const UndirGraph& graph, NodeMap& compMap) { 
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::NodeIt NodeIt;
-    typedef typename UndirGraph::Node Node;
+  template <typename UGraph, typename NodeMap>
+  int biEdgeConnectedComponents(const UGraph& graph, NodeMap& compMap) { 
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::NodeIt NodeIt;
+    typedef typename UGraph::Node Node;
     checkConcept<concept::WriteMap<Node, int>, NodeMap>();
 
     using namespace _topology_bits;
 
-    typedef BiEdgeConnectedComponentsVisitor<UndirGraph, NodeMap> Visitor;
+    typedef BiEdgeConnectedComponentsVisitor<UGraph, NodeMap> Visitor;
     
     int compNum = 0;
     Visitor visitor(graph, compMap, compNum);
 
-    DfsVisit<UndirGraph, Visitor> dfs(graph, visitor);
+    DfsVisit<UGraph, Visitor> dfs(graph, visitor);
     dfs.init();
     
@@ -1137 +1137 @@
   /// edge is a cut edge.
   /// \return The number of cut edges.
-  template <typename UndirGraph, typename UndirEdgeMap>
-  int biEdgeConnectedCutEdges(const UndirGraph& graph, UndirEdgeMap& cutMap) { 
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::NodeIt NodeIt;
-    typedef typename UndirGraph::UndirEdge UndirEdge;
-    checkConcept<concept::WriteMap<UndirEdge, bool>, UndirEdgeMap>();
+  template <typename UGraph, typename UEdgeMap>
+  int biEdgeConnectedCutEdges(const UGraph& graph, UEdgeMap& cutMap) { 
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::NodeIt NodeIt;
+    typedef typename UGraph::UEdge UEdge;
+    checkConcept<concept::WriteMap<UEdge, bool>, UEdgeMap>();
 
     using namespace _topology_bits;
 
-    typedef BiEdgeConnectedCutEdgesVisitor<UndirGraph, UndirEdgeMap> Visitor;
+    typedef BiEdgeConnectedCutEdgesVisitor<UGraph, UEdgeMap> Visitor;
     
     int cutNum = 0;
     Visitor visitor(graph, cutMap, cutNum);
 
-    DfsVisit<UndirGraph, Visitor> dfs(graph, visitor);
+    DfsVisit<UGraph, Visitor> dfs(graph, visitor);
     dfs.init();
     
@@ -1327 +1327 @@
   /// \return %True when there is no circle in the graph.
   /// \see dag
-  template <typename UndirGraph>
-  bool acyclic(const UndirGraph& graph) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::Node Node;
-    typedef typename UndirGraph::NodeIt NodeIt;
-    typedef typename UndirGraph::Edge Edge;
-    Dfs<UndirGraph> dfs(graph);
+  template <typename UGraph>
+  bool acyclic(const UGraph& graph) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::Node Node;
+    typedef typename UGraph::NodeIt NodeIt;
+    typedef typename UGraph::Edge Edge;
+    Dfs<UGraph> dfs(graph);
     dfs.init();
     for (NodeIt it(graph); it != INVALID; ++it) {
@@ -1360 +1360 @@
   /// \param graph The undirected graph.
   /// \return %True when the graph is acyclic and connected.
-  template <typename UndirGraph>
-  bool tree(const UndirGraph& graph) {
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    typedef typename UndirGraph::Node Node;
-    typedef typename UndirGraph::NodeIt NodeIt;
-    typedef typename UndirGraph::Edge Edge;
-    Dfs<UndirGraph> dfs(graph);
+  template <typename UGraph>
+  bool tree(const UGraph& graph) {
+    checkConcept<concept::UGraph, UGraph>();
+    typedef typename UGraph::Node Node;
+    typedef typename UGraph::NodeIt NodeIt;
+    typedef typename UGraph::Edge Edge;
+    Dfs<UGraph> dfs(graph);
     dfs.init();
     dfs.addSource(NodeIt(graph));
@@ -1398 +1398 @@
   ///
   /// \author Balazs Attila Mihaly  
-  template<typename UndirGraph>
-  inline bool bipartite(const UndirGraph &graph){
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    
-    typedef typename UndirGraph::NodeIt NodeIt;
-    typedef typename UndirGraph::EdgeIt EdgeIt;
-    
-    Bfs<UndirGraph> bfs(graph);
+  template<typename UGraph>
+  inline bool bipartite(const UGraph &graph){
+    checkConcept<concept::UGraph, UGraph>();
+    
+    typedef typename UGraph::NodeIt NodeIt;
+    typedef typename UGraph::EdgeIt EdgeIt;
+    
+    Bfs<UGraph> bfs(graph);
     bfs.init();
     for(NodeIt i(graph);i!=INVALID;++i){
@@ -1435 +1435 @@
   /// \image html bipartite_partitions.png
   /// \image latex bipartite_partitions.eps "Bipartite partititions" width=\textwidth
-  template<typename UndirGraph, typename NodeMap>
-  inline bool bipartitePartitions(const UndirGraph &graph, NodeMap &partMap){
-    checkConcept<concept::UndirGraph, UndirGraph>();
-    
-    typedef typename UndirGraph::Node Node;
-    typedef typename UndirGraph::NodeIt NodeIt;
-    typedef typename UndirGraph::EdgeIt EdgeIt;
+  template<typename UGraph, typename NodeMap>
+  inline bool bipartitePartitions(const UGraph &graph, NodeMap &partMap){
+    checkConcept<concept::UGraph, UGraph>();
+    
+    typedef typename UGraph::Node Node;
+    typedef typename UGraph::NodeIt NodeIt;
+    typedef typename UGraph::EdgeIt EdgeIt;
   
-    Bfs<UndirGraph> bfs(graph);
+    Bfs<UGraph> bfs(graph);
     bfs.init();
     for(NodeIt i(graph);i!=INVALID;++i){

lemon/traits.h

@@ -73 +73 @@
 
   template <typename _Graph>
-  class ItemSetTraits<_Graph, typename _Graph::UndirEdge> {
+  class ItemSetTraits<_Graph, typename _Graph::UEdge> {
   public:
     
     typedef _Graph Graph;
 
-    typedef typename Graph::UndirEdge Item;
-    typedef typename Graph::UndirEdgeIt ItemIt;
+    typedef typename Graph::UEdge Item;
+    typedef typename Graph::UEdgeIt ItemIt;
 
     template <typename _Value>
-    class Map : public Graph::template UndirEdgeMap<_Value> {
+    class Map : public Graph::template UEdgeMap<_Value> {
     public:
-      typedef typename Graph::template UndirEdgeMap<_Value> Parent; 
+      typedef typename Graph::template UEdgeMap<_Value> Parent; 
       typedef typename Parent::Value Value;
 

test/Makefile.am

@@ -34 +34 @@
         time_measure_test \
         unionfind_test \
-        undir_graph_test \
+        ugraph_test \
         xy_test \
         heap_test
@@ -71 +71 @@
 unionfind_test_SOURCES = unionfind_test.cc
 xy_test_SOURCES = xy_test.cc
-undir_graph_test_SOURCES = undir_graph_test.cc
+ugraph_test_SOURCES = ugraph_test.cc
 heap_test_SOURCES = heap_test.cc
 

test/graph_adaptor_test.cc

@@ -20 +20 @@
 #include<lemon/smart_graph.h>
 #include<lemon/concept/graph.h>
-#include<lemon/concept/undir_graph.h>
+#include<lemon/concept/ugraph.h>
 
 #include<lemon/list_graph.h>
@@ -66 +66 @@
 
     /// \bug why does not compile with StaticGraph
-    checkConcept<BaseIterableUndirGraphConcept, UndirGraphAdaptor<ListGraph> >();
-    checkConcept<IterableUndirGraphConcept, UndirGraphAdaptor<ListGraph> >();
-    checkConcept<MappableUndirGraphConcept, UndirGraphAdaptor<ListGraph> >();
+    checkConcept<BaseIterableUGraphConcept, UGraphAdaptor<ListGraph> >();
+    checkConcept<IterableUGraphConcept, UGraphAdaptor<ListGraph> >();
+    checkConcept<MappableUGraphConcept, UGraphAdaptor<ListGraph> >();
   }
   std::cout << __FILE__ ": All tests passed.\n";

test/max_matching_test.cc

@@ -32 +32 @@
 int main() {
 
-  typedef UndirListGraph Graph;
+  typedef ListUGraph Graph;
 
   typedef Graph::Edge Edge;
-  typedef Graph::UndirEdgeIt UndirEdgeIt;
+  typedef Graph::UEdgeIt UEdgeIt;
   typedef Graph::IncEdgeIt IncEdgeIt;
   typedef Graph::NodeIt NodeIt;
@@ -139 +139 @@
 
   bool noedge=true;
-  for(UndirEdgeIt e(g); e!=INVALID; ++e) {
+  for(UEdgeIt e(g); e!=INVALID; ++e) {
    if ( (pos[g.target(e)]==max_matching.C && pos[g.source(e)]==max_matching.D) || 
          (pos[g.target(e)]==max_matching.D && pos[g.source(e)]==max_matching.C) )

test/path_test.cc

@@ -90 +90 @@
 template void checkCompilePath< concept::Path<ListGraph> >(concept::Path<ListGraph> &);
 template void checkCompilePath< DirPath<ListGraph> >(DirPath<ListGraph> &);
-template void checkCompilePath< UndirPath<ListGraph> >(UndirPath<ListGraph> &);
+template void checkCompilePath< UPath<ListGraph> >(UPath<ListGraph> &);
 
 int main() 

test/test_tools.h

@@ -134 +134 @@
 }
 
-///Structure returned by \ref addUndirPetersen().
+///Structure returned by \ref addUPetersen().
 
-///Structure returned by \ref addUndirPetersen().
+///Structure returned by \ref addUPetersen().
 ///
-template<class Graph> struct UndirPetStruct
+template<class Graph> struct UPetStruct
 {
   ///Vector containing the outer nodes.
@@ -145 +145 @@
   std::vector<typename Graph::Node> inner;
   ///Vector containing the edges of the inner circle.
-  std::vector<typename Graph::UndirEdge> incir;
+  std::vector<typename Graph::UEdge> incir;
   ///Vector containing the edges of the outer circle.
-  std::vector<typename Graph::UndirEdge> outcir;
+  std::vector<typename Graph::UEdge> outcir;
   ///Vector containing the chord edges.
-  std::vector<typename Graph::UndirEdge> chords;
+  std::vector<typename Graph::UEdge> chords;
 };
 
@@ -158 +158 @@
 
 template<typename Graph>
-UndirPetStruct<Graph> addUndirPetersen(Graph &G,int num=5)
+UPetStruct<Graph> addUPetersen(Graph &G,int num=5)
 {
-  UndirPetStruct<Graph> n;
+  UPetStruct<Graph> n;
 
   for(int i=0;i<num;i++) {

test/ugraph_test.cc

@@ -2 +2 @@
 
 #include <lemon/bits/graph_extender.h>
-#include <lemon/concept/undir_graph.h>
+#include <lemon/concept/ugraph.h>
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
@@ -17 +17 @@
 
 void check_concepts() {
-  typedef UndirGraphExtender<ListGraphBase> UndirListGraphBase;
-
-  typedef IterableUndirGraphExtender<
-    AlterableUndirGraphExtender<UndirListGraphBase> > IterableUndirListGraph;
-
-  typedef MappableUndirGraphExtender<IterableUndirListGraph>
-    MappableUndirListGraph;
-
-  typedef ErasableUndirGraphExtender<
-    ClearableUndirGraphExtender<
-    ExtendableUndirGraphExtender<MappableUndirListGraph> > > Graph;
-
-  checkConcept<BaseIterableUndirGraphConcept, Graph>();
-  checkConcept<IterableUndirGraphConcept, Graph>();
-  checkConcept<MappableUndirGraphConcept, Graph>();
-
-  checkConcept<UndirGraph, Graph>();
-  checkConcept<ErasableUndirGraph, Graph>();
-
-  checkConcept<UndirGraph, UndirListGraph>();
-  checkConcept<ErasableUndirGraph, UndirListGraph>();
-
-  checkConcept<UndirGraph, UndirSmartGraph>();
-  checkConcept<ExtendableUndirGraph, UndirSmartGraph>();
-
-  checkConcept<UndirGraph, UndirFullGraph>();
-
-  checkConcept<UndirGraph, UndirGraph>();
-
-  checkConcept<UndirGraph, GridGraph>();
+  typedef UGraphExtender<ListGraphBase> ListUGraphBase;
+
+  typedef IterableUGraphExtender<
+    AlterableUGraphExtender<ListUGraphBase> > IterableListUGraph;
+
+  typedef MappableUGraphExtender<IterableListUGraph>
+    MappableListUGraph;
+
+  typedef ErasableUGraphExtender<
+    ClearableUGraphExtender<
+    ExtendableUGraphExtender<MappableListUGraph> > > Graph;
+
+  checkConcept<BaseIterableUGraphConcept, Graph>();
+  checkConcept<IterableUGraphConcept, Graph>();
+  checkConcept<MappableUGraphConcept, Graph>();
+
+  checkConcept<UGraph, Graph>();
+  checkConcept<ErasableUGraph, Graph>();
+
+  checkConcept<UGraph, ListUGraph>();
+  checkConcept<ErasableUGraph, ListUGraph>();
+
+  checkConcept<UGraph, SmartUGraph>();
+  checkConcept<ExtendableUGraph, SmartUGraph>();
+
+  checkConcept<UGraph, FullUGraph>();
+
+  checkConcept<UGraph, UGraph>();
+
+  checkConcept<UGraph, GridGraph>();
 }
 
@@ -68 +68 @@
 
   int uee = 0;
-  for (typename Graph::UndirEdgeIt it(g); it != INVALID; ++it) {
+  for (typename Graph::UEdgeIt it(g); it != INVALID; ++it) {
     ++uee;
   }
 
-  check(uee == e, "Wrong undir edge number.");
-  check(countUndirEdges(g) == e, "Wrong undir edge number.");
+  check(uee == e, "Wrong uedge number.");
+  check(countUEdges(g) == e, "Wrong uedge number.");
 }
 
@@ -80 +80 @@
 
   typedef typename Graph::NodeIt NodeIt;
-  typedef typename Graph::UndirEdgeIt UEdgeIt;
+  typedef typename Graph::UEdgeIt UEdgeIt;
   typedef typename Graph::EdgeIt EdgeIt;
 
@@ -89 +89 @@
   }
 
-  std::cout << "UndirEdge" << std::endl;
+  std::cout << "UEdge" << std::endl;
   i=0;
   for(UEdgeIt it(g); it!=INVALID; ++it, ++i) {
@@ -111 +111 @@
 
   typedef typename Graph::Node Node;
-  typedef typename Graph::UndirEdge UEdge;
+  typedef typename Graph::UEdge UEdge;
   typedef typename Graph::Edge Edge;
   typedef typename Graph::NodeIt NodeIt;
-  typedef typename Graph::UndirEdgeIt UEdgeIt;
+  typedef typename Graph::UEdgeIt UEdgeIt;
   typedef typename Graph::EdgeIt EdgeIt;
 
@@ -182 +182 @@
   check_concepts();
 
-  check_graph<UndirListGraph>();
-  check_graph<UndirSmartGraph>();
+  check_graph<ListUGraph>();
+  check_graph<SmartUGraph>();
 
   {
-    UndirFullGraph g(5);
+    FullUGraph g(5);
     check_item_counts(g, 5, 10);
   }