diff -r e225719bde6b -r 2d806130e700 lemon/lemon_reader.h
--- a/lemon/lemon_reader.h	Thu Jan 26 06:44:22 2006 +0000
+++ b/lemon/lemon_reader.h	Thu Jan 26 15:42:13 2006 +0000
@@ -104,7 +104,7 @@
     template <typename Graph, typename Map>
     class ForwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
       ForwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map) 
@@ -134,7 +134,7 @@
     template <typename Graph, typename Map>
     class BackwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
       BackwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map) 
@@ -1167,8 +1167,8 @@
   /// \brief SectionReader for reading a undirected graph's edgeset.
   ///
   /// 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
   /// with white spaces. Each next lines describes an edge in the edgeset. The
@@ -1183,7 +1183,7 @@
   /// If the edgeset contains an \c "label" named map then it will be regarded
   /// 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 
   /// nodes have to be connected. If a NodeSetReader reads an "label" named map,
@@ -1191,7 +1191,7 @@
   ///
   /// \relates LemonReader
   template <typename _Graph, typename _Traits = DefaultReaderTraits>
-  class UndirEdgeSetReader : public LemonReader::SectionReader {
+  class UEdgeSetReader : public LemonReader::SectionReader {
     typedef LemonReader::SectionReader Parent;
   public:
 
@@ -1199,19 +1199,19 @@
     typedef _Traits Traits;
     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, 
 		       const std::string& _name = std::string(),
@@ -1223,8 +1223,8 @@
     }
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeSetReader.
-    virtual ~UndirEdgeSetReader() {
+    /// Destructor for UEdgeSetReader.
+    virtual ~UEdgeSetReader() {
       for (typename MapReaders::iterator it = readers.begin(); 
 	   it != readers.end(); ++it) {
 	delete it->second;
@@ -1232,8 +1232,8 @@
     }
 
   private:
-    UndirEdgeSetReader(const UndirEdgeSetReader&);
-    void operator=(const UndirEdgeSetReader&);
+    UEdgeSetReader(const UEdgeSetReader&);
+    void operator=(const UEdgeSetReader&);
 
   public:
 
@@ -1241,14 +1241,14 @@
     ///
     /// 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, 
 	typename _reader_bits::Arg<Map>::Type>(name, map);
     }
 
     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, 
 	typename _reader_bits::Arg<Map>::Type>(name, map);
@@ -1258,14 +1258,14 @@
     ///
     /// 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>
 	(name, map, reader);
     }
 
     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 >
 	(name, map, reader);
@@ -1274,9 +1274,9 @@
   private:
 
     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()) {
 	ErrorMessage msg;
@@ -1285,7 +1285,7 @@
       }
       readers.insert(
 	make_pair(name, new _reader_bits::
-		  MapReader<UndirEdge, Map, Reader>(map, reader)));
+		  MapReader<UEdge, Map, Reader>(map, reader)));
       return *this;
     }
 
@@ -1295,7 +1295,7 @@
     ///
     /// 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()) {
 	ErrorMessage msg;
@@ -1303,7 +1303,7 @@
 	throw IOParameterError(msg.message());
       }
       readers.insert(make_pair(name, new _reader_bits::
-			       SkipReader<UndirEdge, Reader>(reader)));
+			       SkipReader<UEdge, Reader>(reader)));
       return *this;
     }
 
@@ -1311,14 +1311,14 @@
     ///
     /// 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,
 	typename _reader_bits::Arg<Map>::Type>(name, map);
     }
 
     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,
 	typename _reader_bits::Arg<Map>::Type>(name, map);
@@ -1328,14 +1328,14 @@
     ///
     /// 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>
 	(name, map, reader);
     }
 
     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>
 	(name, map, reader);
@@ -1344,7 +1344,7 @@
   private:
 
     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>();
       checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
@@ -1361,7 +1361,7 @@
     ///
     /// 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);
       skipMap("-" + name, reader);
@@ -1373,14 +1373,14 @@
     /// \brief Gives back true when the SectionReader can process 
     /// 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) {
       std::istringstream ls(line);
       std::string command;
       std::string id;
       ls >> command >> name;
-      return command == "@undiredgeset" && name == id;
+      return command == "@uedgeset" && name == id;
     }
 
     /// \brief Reader function of the section.
@@ -1390,7 +1390,7 @@
       if (!nodeLabelReader->isLabelReader()) {
 	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;
 
       getline(is, line);
@@ -1421,7 +1421,7 @@
 	std::istringstream ls(line);
 	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);
 	}
@@ -1442,8 +1442,8 @@
     ///
     /// 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);
     } 
 
     /// \brief Gives back the directed edge by its label.
