lemon-0.x: comparison src/lemon/graph

equal deleted inserted replaced

-:358e3ee5c5f1
+:e5912587656b
 #include <lemon/error.h>
 namespace lemon {
+/// \addtogroup io_group
+/// @{
 /// \brief Standard ReaderTraits for the GraphReader class.
 ///
 /// Standard ReaderTraits for the GraphReader class.
 /// It defines standard reading method for all type of value.
+/// \author Balazs Dezso
 struct DefaultReaderTraits {
 /// \brief Template class for reading an value.
 ///
 /// Template class for reading an value.
+/// \author Balazs Dezso
 template <typename _Value>
 struct Reader {
 /// The value type.
 typedef _Value Value;
 /// \brief Reads a value from the given stream.
 	if (!(is >> value))
 	  throw DataFormatError("Default reader format exception");
 }
 };
+/// \brief Returns wheter this name is an ID map name.
+///
+/// Returns wheter this name is an ID map name.
+static bool idMapName(const std::string& name) {
+return name == "id";
+}
 /// The reader class for the not needed maps.
 typedef Reader<std::string> DefaultReader;
 };
 /// \brief Reader class for quoted strings.
 ///
 /// Reader class for quoted strings. It can process the escape
 /// sequences in the string.
+/// \author Balazs Dezso
 class QuotedStringReader {
 public:
 typedef std::string Value;
 /// \brief Constructor for the reader.
 bool escaped;
 };
 /// \brief The graph reader class.
 ///
-/// \ingroup io_group
+///
-/// The reader class for the graph input.
+/// 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
+/// GraphReader<ListGraph> reader(std::cin, graph);
+/// \endcode
+///
+/// The \c addNodeMap() 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.addNodeMap("x-coord", xCoordMap);
+/// reader.addNodeMap("y-coord", yCoordMap);
+///
+/// reader.addNodeMap<QuotedStringReader>("label", labelMap);
+/// reader.skipNodeMap<QuotedStringReader>("description");
+///
+/// reader.addNodeMap("color", colorMap);
+/// \endcode
+///
+/// With the \c addEdgeMap() member function you can give an edge map
+/// reading command similar to the NodeMaps.
+///
+/// \code
+/// reader.addEdgeMap("weight", weightMap);
+/// reader.addEdgeMap("label", labelMap);
+/// \endcode
+///
+/// With \c addNode() and \c addEdge() functions you can read labeled Nodes
+/// and Edges.
+///
+/// \code
+/// reader.addNode("source", sourceNode);
+/// reader.addNode("target", targetNode);
+///
+/// reader.addEdge("observed", edge);
+/// \endcode
+///
+/// After you give all read commands you must call the \c run() member
+/// function, which execute all the commands.
+///
+/// \code
+/// reader.run();
+/// \endcode
+///
 /// \see DefaultReaderTraits
 /// \see QuotedStringReader
 /// \see \ref GraphWriter
 /// \see \ref graph-io-page
+/// \author Balazs Dezso
 template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits>
 class GraphReader {
 public:
 typedef _Graph Graph;
 /// \brief Destruct the graph reader.
 ///
 /// Destruct the graph reader.
 ~GraphReader() {
 for (typename NodeMapReaders::iterator it = node_map_readers.begin();
 	   it != node_map_readers.end(); ++it) {
 	delete it->second;
 }
 {
 	std::string line = readNotEmptyLine(is, line_num);
 	std::string id;
 	std::istringstream ls(line);
 	while (ls >> id) {
-	  if (id[0] == '#') break;
 	  typename NodeMapReaders::iterator it = node_map_readers.find(id);
 	  if (it != node_map_readers.end()) {
 	    index.push_back(it->second);
 	    node_map_readers.erase(it);
 	  } else {
 	    index.push_back(&nodeSkipper);
 	  }
-	}
+	  if (ReaderTraits::idMapName(id) && nodeInverter.get() == 0) {
-}
+	    nodeInverter.reset(index.back()->getInverter());
+	    index.back() = nodeInverter.get();
-if (index.size() == 0) {
+	  }
-	throw DataFormatError("Cannot find node id map");
+	}
 }
-nodeInverter =
+//       if (index.size() == 0) {
-	std::auto_ptr<InverterBase<Node> >(index[0]->getInverter());
+// 	throw DataFormatError("Cannot find node id map");
+//       }
+//       nodeInverter =
+// 	std::auto_ptr<InverterBase<Node> >(index[0]->getInverter());
 std::string line;
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	Node node = graph.addNode();
 	std::istringstream ls(line);
-	nodeInverter->read(ls, node);
+	for (int i = 0; i < (int)index.size(); ++i) {
-	for (int i = 1; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, node);
 	}
 }
 return line;
 }
 {
 	std::string line = readNotEmptyLine(is, line_num);
 	std::string id;
 	std::istringstream ls(line);
 	while (ls >> id) {
-	  if (id[0] == '#') break;
 	  typename EdgeMapReaders::iterator it = edge_map_readers.find(id);
 	  if (it != edge_map_readers.end()) {
 	    index.push_back(it->second);
 	    edge_map_readers.erase(it);
 	  } else {
 	    index.push_back(&edgeSkipper);
 	  }
-	}
+	  if (ReaderTraits::idMapName(id) && edgeInverter.get() == 0) {
-}
+	    edgeInverter.reset(index.back()->getInverter());
+	    index.back() = edgeInverter.get();
-if (index.size() == 0) {
+	  }
-	throw DataFormatError("Cannot find edge id map");
+	}
 }
