Index: lemon/graph_reader.h
===================================================================
--- lemon/graph_reader.h	(revision 1901)
+++ lemon/graph_reader.h	(revision 1909)
@@ -379,5 +379,5 @@
   /// \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,6 +391,6 @@
   ///
   /// 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,5 +400,5 @@
   ///
   /// \code
-  /// UndirGraphReader<UndirListGraph> reader(std::cin, graph);
+  /// UGraphReader<ListUGraph> reader(std::cin, graph);
   /// \endcode
   ///
@@ -417,9 +417,9 @@
   /// \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,6 +433,6 @@
   /// \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,5 +440,5 @@
   /// reader.readNode("target", targetNode);
   ///
-  /// reader.readUndirEdge("observed", undirEdge);
+  /// reader.readUEdge("observed", uEdge);
   /// \endcode
   ///
@@ -456,10 +456,10 @@
   /// \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,50 +467,50 @@
     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,5 +518,5 @@
     ///
     /// Destruct the graph reader.
-    ~UndirGraphReader() {
+    ~UGraphReader() {
       if (own_reader) 
 	delete reader;
@@ -527,5 +527,5 @@
     /// 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,5 +533,5 @@
 
     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,5 +542,5 @@
     /// 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,5 +549,5 @@
 
     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,5 +559,5 @@
     /// 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,12 +569,12 @@
     /// 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,14 +585,14 @@
     /// 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,7 +602,7 @@
     /// 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,12 +613,12 @@
     /// 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,14 +629,14 @@
     /// 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,7 +646,7 @@
     /// 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,5 +655,5 @@
     ///
     /// 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,6 +663,6 @@
     ///
     /// 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,6 +671,6 @@
     ///
     /// 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,5 +679,5 @@
     ///  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,5 +688,5 @@
     ///  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,5 +717,5 @@
     bool isLabelReader() const {
       return nodeset_reader.isLabelReader() && 
-        undir_edgeset_reader.isLabelReader();
+        u_edgeset_reader.isLabelReader();
     }
 
@@ -733,5 +733,5 @@
     /// 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,6 +741,6 @@
     /// 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,8 +754,8 @@
 
     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,5 +765,5 @@
   ///
   /// 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,5 +774,5 @@
   /// \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,5 +781,5 @@
   ///
   /// 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,5 +790,5 @@
   /// \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);
   }
