Index: lemon/lemon_reader.h
===================================================================
--- lemon/lemon_reader.h	(revision 1901)
+++ lemon/lemon_reader.h	(revision 1909)
@@ -105,5 +105,5 @@
     class ForwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -135,5 +135,5 @@
     class BackwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -1168,6 +1168,6 @@
   ///
   /// 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,5 +1184,5 @@
   /// 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,5 +1192,5 @@
   /// \relates LemonReader
   template <typename _Graph, typename _Traits = DefaultReaderTraits>
-  class UndirEdgeSetReader : public LemonReader::SectionReader {
+  class UEdgeSetReader : public LemonReader::SectionReader {
     typedef LemonReader::SectionReader Parent;
   public:
@@ -1200,17 +1200,17 @@
     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,6 +1224,6 @@
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeSetReader.
-    virtual ~UndirEdgeSetReader() {
+    /// Destructor for UEdgeSetReader.
+    virtual ~UEdgeSetReader() {
       for (typename MapReaders::iterator it = readers.begin(); 
 	   it != readers.end(); ++it) {
@@ -1233,6 +1233,6 @@
 
   private:
-    UndirEdgeSetReader(const UndirEdgeSetReader&);
-    void operator=(const UndirEdgeSetReader&);
+    UEdgeSetReader(const UEdgeSetReader&);
+    void operator=(const UEdgeSetReader&);
 
   public:
@@ -1242,5 +1242,5 @@
     /// 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,5 +1249,5 @@
 
     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,5 +1259,5 @@
     /// 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,5 +1266,5 @@
 
     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,7 +1275,7 @@
 
     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,5 +1286,5 @@
       readers.insert(
 	make_pair(name, new _reader_bits::
-		  MapReader<UndirEdge, Map, Reader>(map, reader)));
+		  MapReader<UEdge, Map, Reader>(map, reader)));
       return *this;
     }
@@ -1296,5 +1296,5 @@
     /// 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,5 +1304,5 @@
       }
       readers.insert(make_pair(name, new _reader_bits::
-			       SkipReader<UndirEdge, Reader>(reader)));
+			       SkipReader<UEdge, Reader>(reader)));
       return *this;
     }
@@ -1312,5 +1312,5 @@
     /// 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,5 +1319,5 @@
 
     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,5 +1329,5 @@
     /// 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,5 +1336,5 @@
 
     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,5 +1345,5 @@
 
     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,5 +1362,5 @@
     /// 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,5 +1374,5 @@
     /// 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,5 +1381,5 @@
       std::string id;
       ls >> command >> name;
-      return command == "@undiredgeset" && name == id;
+      return command == "@uedgeset" && name == id;
     }
 
@@ -1391,5 +1391,5 @@
 	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,5 +1422,5 @@
 	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,6 +1443,6 @@
     /// 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,9 +1456,9 @@
       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,12 +1470,12 @@
 
     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,6 +1697,6 @@
   /// \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,26 +1705,26 @@
   /// \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,28 +1733,28 @@
     /// \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,5 +1778,5 @@
       std::string id;
       ls >> command >> name;
-      return command == "@undiredges" && name == id;
+      return command == "@uedges" && name == id;
     }
 
@@ -1788,5 +1788,5 @@
 	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,7 +1797,7 @@
 	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,9 +1820,9 @@
 	}
       }
-      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,7 +1835,7 @@
 
     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,6 +2026,6 @@
     ///
     /// Gives back how many undirected edgesets are in the file.
-    int undirEdgeSetNum() const {
-      return undiredgesets.size();
+    int uEdgeSetNum() const {
+      return uedgesets.size();
     }
 
@@ -2034,6 +2034,6 @@
     ///
     /// 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,6 +2042,6 @@
     ///
     /// 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,6 +2096,6 @@
     ///
     /// 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,6 +2105,6 @@
     /// 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,6 +2114,6 @@
     /// 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,7 +2161,7 @@
 	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,7 +2170,7 @@
 	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,12 +2191,12 @@
       } 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,9 +2234,9 @@
     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;