-edgeInverter =
+if (nodeInverter.get() == 0) {
-	std::auto_ptr<InverterBase<Edge> >(index[0]->getInverter());
+	throw DataFormatError("Cannot find node id map");
+}
+//       if (index.size() == 0) {
+// 	throw DataFormatError("Cannot find edge id map");
+//       }
+//       edgeInverter =
+// 	std::auto_ptr<InverterBase<Edge> >(index[0]->getInverter());
 std::string line;
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	std::istringstream ls(line);
 	Node source = nodeInverter->read(ls);
 	Node target = nodeInverter->read(ls);
 	Edge edge = graph.addEdge(source, target);
-	edgeInverter->read(ls, edge);
+	for (int i = 0; i < (int)index.size(); ++i) {
-	for (int i = 1; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 return line;
 }
 std::string readNodes(int& line_num,
 			  std::auto_ptr<InverterBase<Node> >& nodeInverter) {
 std::string line;
+if (nodeInverter.get() == 0) {
+	throw DataFormatError("Cannot find node id map");
+}
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	std::istringstream ls(line);
 	std::string name;
 	ls >> name;
 	typename NodeReaders::iterator it = node_readers.find(name);
 }
 std::string readEdges(int& line_num,
 			  std::auto_ptr<InverterBase<Edge> >& edgeInverter) {
 std::string line;
+if (edgeInverter.get() == 0) {
+	throw DataFormatError("Cannot find edge id map");
+}
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	std::istringstream ls(line);
 	std::string name;
 	ls >> name;
 	typename EdgeReaders::iterator it = edge_readers.find(name);
 }
 std::string readNotEmptyLine(std::istream& is, int& line_num) {
 std::string line;
 while (++line_num, getline(is, line)) {
-	int vi = line.find_first_not_of(" \t");
+	int vi = line.find('#');
-	if (vi != (int)std::string::npos && line[vi] != '#') {
+	if (vi != (int)::std::string::npos) {
+	  line = line.substr(0, vi);
+	}
+	vi = line.find_first_not_of(" \t");
+	if (vi != (int)std::string::npos) {
+	  std::cerr << "Line: " << line.substr(vi) << std::endl;
 	  return line.substr(vi);
 	}
 }
 throw DataFormatError("End of stream error");
 }
-// Inverters store and give back the Item from the id,
-// and may put the ids into a map.
 template <typename _Item>
-class InverterBase {
+class ReaderBase;
+template <typename _Item>
+class InverterBase : public ReaderBase<_Item> {
 public:
 typedef _Item Item;
 virtual void read(std::istream&, const Item&) = 0;
 virtual Item read(std::istream&) = 0;
+virtual InverterBase<_Item>* getInverter() {
+	return this;
+}
 };
 template <typename _Item, typename _Map, typename _Reader>
 class MapReaderInverter : public InverterBase<_Item> {
 public:
 SkipReader<Node, DefaultReader> nodeSkipper;
 SkipReader<Edge, DefaultReader> edgeSkipper;
 };
-/// Ready to use reader function.
+/// \brief Read a graph from the input.
+///
+/// Read a graph from the input.
+/// \param is The input stream.
+/// \param g The graph.
+/// \param capacity The capacity map.
+/// \param s The source node.
+/// \param t The target node.
+/// \param cost The cost map.
 template<typename Graph, typename CapacityMap, typename CostMap>
 void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
 		  typename Graph::Node &s, typename Graph::Node &t,
 		  CostMap& cost) {
 GraphReader<Graph> reader(is, g);
 reader.addNode("source", s);
 reader.addNode("target", t);
 reader.run();
 }
+/// \brief Read a graph from the input.
+///
+/// Read a graph from the input.
+/// \param is The input stream.
+/// \param g The graph.
+/// \param capacity The capacity map.
+/// \param s The source node.
+/// \param t The target node.
 template<typename Graph, typename CapacityMap>
 void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
 		  typename Graph::Node &s, typename Graph::Node &t) {
 GraphReader<Graph> reader(is, g);
 reader.addEdgeMap("capacity", capacity);
 reader.addNode("source", s);
 reader.addNode("target", t);
 reader.run();
 }
+/// \brief Read a graph from the input.
+///
+/// Read a graph from the input.
+/// \param is The input stream.
+/// \param g The graph.
+/// \param capacity The capacity map.
+/// \param s The source node.
 template<typename Graph, typename CapacityMap>
 void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
 		  typename Graph::Node &s) {
 GraphReader<Graph> reader(is, g);
 reader.addEdgeMap("capacity", capacity);
 reader.addNode("source", s);
 reader.run();
 }
+/// \brief Read a graph from the input.
+///
+/// Read a graph from the input.
+/// \param is The input stream.
+/// \param g The graph.
+/// \param capacity The capacity map.
 template<typename Graph, typename CapacityMap>
 void readGraph(std::istream& is, Graph &g, CapacityMap& capacity) {
 GraphReader<Graph> reader(is, g);
 reader.addEdgeMap("capacity", capacity);
 reader.run();
 }
+/// \brief Read a graph from the input.
+///
+/// Read a graph from the input.
+/// \param is The input stream.
+/// \param g The graph.
 template<typename Graph>
 void readGraph(std::istream& is, Graph &g) {
 GraphReader<Graph> reader(is, g);
 reader.run();
 }
+/// @}
 }
 #endif

changeset 1333	2640cf6547ff
parent 1311	b810a07248a0
child 1341	bda966891ea0