Changeset 1115:444f69240539 in lemon-0.x for src/work

Timestamp:

02/01/05 16:56:37 (19 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1514

Message:

Some changes in the IO and map utilities.

Location:

src/work/deba

Files:

• graph_io_test.cc (modified) (3 diffs)
• graph_reader.h (modified) (20 diffs)
• graph_writer.h (modified) (12 diffs)
• map_utils.h (modified) (6 diffs)

src/work/deba/graph_io_test.cc

@@ -19 +19 @@
 
   SmartGraph::NodeMap<int> id(graph);
-  reader.readNodeMap("id", id);
+  reader.addNodeMap("id", id);
 
   SmartGraph::NodeMap<int> cost(graph);
-  reader.readNodeMap("cost", cost);
+  reader.addNodeMap("cost", cost);
  
   SmartGraph::NodeMap<string> color(graph);
-  reader.readNodeMap("color", color);
+  reader.addNodeMap("color", color);
 
   SmartGraph::NodeMap<string> description(graph);
-  reader.readNodeMap<QuotedStringReader>("description", description);
+  reader.addNodeMap<QuotedStringReader>("description", description);
 
   SmartGraph::EdgeMap<char> mmap(graph);
-  reader.readEdgeMap("mmap", mmap);
+  reader.addEdgeMap("mmap", mmap);
 
   reader.skipEdgeMap<QuotedStringReader>("description");
 
   SmartGraph::Node source;
-  reader.readNode("source", source);
+  reader.addNode("source", source);
   
   SmartGraph::Edge newedge;
-  reader.readEdge("newedge", newedge);
+  reader.addEdge("newedge", newedge);
 
   try {
@@ -48 +48 @@
     cerr << e.what() << endl;
   }
+
   for (SmartGraph::NodeIt it(graph); it != INVALID; ++it) {
     cout << cost[it] << ' ' << color[it] << ' ' << description[it] << endl;
@@ -53 +54 @@
 
   for (SmartGraph::EdgeIt it(graph); it != INVALID; ++it) {
-    cout << mmap[it] << ' ' << id[graph.source(it)] << ' ' << id[graph.target(it)]  << endl;
+    cout << mmap[it] << ' ' << id[graph.source(it)] << ' ' << 
+      id[graph.target(it)]  << endl;
   }
 
-  cout << id[source] << ' ' << cost[source] << ' ' << color[source] << ' ' << description[source] << endl;
-  cout << mmap[newedge] << ' ' << id[graph.source(newedge)] << ' ' << id[graph.target(newedge)]  << endl;
+  cout << id[source] << ' ' << cost[source] << ' ' <<
+    color[source] << ' ' << description[source] << endl;
+  cout << mmap[newedge] << ' ' << id[graph.source(newedge)] << 
+    ' ' << id[graph.target(newedge)]  << endl;
 
   ofstream output("copy.lgf");
   GraphWriter<SmartGraph> writer(output, graph);
   
-  DescriptorMap<SmartGraph, SmartGraph::Node, SmartGraph::NodeIt, SmartGraph::NodeMap<int> > node_ids(graph);
+  DescriptorMap<SmartGraph, SmartGraph::Node, SmartGraph::NodeMap<int> > 
+    node_ids(graph);
   
-  writer.writeNodeMap("id", node_ids);
-  writer.writeNodeMap<QuotedStringWriter>("format", description);
+  writer.addNodeMap("id", node_ids);
+  writer.addNodeMap<QuotedStringWriter>("format", description);
 
-  DescriptorMap<SmartGraph, SmartGraph::Edge, SmartGraph::EdgeIt, SmartGraph::EdgeMap<int> > edge_ids(graph);
+  IdMap<SmartGraph, SmartGraph::Edge > edge_ids(graph);
 
-  writer.writeEdgeMap("id", edge_ids);
-  writer.writeEdgeMap("chars", mmap);
+  writer.addEdgeMap("id", edge_ids);
+  writer.addEdgeMap("chars", mmap);
   
-  writer.writeNode("source", node_ids.inverse()[3]);
-  writer.writeEdge("elek", edge_ids.inverse()[6]);
+  writer.addNode("source", node_ids.inverse()[3]);
+  //  writer.addEdge("elek", edge_ids.inverse()[6]);
   writer.write();
   

src/work/deba/graph_reader.h

@@ -38 +38 @@
   class IOException {
   public:
+    virtual ~IOException() {}
     virtual string what() const = 0;
   };
@@ -56 +57 @@
     typedef _Exception Exception;
     StreamException(int _line, Exception _exception) 
-      : line_num(_line), Exception(_exception) {}
+      : Exception(_exception), line_num(_line) {}
     virtual int line() const {
       return line_num;
     }
+
+    virtual ~StreamException() {}
+
     virtual std::string what() const {
       ostringstream os;
@@ -71 +75 @@
 
   // Readers and ReaderTraits
-  
+  /// \brief Standard ReaderTraits for the GraphReader class.
+  ///
+  /// 
+ 
   struct DefaultReaderTraits {
 
@@ -97 +104 @@
       value.clear();
       is >> ws;
-      if (!is.get(c) || c != '\"') throw DataFormatException("Quoted string format");
+      if (!is.get(c) || c != '\"') 
+        throw DataFormatException("Quoted string format");
       while (is.get(c) && c != '\"') {
         if (escaped && c == '\\') {
@@ -193 +201 @@
     typedef typename ReaderTraits::DefaultReader DefaultReader;
 
-    GraphReader(std::istream& _is, Graph& _graph, const DefaultReader& _reader = DefaultReader()) 
+    GraphReader(std::istream& _is, Graph& _graph, 
+                const DefaultReader& _reader = DefaultReader()) 
       : is(_is), graph(_graph), nodeSkipper(_reader), edgeSkipper(_reader) {}
 
@@ -199 +208 @@
     ~GraphReader() {
 
-      for (typename NodeMapReaders::iterator it = node_map_readers.begin(); it != node_map_readers.end(); ++it) {
+      for (typename NodeMapReaders::iterator it = node_map_readers.begin(); 
+           it != node_map_readers.end(); ++it) {
         delete it->second;
       }
 
-      for (typename EdgeMapReaders::iterator it = edge_map_readers.begin(); it != edge_map_readers.end(); ++it) {
+      for (typename EdgeMapReaders::iterator it = edge_map_readers.begin(); 
+           it != edge_map_readers.end(); ++it) {
         delete it->second;
       }
@@ -212 +223 @@
 
     template <typename Map>
-    GraphReader& readNodeMap(std::string name, Map& map) {
-      return readNodeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
+    GraphReader& addNodeMap(std::string name, Map& map) {
+      return addNodeMap<typename ReaderTraits::template 
+        Reader<typename Map::Value>, Map>(name, map);
     }
 
     template <typename Reader, typename Map>
-    GraphReader& readNodeMap(std::string name, Map& map, const Reader& reader = Reader()) {
+    GraphReader& addNodeMap(std::string name, Map& map, 
+                             const Reader& reader = Reader()) {
       if (node_map_readers.find(name) != node_map_readers.end()) {
         throw Exception() << "Multiple read rule for node map: " << name;
       }
-      node_map_readers.insert(make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
+      node_map_readers.insert(
+        make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
       return *this;
     }
 
     template <typename Reader>
-    GraphReader& skipNodeMap(std::string name, const Reader& reader = Reader()) {
+    GraphReader& skipNodeMap(std::string name, 
+                             const Reader& reader = Reader()) {
       if (node_map_readers.find(name) != node_map_readers.end()) {
         throw Exception() << "Multiple read rule for node map: " << name;
       }
-      node_map_readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader)));
+      node_map_readers.insert(
+        make_pair(name, new SkipReader<Node, Reader>(reader)));
       return *this;
     }
@@ -237 +253 @@
 
     template <typename Map>
-    GraphReader& readEdgeMap(std::string name, Map& map) { 
-      return readEdgeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
+    GraphReader& addEdgeMap(std::string name, Map& map) { 
+      return addEdgeMap<typename ReaderTraits::template
+        Reader<typename Map::Value>, Map>(name, map);
     }
 
 
     template <typename Reader, typename Map>
-    GraphReader& readEdgeMap(std::string name, Map& map, const Reader& reader = Reader()) {
+    GraphReader& addEdgeMap(std::string name, Map& map,
+                             const Reader& reader = Reader()) {
       if (edge_map_readers.find(name) != edge_map_readers.end()) {
         throw Exception() << "Multiple read rule for edge map: " << name;
       }
-      edge_map_readers.insert(make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
+      edge_map_readers.insert(
+        make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
       return *this;
     }
 
     template <typename Reader>
-    GraphReader& skipEdgeMap(std::string name, const Reader& reader = Reader()) {
+    GraphReader& skipEdgeMap(std::string name,
+                             const Reader& reader = Reader()) {
       if (edge_map_readers.find(name) != edge_map_readers.end()) {
         throw Exception() << "Multiple read rule for edge map: " << name;
       }
-      edge_map_readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader)));
+      edge_map_readers.insert(
+        make_pair(name, new SkipReader<Edge, Reader>(reader)));
       return *this;
     }
 
     // Node rules
-    GraphReader& readNode(std::string name, Node& node) {
+    GraphReader& addNode(std::string name, Node& node) {
       if (node_readers.find(name) != node_readers.end()) {
         throw Exception() << "Multiple read rule for node";
       }
       node_readers.insert(make_pair(name, &node));
+      return *this;
     }
 
     // Edge rules
 
-    GraphReader& readEdge(std::string name, Edge& edge) {
+    GraphReader& addEdge(std::string name, Edge& edge) {
       if (edge_readers.find(name) != edge_readers.end()) {
         throw Exception() << "Multiple read rule for edge";
       }
       edge_readers.insert(make_pair(name, &edge));
+      return *this;
     }
 
@@ -307 +330 @@
     template <typename Item> class InverterBase;
 
-    std::string readNodeSet(int& line_num, auto_ptr<InverterBase<Node> > & nodeInverter) {
+    std::string readNodeSet(int& line_num, 
+                            auto_ptr<InverterBase<Node> > & nodeInverter) {
       std::vector<ReaderBase<Node>* > index;
       {
@@ -335 +359 @@
         std::istringstream ls(line);
         nodeInverter->read(ls, node);
-        for (int i = 1; i < index.size(); ++i) {
+        for (int i = 1; i < (int)index.size(); ++i) {
           index[i]->read(ls, node);
         }
@@ -343 +367 @@
 
     std::string readEdgeSet(int& line_num, 
-                     auto_ptr<InverterBase<Edge> > & edgeInverter, auto_ptr<InverterBase<Node> > & nodeInverter) {
+                            auto_ptr<InverterBase<Edge> > & edgeInverter, 
+                            auto_ptr<InverterBase<Node> > & nodeInverter) {
       std::vector<ReaderBase<Edge>*> index;
       {
@@ -373 +398 @@
         Edge edge = graph.addEdge(source, target);
         edgeInverter->read(ls, edge);
-        for (int i = 1; i < index.size(); ++i) {
+        for (int i = 1; i < (int)index.size(); ++i) {
           index[i]->read(ls, edge);
         }
@@ -380 +405 @@
     }
 
-    std::string readNodes(int& line_num, auto_ptr<InverterBase<Node> >& nodeInverter) {
+    std::string readNodes(int& line_num, 
+                          auto_ptr<InverterBase<Node> >& nodeInverter) {
       std::string line;
       while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
@@ -394 +420 @@
     }
 
-    std::string readEdges(int& line_num, auto_ptr<InverterBase<Edge> >& edgeInverter) {
+    std::string readEdges(int& line_num, 
+                          auto_ptr<InverterBase<Edge> >& edgeInverter) {
       std::string line;
       while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
@@ -412 +439 @@
       while (++line_num, getline(is, line)) {   
         int vi = line.find_first_not_of(" \t");
-        if (vi != string::npos && line[vi] != '#') {
+        if (vi != (int)string::npos && line[vi] != '#') {
           return line.substr(vi);
         }
@@ -446 +473 @@
         : map(_map), reader(_reader) {}
 
+      virtual ~MapReaderInverter() {}
+
       virtual void read(std::istream& is, const Item& item) {
         Value value;
@@ -483 +512 @@
         : reader(_reader) {}
 
+      virtual ~SkipReaderInverter() {}
+
       virtual void read(std::istream& is, const Item& item) {
         Value value;
@@ -514 +545 @@
     public:
       typedef _Item Item;
+
+      //      virtual ~ReaderBase() {}
 
       virtual void read(std::istream& is, const Item& item) = 0;
@@ -533 +566 @@
         : map(_map), reader(_reader) {}
 
+      virtual ~MapReader() {}
 
       virtual void read(std::istream& is, const Item& item) {
@@ -556 +590 @@
       SkipReader(const Reader& _reader) : reader(_reader) {}
 
+      virtual ~SkipReader() {}
+
       virtual void read(std::istream& is, const Item& item) {
         Value value;

src/work/deba/graph_writer.h

@@ -55 +55 @@
 
     void write(std::ostream& os, const std::string& value) {
-      char c;
       os << "\"";
       if (escaped) {
         ostringstream ls;
-        for (int i = 0; i < value.size(); ++i) {
+        for (int i = 0; i < (int)value.size(); ++i) {
           writeEscape(ls, value[i]);
         }
@@ -137 +136 @@
 
     ~GraphWriter() {
-
-      for (typename NodeMapWriters::iterator it = node_map_writers.begin(); it != node_map_writers.end(); ++it) {
+      for (typename NodeMapWriters::iterator it = node_map_writers.begin(); 
+           it != node_map_writers.end(); ++it) {
         delete it->second;
       }
 
-      for (typename EdgeMapWriters::iterator it = edge_map_writers.begin(); it != edge_map_writers.end(); ++it) {
+      for (typename EdgeMapWriters::iterator it = edge_map_writers.begin();
+           it != edge_map_writers.end(); ++it) {
         delete it->second;
       }
@@ -151 +151 @@
 
     template <typename Map>
-    GraphWriter& writeNodeMap(std::string name, const Map& map) {
-      return writeNodeMap<typename WriterTraits::template Writer<typename Map::Value>, Map>(name, map);
+    GraphWriter& addNodeMap(std::string name, const Map& map) {
+      return addNodeMap<typename WriterTraits::template Writer<
+        typename Map::Value>, Map>(name, map);
     }
 
     template <typename Writer, typename Map>
-    GraphWriter& writeNodeMap(std::string name, const Map& map, const Writer& writer = Writer()) {
+    GraphWriter& addNodeMap(std::string name, const Map& map, 
+                              const Writer& writer = Writer()) {
       //      if (node_map_writers.find(name) != node_map_writers.end()) {
-      //        throw Exception() << "Multiple write rule for node map: " << name;
+      //        throw Exception() << "Multiple write rule for node map: " 
+      //        << name;
       //      }
-      node_map_writers.push_back(make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
+      node_map_writers.push_back(
+        make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
       return *this;
     }
@@ -167 +171 @@
 
     template <typename Map>
-    GraphWriter& writeEdgeMap(std::string name, const Map& map) { 
-      return writeEdgeMap<typename WriterTraits::template Writer<typename Map::Value>, Map>(name, map);
+    GraphWriter& addEdgeMap(std::string name, const Map& map) { 
+      return addEdgeMap<typename WriterTraits::template Writer<typename Map::Value>, Map>(name, map);
     }
 
 
     template <typename Writer, typename Map>
-    GraphWriter& writeEdgeMap(std::string name, const Map& map, const Writer& writer = Writer()) {
+    GraphWriter& addEdgeMap(std::string name, const Map& map, const Writer& writer = Writer()) {
       //      if (edge_map_writers.find(name) != edge_map_writers.end()) {
       //        throw Exception() << "Multiple write rule for edge map: " << name;
@@ -182 +186 @@
 
     // Node rules
-    GraphWriter& writeNode(std::string name, const Node& node) {
+    GraphWriter& addNode(std::string name, const Node& node) {
       //      if (node_writers.find(name) != node_writers.end()) {
       //        throw Exception() << "Multiple write rule for node";
       //      }
       node_writers.push_back(make_pair(name, node));
+      return *this;
     }
 
     // Edge rules
 
-    GraphWriter& writeEdge(std::string name, const Edge& edge) {
+    GraphWriter& addEdge(std::string name, const Edge& edge) {
       //      if (edge_writers.find(name) != edge_writers.end()) {
       //        throw Exception() << "Multiple write rule for edge";
       //      }
       edge_writers.push_back(make_pair(name, edge));
+      return *this;
     }
 
@@ -211 +217 @@
       if (node_map_writers.size() == 0) return;
       os << "@nodeset" << std::endl;
-      for (int i = 0; i < node_map_writers.size(); ++i) {
+      for (int i = 0; i < (int)node_map_writers.size(); ++i) {
         os << node_map_writers[i].first << '\t';
       } 
       os << std::endl;
       for (NodeIt it(graph); it != INVALID; ++it) {
-        for (int i = 0; i < node_map_writers.size(); ++i) {
+        for (int i = 0; i < (int)node_map_writers.size(); ++i) {
           node_map_writers[i].second->write(os, it);
         }
@@ -231 +237 @@
       os << "@edgeset" << std::endl;
       os << "\t\t";
-      for (int i = 0; i < edge_map_writers.size(); ++i) {
+      for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
         os << edge_map_writers[i].first << '\t';
       } 
@@ -238 +244 @@
         node_map_writers[0].second->write(os, graph.source(it));
         node_map_writers[0].second->write(os, graph.target(it));
-        for (int i = 0; i < edge_map_writers.size(); ++i) {
+        for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
           edge_map_writers[i].second->write(os, it);
         }
@@ -251 +257 @@
       }
       os << "@nodes" << std::endl;
-      for (int i = 0; i < node_writers.size(); ++i) {
+      for (int i = 0; i < (int)node_writers.size(); ++i) {
         os << node_writers[i].first << '\t';
         node_map_writers[0].second->write(os, node_writers[i].second);
@@ -264 +270 @@
       }
       os << "@edges" << std::endl;
-      for (int i = 0; i < edge_writers.size(); ++i) {
+      for (int i = 0; i < (int)edge_writers.size(); ++i) {
         os << edge_writers[i].first << '\t';
         edge_map_writers[0].second->write(os, edge_writers[i].second);
@@ -296 +302 @@
 
       virtual void write(std::ostream& os, const Item& item) {
-        Value value;
         writer.write(os, map[item]);
       }
@@ -304 +309 @@
 
 
-    typedef std::vector< std::pair<std::string, WriterBase<Node>*> > NodeMapWriters;
+    typedef std::vector< std::pair<std::string, WriterBase<Node>*> > 
+      NodeMapWriters;
     NodeMapWriters node_map_writers;
 
-    typedef std::vector< std::pair<std::string, WriterBase<Edge>*> > EdgeMapWriters;
+    typedef std::vector< std::pair<std::string, WriterBase<Edge>*> > 
+      EdgeMapWriters;
     EdgeMapWriters edge_map_writers;
 

src/work/deba/map_utils.h

@@ -15 +15 @@
  */
 
-///\ingroup gutils
+///\ingroup mutils
 ///\file
 ///\brief Map utilities.
@@ -50 +50 @@
     typedef typename _Map::ConstReference ConstReference;
 
-    /// Constructor.
-
+    /// \brief Constructor.
+    ///
     /// Construct a new InversableMap for the graph.
     ///
     InversableMap(const Graph& graph) : Map(graph) {} 
     
-    /// The setter function of the map.
-
-    /// It sets the map and the inverse map 
+    /// \brief The setter function of the map.
+    ///
+    /// It sets the map and the inverse map to given key-value pair.
     void set(const Key& key, const Value& val) {
       Value oldval = Map::operator[](key);
@@ -96 +96 @@
 
 
-  // unique, continous, mutable
+  
+  /// \brief Provides a mutable, continous and unique descriptor for each 
+  /// item in the graph.
+  ///
+  /// The DescriptorMap class provides a mutable, continous and immutable
+  /// mapping for each item in the graph.
+  ///
+  /// \param _Graph The graph class the \c DescriptorMap belongs to.
+  /// \param _Item The Item is the Key of the Map. It may be Node, Edge or 
+  /// UndirEdge.
+  /// \param _Map A ReadWriteMap mapping from the item type to integer.
 
   template <
     typename _Graph,   
     typename _Item,
-    typename _ItemIt,
     typename _Map
   >
   class DescriptorMap : protected _Map {
+
+    typedef _Item Item;
+    typedef _Map Map;
+
   public:
+    /// The graph class of DescriptorMap.
     typedef _Graph Graph;
-    typedef _Item Item;
-    typedef _ItemIt ItemIt;
-    typedef _Map Map;
-
-
+
+    /// The key type of DescriptorMap (Node, Edge, UndirEdge).
     typedef typename _Map::Key Key;
+    /// The value type of DescriptorMap.
     typedef typename _Map::Value Value;
 
-    typedef vector<Item> InverseMap;
-
+    typedef std::vector<Item> InverseMap;
+
+    /// \brief Constructor.
+    ///
+    /// Constructor for creating descriptor map.
     DescriptorMap(const Graph& _graph) : Map(_graph) {
       build();
@@ -135 +150 @@
     virtual void build() {
       Map::build();
-      for (ItemIt it(*Map::getGraph()); it != INVALID; ++it) {
+      Item it;
+      for (getGraph()->first(it); it != INVALID; getGraph()->next(it)) {
         Map::set(it, inv_map.size());
         inv_map.push_back(it);  
@@ -146 +162 @@
     }
 
+    /// \brief Gives back the \e descriptor of the item.
+    ///
+    /// Gives back the mutable and unique \e descriptor of the map.
     int operator[](const Item& item) const {
       return Map::operator[](item);
     }
-
-    
+    
+    /// \brief Gives back the inverse of the map.
+    ///
+    /// Gives back the inverse of the map.
     const InverseMap inverse() const {
       return inv_map;
@@ -158 +179 @@
     vector<Item> inv_map;
   };
-
-  // unique, immutable => IDMap
   
-  
+  /// Provides an immutable and unique id for each item in the graph.
+
+  /// The IdMap class provides an unique and immutable mapping for each item
+  /// in the graph.
+  ///
+  template <typename _Graph, typename _Item>
+  class IdMap {
+  public:
+    typedef _Graph Graph;
+    typedef int Value;
+    typedef _Item Item;
+
+    /// \brief The class represents the inverse of the map.
+    ///
+    /// The class represents the inverse of the map.
+    /// \see inverse()
+    class InverseMap {
+    protected:
+      InverseMap(const Graph& _graph) : graph(_graph) {}
+    public:
+      /// \brief Gives back the given item by its id.
+      ///
+      /// Gives back the given item by its id.
+      /// 
+      Item operator[](int id) const { return graph->fromId(id, Item());}
+    private:
+      Graph* graph;
+    };
+
+    /// \brief Constructor.
+    ///
+    /// Constructor for creating id map.
+    IdMap(const Graph& _graph) : graph(&_graph) {}
+
+    /// \brief Gives back the \e id of the item.
+    ///
+    /// Gives back the immutable and unique \e id of the map.
+    int operator[](const Item& item) const { return graph->id(item);}
+
+    /// \brief Gives back the inverse of the map.
+    ///
+    /// Gives back the inverse of the map.
+    InverseMap inverse() const { return InverseMap(*graph);} 
+
+  private:
+    const Graph* graph;
+
+  };
+
+
 
 }