Changeset 1909:2d806130e700 in lemon-0.x for lemon/lemon_reader.h

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

File:

• lemon/lemon_reader.h (modified) (47 diffs)

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;