Index: lemon/graph_writer.h
===================================================================
--- lemon/graph_writer.h	(revision 1901)
+++ lemon/graph_writer.h	(revision 1909)
@@ -316,15 +316,15 @@
   /// \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,5 +332,5 @@
   ///
   /// \code
-  /// IdMap<UndirListGraph, Node> nodeLabelMap;
+  /// IdMap<ListUGraph, Node> nodeLabelMap;
   /// writer.writeNodeMap("label", nodeLabelMap);
   ///
@@ -339,5 +339,5 @@
   /// \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,8 +345,8 @@
   /// 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,5 +359,5 @@
   ///
   ///
-  /// 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,5 +367,5 @@
   /// writer.writeNode("target", targetNode);
   ///
-  /// writer.writeUndirEdge("observed", undirEdge);
+  /// writer.writeUEdge("observed", uEdge);
   /// \endcode
   ///
@@ -385,5 +385,5 @@
   /// \author Balazs Dezso
   template <typename _Graph, typename _WriterTraits = DefaultWriterTraits> 
-  class UndirGraphWriter {
+  class UGraphWriter {
   public:
     
@@ -391,42 +391,42 @@
     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,5 +434,5 @@
     ///
     /// Destruct the graph writer.
-    ~UndirGraphWriter() {
+    ~UGraphWriter() {
       if (own_writer) 
 	delete writer;
@@ -443,5 +443,5 @@
    /// 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,5 +452,5 @@
    /// 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,6 +462,6 @@
    /// 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,7 +471,7 @@
    /// 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,6 +482,6 @@
     /// 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,7 +492,7 @@
     /// 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,5 +502,5 @@
     /// 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,6 +511,6 @@
     /// 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,6 +520,6 @@
     /// 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,5 +529,5 @@
     /// 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,5 +539,5 @@
     /// 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,5 +575,5 @@
     /// 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,6 +583,6 @@
     /// 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,8 +594,8 @@
 
     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,5 +605,5 @@
   ///
   /// 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,6 +612,6 @@
   /// \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,5 +619,5 @@
   ///
   /// 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,7 +628,7 @@
   /// \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);
   }
 
