Changeset 1421:7a21e1414c38 in lemon-0.x for src/lemon/graph_reader.h

Timestamp:

05/14/05 19:39:37 (19 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

IO with undirected edgesets and undirected graphs.
Missing features:

InfoReader?,
aliased edges in undir edgesets

File:

• src/lemon/graph_reader.h (modified) (12 diffs)

src/lemon/graph_reader.h

@@ -57 +57 @@
   ///
   /// \code
-  /// reader.readNodeMap("x-coord", xCoordMap);
-  /// reader.readNodeMap("y-coord", yCoordMap);
+  /// reader.readNodeMap("coords", coords);
   ///
   /// reader.readNodeMap<QuotedStringReader>("label", labelMap);
@@ -115 +114 @@
     /// Construct a new GraphReader. It reads into the given graph
     /// and it use the given reader as the default skipper.
-    GraphReader(std::istream& _is, Graph& _graph, 
+    GraphReader(std::istream& _is, 
+                typename SmartParameter<Graph>::Type _graph, 
                 const DefaultSkipper& _skipper = DefaultSkipper()) 
-      : reader(new LemonReader(_is)), own_reader(true), 
-        graph(_graph), skipper(_skipper),
-        nodeset_reader(*reader, graph, std::string(), skipper),
-        edgeset_reader(*reader, graph, nodeset_reader, std::string(), skipper),
+      : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
+        nodeset_reader(*reader, _graph, std::string(), skipper),
+        edgeset_reader(*reader, _graph, nodeset_reader, 
+                       std::string(), skipper),
         node_reader(*reader, nodeset_reader, std::string()),
         edge_reader(*reader, edgeset_reader, std::string()),
@@ -129 +129 @@
     /// Construct a new GraphReader. It reads into the given graph
     /// and it use the given reader as the default skipper.
-    GraphReader(const std::string& _filename, Graph& _graph, 
+    GraphReader(const std::string& _filename, 
+                typename SmartParameter<Graph>::Type _graph, 
                 const DefaultSkipper& _skipper = DefaultSkipper()) 
       : reader(new LemonReader(_filename)), own_reader(true), 
-        graph(_graph), skipper(_skipper),
-        nodeset_reader(*reader, graph, std::string(), skipper),
-        edgeset_reader(*reader, graph, nodeset_reader, std::string(), skipper),
+        skipper(_skipper),
+        nodeset_reader(*reader, _graph, std::string(), skipper),
+        edgeset_reader(*reader, _graph, nodeset_reader, 
+                       std::string(), skipper),
         node_reader(*reader, nodeset_reader, std::string()),
         edge_reader(*reader, edgeset_reader, std::string()),
@@ -143 +145 @@
     /// Construct a new GraphReader. It reads into the given graph
     /// and it use the given reader as the default skipper.
-    GraphReader(LemonReader& _reader, Graph& _graph, 
+    GraphReader(LemonReader& _reader, 
+                typename SmartParameter<Graph>::Type _graph, 
                 const DefaultSkipper& _skipper = DefaultSkipper()) 
-      : reader(_reader), own_reader(false), 
-        graph(_graph), skipper(_skipper),
-        nodeset_reader(*reader, graph, std::string(), skipper),
-        edgeset_reader(*reader, graph, nodeset_reader, std::string(), skipper),
+      : reader(_reader), own_reader(false), skipper(_skipper),
+        nodeset_reader(*reader, _graph, std::string(), skipper),
+        edgeset_reader(*reader, _graph, nodeset_reader, 
+                       std::string(), skipper),
         node_reader(*reader, nodeset_reader, std::string()),
         edge_reader(*reader, edgeset_reader, std::string()),
@@ -166 +169 @@
     template <typename Map>
     GraphReader& readNodeMap(std::string name, Map& map) {
-      nodeset_reader.readMap(name, map);
+      nodeset_reader.readNodeMap(name, map);
+      return *this;
+    }
+
+    template <typename Map>
+    GraphReader& readNodeMap(std::string name, const Map& map) {
+      nodeset_reader.readNodeMap(name, map);
       return *this;
     }
@@ -176 +185 @@
     GraphReader& readNodeMap(std::string name, Map& map, 
                              const Reader& reader = Reader()) {
-      nodeset_reader.readMap(name, map, reader);
+      nodeset_reader.readNodeMap(name, map, reader);
+      return *this;
+    }
+
+    template <typename Reader, typename Map>
+    GraphReader& readNodeMap(std::string name, const Map& map, 
+                             const Reader& reader = Reader()) {
+      nodeset_reader.readNodeMap(name, map, reader);
       return *this;
     }
@@ -186 +202 @@
     GraphReader& skipNodeMap(std::string name, 
                              const Reader& reader = Reader()) {
-      nodeset_reader.skipMap(name, reader);
+      nodeset_reader.skipNodeMap(name, reader);
       return *this;
     }
@@ -195 +211 @@
     template <typename Map>
     GraphReader& readEdgeMap(std::string name, Map& map) { 
-      edgeset_reader.readMap(name, map);
+      edgeset_reader.readEdgeMap(name, map);
+      return *this;
+    }
+
+    template <typename Map>
+    GraphReader& readEdgeMap(std::string name, const Map& map) { 
+      edgeset_reader.readEdgeMap(name, map);
       return *this;
     }
@@ -206 +228 @@
     GraphReader& readEdgeMap(std::string name, Map& map,
                              const Reader& reader = Reader()) {
-      edgeset_reader.readMap(name, map, reader);
+      edgeset_reader.readEdgeMap(name, map, reader);
+      return *this;
+    }
+
+    template <typename Reader, typename Map>
+    GraphReader& readEdgeMap(std::string name, const Map& map,
+                             const Reader& reader = Reader()) {
+      edgeset_reader.readEdgeMap(name, map, reader);
       return *this;
     }
@@ -214 +243 @@
     /// Add a new edge map skipper command for the reader.
     template <typename Reader>
-    GraphReader& skipEdgeMap(std::string name,
+    GraphReader& skipEdgeMap(std::string name, 
                              const Reader& reader = Reader()) {
-
-      edgeset_reader.skipMap(name, reader);
+      edgeset_reader.skipEdgeMap(name, reader);
       return *this;
     }
@@ -276 +304 @@
     LemonReader* reader;
     bool own_reader;
-
-    Graph& graph;
 
     DefaultSkipper skipper;
@@ -369 +395 @@
   }
 
+  /// \brief The undir graph reader class.
+  ///
+  /// The given file format may contain several maps and labeled nodes or 
+  /// edges.
+  ///
+  /// If you read a graph you need not read all the maps and items just those
+  /// that you need. The interface of the \c GraphReader is very similar to
+  /// the GraphWriter but the reading method does not depend on the order the
+  /// given commands.
+  ///
+  /// The reader object suppose that each not readed value does not contain 
+  /// whitespaces, therefore it has some extra possibilities to control how
+  /// it should skip the values when the string representation contains spaces.
+  ///
+  /// \code
+  /// UndirGraphReader<UndirListGraph> reader(std::cin, graph);
+  /// \endcode
+  ///
+  /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
+  /// If there is a map that you do not want to read from the file and there is
+  /// whitespace in the string represenation of the values then you should
+  /// call the \c skipNodeMap() template member function with proper 
+  /// parameters.
+  ///
+  /// \code
+  /// reader.readNodeMap("coords", coords);
+  ///
+  /// reader.readNodeMap<QuotedStringReader>("label", labelMap);
+  /// reader.skipNodeMap<QuotedStringReader>("description");
+  ///
+  /// reader.readNodeMap("color", colorMap);
+  /// \endcode
+  ///
+  /// With the \c readUndirEdgeMap() member function you can give an 
+  /// undir edge map reading command similar to the NodeMaps. 
+  ///
+  /// \code
+  /// reader.readUndirEdgeMap("capacity", capacityMap);
+  /// \endcode
+  ///
+  /// The reading of the directed edge maps is just a syntactical sugar.
+  /// It reads two undirected edgemaps into a directed edge map. The 
+  /// undirected edge maps' name should be start with the \c '+' and the
+  /// \c '-' character and the same.
+  ///
+  /// \code
+  /// reader.readEdgeMap("flow", flowMap);
+  /// \endcode 
+  ///
+  /// With \c readNode() and \c readUndirEdge() functions you can read 
+  /// labeled Nodes and UndirEdges.
+  ///
+  /// \code
+  /// reader.readNode("source", sourceNode);
+  /// reader.readNode("target", targetNode);
+  ///
+  /// reader.readUndirEdge("observed", undirEdge);
+  /// \endcode
+  ///
+  /// With the \c readAttribute() functions you can read an attribute
+  /// in a variable. You can specify the reader for the attribute as
+  /// the nodemaps.
+  ///
+  /// After you give all read commands you must call the \c run() member
+  /// function, which execute all the commands.
+  ///
+  /// \code
+  /// reader.run();
+  /// \endcode
+  ///
+  /// \see GraphReader
+  /// \see DefaultReaderTraits
+  /// \see \ref UndirGraphWriter
+  /// \see \ref graph-io-page
+  ///
+  /// \author Balazs Dezso
+  template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 
+  class UndirGraphReader {
+  public:
+    
+    typedef _Graph Graph;
+    typedef typename Graph::Node Node;
+    typedef typename Graph::Edge Edge;
+    typedef typename Graph::UndirEdge UndirEdge;
+
+    typedef _ReaderTraits ReaderTraits;
+    typedef typename ReaderTraits::Skipper DefaultSkipper;
+
+    /// \brief Construct a new UndirGraphReader.
+    ///
+    /// Construct a new UndirGraphReader. It reads into the given graph
+    /// and it use the given reader as the default skipper.
+    UndirGraphReader(std::istream& _is, Graph& _graph, 
+                     const DefaultSkipper& _skipper = DefaultSkipper()) 
+      : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
+        nodeset_reader(*reader, _graph, std::string(), skipper),
+        undir_edgeset_reader(*reader, _graph, nodeset_reader, 
+                             std::string(), skipper),
+        node_reader(*reader, nodeset_reader, std::string()),
+        undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+        attribute_reader(*reader, std::string()) {}
+
+    /// \brief Construct a new UndirGraphReader.
+    ///
+    /// Construct a new UndirGraphReader. It reads into the given graph
+    /// and it use the given reader as the default skipper.
+    UndirGraphReader(const std::string& _filename, Graph& _graph, 
+                     const DefaultSkipper& _skipper = DefaultSkipper()) 
+      : reader(new LemonReader(_filename)), own_reader(true), 
+        skipper(_skipper),
+        nodeset_reader(*reader, _graph, std::string(), skipper),
+        undir_edgeset_reader(*reader, _graph, nodeset_reader, 
+                             std::string(), skipper),
+        node_reader(*reader, nodeset_reader, std::string()),
+        undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+        attribute_reader(*reader, std::string()) {}
+
+    /// \brief Construct a new UndirGraphReader.
+    ///
+    /// Construct a new UndirGraphReader. It reads into the given graph
+    /// and it use the given reader as the default skipper.
+    UndirGraphReader(LemonReader& _reader, Graph& _graph, 
+                     const DefaultSkipper& _skipper = DefaultSkipper()) 
+      : reader(_reader), own_reader(false), skipper(_skipper),
+        nodeset_reader(*reader, _graph, std::string(), skipper),
+        undir_edgeset_reader(*reader, _graph, nodeset_reader, 
+                             std::string(), skipper),
+        node_reader(*reader, nodeset_reader, std::string()),
+        undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+        attribute_reader(*reader, std::string()) {}
+
+    /// \brief Destruct the graph reader.
+    ///
+    /// Destruct the graph reader.
+    ~UndirGraphReader() {
+      if (own_reader) 
+        delete reader;
+    }
+
+    /// \brief Add a new node map reader command for the reader.
+    ///
+    /// Add a new node map reader command for the reader.
+    template <typename Map>
+    UndirGraphReader& readNodeMap(std::string name, Map& map) {
+      nodeset_reader.readNodeMap(name, map);
+      return *this;
+    }
+
+    template <typename Map>
+    UndirGraphReader& readNodeMap(std::string name, const Map& map) {
+      nodeset_reader.readNodeMap(name, map);
+      return *this;
+    }
+
+    /// \brief Add a new node map reader command for the reader.
+    ///
+    /// Add a new node map reader command for the reader.
+    template <typename Reader, typename Map>
+    UndirGraphReader& readNodeMap(std::string name, Map& map, 
+                                  const Reader& reader = Reader()) {
+      nodeset_reader.readNodeMap(name, map, reader);
+      return *this;
+    }
+
+    template <typename Reader, typename Map>
+    UndirGraphReader& readNodeMap(std::string name, const Map& map, 
+                                  const Reader& reader = Reader()) {
+      nodeset_reader.readNodeMap(name, map, reader);
+      return *this;
+    }
+
+    /// \brief Add a new node map skipper command for the reader.
+    ///
+    /// Add a new node map skipper command for the reader.
+    template <typename Reader>
+    UndirGraphReader& skipNodeMap(std::string name, 
+                             const Reader& reader = Reader()) {
+      nodeset_reader.skipNodeMap(name, reader);
+      return *this;
+    }
+
+    /// \brief Add a new undirected edge map reader command for the reader.
+    ///
+    /// Add a new undirected edge map reader command for the reader.
+    template <typename Map>
+    UndirGraphReader& readUndirEdgeMap(std::string name, Map& map) { 
+      undir_edgeset_reader.readUndirEdgeMap(name, map);
+      return *this;
+    }
+
+    template <typename Map>
+    UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map) { 
+      undir_edgeset_reader.readUndirEdgeMap(name, map);
+      return *this;
+    }
+
+
+    /// \brief Add a new undirected edge map reader command for the reader.
+    ///
+    /// Add a new undirected edge map reader command for the reader.
+    template <typename Reader, typename Map>
+    UndirGraphReader& readUndirEdgeMap(std::string name, Map& map,
+                                       const Reader& reader = Reader()) {
+      undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
+      return *this;
+    }
+
+    template <typename Reader, typename Map>
+    UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map,
+                                       const Reader& reader = Reader()) {
+      undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
+      return *this;
+    }
+
+    /// \brief Add a new undirected edge map skipper command for the reader.
+    ///
+    /// Add a new undirected edge map skipper command for the reader.
+    template <typename Reader>
+    UndirGraphReader& skipUndirEdgeMap(std::string name,
+                                       const Reader& reader = Reader()) {
+      undir_edgeset_reader.skipUndirMap(name, reader);
+      return *this;
+    }
+
+
+    /// \brief Add a new edge map reader command for the reader.
+    ///
+    /// Add a new edge map reader command for the reader.
+    template <typename Map>
+    UndirGraphReader& readEdgeMap(std::string name, Map& map) { 
+      undir_edgeset_reader.readEdgeMap(name, map);
+      return *this;
+    }
+
+    template <typename Map>
+    UndirGraphReader& readEdgeMap(std::string name, const Map& map) { 
+      undir_edgeset_reader.readEdgeMap(name, map);
+      return *this;
+    }
+
+
+    /// \brief Add a new edge map reader command for the reader.
+    ///
+    /// Add a new edge map reader command for the reader.
+    template <typename Reader, typename Map>
+    UndirGraphReader& readEdgeMap(std::string name, Map& map,
+                                       const Reader& reader = Reader()) {
+      undir_edgeset_reader.readEdgeMap(name, map, reader);
+      return *this;
+    }
+
+    template <typename Reader, typename Map>
+    UndirGraphReader& readEdgeMap(std::string name, const Map& map,
+                                       const Reader& reader = Reader()) {
+      undir_edgeset_reader.readEdgeMap(name, map, reader);
+      return *this;
+    }
+
+    /// \brief Add a new edge map skipper command for the reader.
+    ///
+    /// Add a new edge map skipper command for the reader.
+    template <typename Reader>
+    UndirGraphReader& skipEdgeMap(std::string name,
+                                       const Reader& reader = Reader()) {
+      undir_edgeset_reader.skipEdgeMap(name, reader);
+      return *this;
+    }
+
+    /// \brief Add a new labeled node reader for the reader.
+    ///
+    /// Add a new labeled node reader for the reader.
+    UndirGraphReader& readNode(std::string name, Node& node) {
+      node_reader.readNode(name, node);
+      return *this;
+    }
+
+    /// \brief Add a new labeled edge reader for the reader.
+    ///
+    /// Add a new labeled edge reader for the reader.
+    UndirGraphReader& readUndirEdge(std::string name, UndirEdge& edge) {
+      undir_edge_reader.readUndirEdge(name, edge);
+    }
+
+    /// \brief Add a new attribute reader command.
+    ///
+    ///  Add a new attribute reader command.
+    template <typename Value>
+    UndirGraphReader& readAttribute(std::string name, Value& value) {
+      attribute_reader.readAttribute(name, value);
+      return *this;
+    }
+    
+    /// \brief Add a new attribute reader command.
+    ///
+    ///  Add a new attribute reader command.
+    template <typename Reader, typename Value>
+    UndirGraphReader& readAttribute(std::string name, Value& value, 
+                               const Reader& reader) {
+      attribute_reader.readAttribute<Reader>(name, value, reader);
+      return *this;
+    }
+
+    /// \brief Conversion operator to LemonReader.
+    ///
+    /// Conversion operator to LemonReader. It make possible
+    /// to access the encapsulated \e LemonReader, this way
+    /// you can attach to this reader new instances of 
+    /// \e LemonReader::SectionReader.
+    operator LemonReader&() {
+      return *reader;
+    }
+
+    /// \brief Executes the reader commands.
+    ///
+    /// Executes the reader commands.
+    void run() {
+      reader->run();
+    }
+
+  private:
+
+    LemonReader* reader;
+    bool own_reader;
+
+    DefaultSkipper skipper;
+
+    NodeSetReader<Graph, ReaderTraits> nodeset_reader;
+    UndirEdgeSetReader<Graph, ReaderTraits> undir_edgeset_reader;
+
+    NodeReader<Graph> node_reader;
+    UndirEdgeReader<Graph> undir_edge_reader;
+    
+    AttributeReader<ReaderTraits> attribute_reader;
+  };
+
+  /// \brief Read an undir graph from the input.
+  ///
+  /// Read an undir graph from the input.
+  /// \param is The input stream.
+  /// \param g The graph.
+  /// \param capacity The capacity map.
+  template<typename Graph, typename CapacityMap>
+  void readUndirGraph(std::istream& is, Graph &g, CapacityMap& capacity) {
+    UndirGraphReader<Graph> reader(is, g);
+    reader.readUndirEdgeMap("capacity", capacity);
+    reader.run();
+  }
+
+  /// \brief Read an undir graph from the input.
+  ///
+  /// Read an undir graph from the input.
+  /// \param is The input stream.
+  /// \param g The graph.
+  template<typename Graph>
+  void readUndirGraph(std::istream& is, Graph &g) {
+    UndirGraphReader<Graph> reader(is, g);
+    reader.run();
+  }
+
   /// @}
 }