@@ -1455,11 +1455,11 @@
     void readLabel(std::istream& is, Edge& edge) const {
       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 "
 			      "in undirected edgeset");
@@ -1469,14 +1469,14 @@
   private:
 
     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;
+    _reader_bits::SkipReader<UEdge, DefaultSkipper> skipper;
 
-    std::auto_ptr<_reader_bits::MapInverterBase<UndirEdge> > inverter;
+    std::auto_ptr<_reader_bits::MapInverterBase<UEdge> > inverter;
     std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
   };
 
@@ -1696,66 +1696,66 @@
   /// \ingroup io_group
   /// \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 
   /// and then the undirected edge id. 
   ///
   /// \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));
     }
 
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeReader.
-    virtual ~UndirEdgeReader() {}
+    /// Destructor for UEdgeReader.
+    virtual ~UEdgeReader() {}
   private:
-    UndirEdgeReader(const UndirEdgeReader&);
-    void operator=(const UndirEdgeReader&);
+    UEdgeReader(const UEdgeReader&);
+    void operator=(const UEdgeReader&);
 
   public:
 
-    /// \brief Add an undirected edge reader command for the UndirEdgeReader.
+    /// \brief Add an undirected edge reader command for the UEdgeReader.
     ///
-    /// Add an undirected edge reader command for the UndirEdgeReader.
-    void readUndirEdge(const std::string& name, UndirEdge& item) {
-      if (undirEdgeReaders.find(name) != undirEdgeReaders.end()) {
+    /// 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)));
+      uEdgeReaders.insert(make_pair(name, _reader_bits::
+					ItemStore<UEdge>(item)));
     }
 
-    /// \brief Add an edge reader command for the UndirEdgeReader.
+    /// \brief Add an edge reader command for the UEdgeReader.
     ///
-    /// Add an edge reader command for the UndirEdgeReader.
+    /// Add an edge reader command for the UEdgeReader.
     void readEdge(const std::string& name, Edge& item) {
       if (edgeReaders.find(name) != edgeReaders.end()) {
 	ErrorMessage msg;
@@ -1777,7 +1777,7 @@
       std::string command;
       std::string id;
       ls >> command >> name;
-      return command == "@undiredges" && name == id;
+      return command == "@uedges" && name == id;
     }
 
     /// \brief Reader function of the section.
@@ -1787,7 +1787,7 @@
       if (!edgeLabelReader->isLabelReader()) {
 	throw DataFormatError("Cannot find undirected edgeset or label map");
       }
-      if (!undirEdgeLabelReader->isLabelReader()) {
+      if (!uEdgeLabelReader->isLabelReader()) {
 	throw DataFormatError("Cannot find undirected edgeset or label map");
       }
       std::string line;
@@ -1796,9 +1796,9 @@
 	std::string id;
 	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;
 	  }	
@@ -1819,11 +1819,11 @@
 	  throw IOParameterError(msg.message());
 	}
       }
-      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());
 	}
       }
@@ -1834,9 +1834,9 @@
     std::string name;
 
     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;
     EdgeReaders edgeReaders;
@@ -2025,24 +2025,24 @@
     /// \brief Gives back how many undirected edgesets are in the file.
     ///
     /// Gives back how many undirected edgesets are in the file.
-    int undirEdgeSetNum() const {
-      return undiredgesets.size();
+    int uEdgeSetNum() const {
+      return uedgesets.size();
     }
 
     /// \brief Gives back the name of undirected edgeset on the indiced 
     /// position.
     ///
     /// 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;
     }
 
     /// \brief Gives back the map names of undirected edgeset on the indiced 
     /// position.
     ///
     /// 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;
     }
 
     /// \brief Gives back how many labeled nodes section are in the file.
@@ -2095,8 +2095,8 @@
     /// in the file.
     ///
     /// Gives back how many labeled undirected edges section are in the file.
-    int undirEdgesNum() const {
-      return undiredges.size();
+    int uEdgesNum() const {
+      return uedges.size();
     }
 
     /// \brief Gives back the name of labeled undirected edges section 
@@ -2104,8 +2104,8 @@
     ///
     /// 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;
     }
 
     /// \brief Gives back the names of the labeled undirected edges in 
@@ -2113,8 +2113,8 @@
     ///
     /// 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;
     }
 
  
@@ -2160,18 +2160,18 @@
       } else if (command == "@edgeset") {
 	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;
 	nodes.push_back(SectionInfo(name));
       } else if (command == "@edges") {
 	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;
 	attributes.push_back(SectionInfo(name));
@@ -2190,14 +2190,14 @@
 	readMapNames(is, nodesets.back().items);
       } 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);
       }
@@ -2233,11 +2233,11 @@
 
     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;