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

equal deleted inserted replaced

-:411524653e75
+:c8bbf2f05176
 #include <lemon/error.h>
 namespace lemon {
+/// \addtogroup io_group
+/// @{
 /// \brief Standard WriterTraits for the GraphWriter class.
 ///
 /// Standard WriterTraits for the GraphWriter class.
 /// It defines standard writing method for all type of value.
+/// \author Balazs Dezso
 struct DefaultWriterTraits {
 /// \brief Template class for writing an value.
 ///
 /// Template class for writing an value.
+/// \author Balazs Dezso
 template <typename _Value>
 struct Writer {
 /// The value type.
 typedef _Value Value;
 void write(std::ostream& os, const Value& value) {
 	os << value << '\t';
 }
 };
+/// \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";
+}
 };
 /// \brief Writer class for quoted strings.
 ///
 /// Writer class for quoted strings. It can process the escape
 /// sequences in the string.
+/// \author Balazs Dezso
 class QuotedStringWriter {
 public:
 typedef std::string Value;
 /// \brief Constructor for the writer.
 };
 /// \brief The graph writer class.
 ///
-///\ingroup io_group
+/// The \c GraphWriter class provides the graph output. To write a graph
-/// The writer class for the graph output.
+/// you should first give writing commands for the writer. You can declare
+/// write command as \c NodeMap or \c EdgeMap writing and labeled Node and
+/// Edge writing.
+///
+/// \code
+/// GraphWriter<ListGraph> writer(std::cout, graph);
+/// \endcode
+///
+/// The \c addNodeMap() function declares a \c NodeMap writing command in the
+/// \c GraphWriter. You should give as parameter the name of the map and the
+/// map object. The NodeMap writing command with name "id" should write a
+/// unique map because it is regarded as ID map.
+///
+/// \code
+/// IdMap<ListGraph, Node> nodeIdMap;
+/// writer.addNodeMap("id", nodeIdMap);
+///
+/// writer.addNodeMap("x-coord", xCoordMap);
+/// writer.addNodeMap("y-coord", yCoordMap);
+/// writer.addNodeMap("color", colorMap);
+/// \endcode
+///
+/// With the \c addEdgeMap() member function you can give an edge map
+/// writing command similar to the NodeMaps.
+///
+/// \code
+/// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
+///   edgeDescMap(graph);
+/// writer.addEdgeMap("descriptor", edgeDescMap);
+///
+/// writer.addEdgeMap("weight", weightMap);
+/// writer.addEdgeMap("label", labelMap);
+/// \endcode
+///
+/// With \c addNode() and \c addEdge() functions you can point out Nodes and
+/// Edges in the graph. By example, you can write out the source and target
+/// of the graph.
+///
+/// \code
+/// writer.addNode("source", sourceNode);
+/// writer.addNode("target", targetNode);
+///
+/// writer.addEdge("observed", edge);
+/// \endcode
+///
+/// After you give all write commands you must call the \c run() member
+/// function, which execute all the writer commands.
+///
+/// \code
+/// writer.run();
+/// \endcode
+///
 /// \see DefaultWriterTraits
 /// \see QuotedStringWriter
+/// \see IdMap
+/// \see DescriptorMap
 /// \see \ref GraphReader
 /// \see \ref graph-io-page
+/// \author Balazs Dezso
 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
 class GraphWriter {
 public:
 typedef _Graph Graph;
 /// \brief Executes the writer commands.
 ///
 /// Executes the writer commands.
 void run() {
-writeNodeSet();
+WriterBase<Node>* nodeWriter = 0;
-writeEdgeSet();
+WriterBase<Edge>* edgeWriter = 0;
-writeNodes();
+writeNodeSet(nodeWriter);
-writeEdges();
+writeEdgeSet(nodeWriter, edgeWriter);
+writeNodes(nodeWriter);
+writeEdges(edgeWriter);
 os << "@end" << std::endl;
 }
 private:
-void writeNodeSet() {
-if (node_map_writers.size() == 0) return;
-os << "@nodeset" << std::endl;
-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 < (int)node_map_writers.size(); ++i) {
-	  node_map_writers[i].second->write(os, it);
-	}
-	os << std::endl;
-}
-}
-void writeEdgeSet() {
-if (edge_map_writers.size() == 0) return;
-if (node_map_writers.size() == 0) {
-	//	ErrorMessage message;
-	//	message << "Missing node id map";
-	//	throw IOLogicError(message);
-}
-os << "@edgeset" << std::endl;
-os << "\t\t";
-for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
-	os << edge_map_writers[i].first << '\t';
-}
-os << std::endl;
-for (EdgeIt it(graph); it != INVALID; ++it) {
-	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 < (int)edge_map_writers.size(); ++i) {
-	  edge_map_writers[i].second->write(os, it);
-	}
-	os << std::endl;
-}
-}
-void writeNodes() {
-if (node_writers.size() == 0) return;
-if (node_map_writers.size() == 0) {
-	//	throw Exception() << "Missing node id map";
-}
-os << "@nodes" << std::endl;
-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);
-	os << std::endl;
-}
-}
-void writeEdges() {
-if (edge_writers.size() == 0) return;
-if (edge_map_writers.size() == 0) {
-	//	throw Exception() << "Missing edge id map";
-}
-os << "@edges" << std::endl;
-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);
-	os << std::endl;
-}
-}
-// Writers
 template <class _Item>
 class WriterBase {
 public:
 typedef _Item Item;
 	writer.write(os, map[item]);
 }
 };
+void writeNodeSet(WriterBase<Node>* & nodeWriter) {
+if (node_map_writers.size() == 0) return;
+os << "@nodeset" << std::endl;
+for (int i = 0; i < (int)node_map_writers.size(); ++i) {
+	const std::string& id = node_map_writers[i].first;
+	os << id << '\t';
+	if (WriterTraits::idMapName(id) && nodeWriter == 0) {
+	  nodeWriter = node_map_writers[i].second;
+	}
+}
+os << std::endl;
+for (NodeIt it(graph); it != INVALID; ++it) {
+	for (int i = 0; i < (int)node_map_writers.size(); ++i) {
+	  node_map_writers[i].second->write(os, it);
+	}
+	os << std::endl;
+}
+}
+void writeEdgeSet(WriterBase<Node>* nodeWriter,
+		      WriterBase<Edge>* & edgeWriter) {
+if (nodeWriter == 0) {
+	throw DataFormatError("Cannot find node id map");
+}
+os << "@edgeset" << std::endl;
+os << "\t\t";
+for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
+	const std::string& id = edge_map_writers[i].first;
+	os << id << '\t';
+	if (WriterTraits::idMapName(id) && edgeWriter == 0) {
+	  edgeWriter = edge_map_writers[i].second;
+	}
+}
+os << std::endl;
+for (EdgeIt it(graph); it != INVALID; ++it) {
+	nodeWriter->write(os, graph.source(it));
+	nodeWriter->write(os, graph.target(it));
+	for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
+	  edge_map_writers[i].second->write(os, it);
+	}
+	os << std::endl;
+}
+}
+void writeNodes(WriterBase<Node>* nodeWriter) {
+if (nodeWriter == 0) {
+	throw DataFormatError("Cannot find node id map");
+}
+os << "@nodes" << std::endl;
+for (int i = 0; i < (int)node_writers.size(); ++i) {
+	os << node_writers[i].first << '\t';
+	nodeWriter->write(os, node_writers[i].second);
+	os << std::endl;
+}
+}
+void writeEdges(WriterBase<Edge>* edgeWriter) {
+if (edgeWriter == 0) {
+	throw DataFormatError("Cannot find node id map");
+}
+os << "@edges" << std::endl;
+for (int i = 0; i < (int)edge_writers.size(); ++i) {
+	os << edge_writers[i].first << '\t';
+edgeWriter->write(os, edge_writers[i].second);
+	os << std::endl;
+}
+}
 typedef std::vector< std::pair<std::string, WriterBase<Node>*> >
 NodeMapWriters;
 NodeMapWriters node_map_writers;
 std::ostream& os;
 const Graph& graph;
 };
-/// Ready to use writer function.
+/// \brief Write a graph to the output.
+///
+/// Write a graph to the output.
+/// \param os The output 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 writeGraph(std::ostream& os, const Graph &g,
 		  const CapacityMap& capacity, const typename Graph::Node &s,
 		  const typename Graph::Node &t, const CostMap& cost) {
 GraphWriter<Graph> reader(os, g);
 reader.addNode("source", s);
 reader.addNode("target", t);
 reader.run();
 }
-/// Ready to use writer function.
+/// \brief Write a graph to the output.
+///
+/// Write a graph to the output.
+/// \param os The output 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 writeGraph(std::ostream& os, const Graph &g,
 		  const CapacityMap& capacity, const typename Graph::Node &s,
 		  const typename Graph::Node &t) {
 GraphWriter<Graph> reader(os, g);
 reader.addNode("source", s);
 reader.addNode("target", t);
 reader.run();
 }
-/// Ready to use writer function.
+/// \brief Write a graph to the output.
+///
+/// Write a graph to the output.
+/// \param os The output stream.
+/// \param g The graph.
+/// \param capacity The capacity map.
+/// \param s The source node.
 template<typename Graph, typename CapacityMap>
 void writeGraph(std::ostream& os, const Graph &g,
 		  const CapacityMap& capacity, const typename Graph::Node &s) {
 GraphWriter<Graph> reader(os, g);
 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
 reader.addEdgeMap("id", edgeIdMap);
 reader.addEdgeMap("capacity", capacity);
 reader.addNode("source", s);
 reader.run();
 }
-/// Ready to use writer function.
+/// \brief Write a graph to the output.
+///
+/// Write a graph to the output.
+/// \param os The output stream.
+/// \param g The graph.
+/// \param capacity The capacity map.
 template<typename Graph, typename CapacityMap>
 void writeGraph(std::ostream& os, const Graph &g,
 		  const CapacityMap& capacity) {
 GraphWriter<Graph> reader(os, g);
 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
 IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
 reader.addEdgeMap("id", edgeIdMap);
 reader.addEdgeMap("capacity", capacity);
 reader.run();
 }
-/// Ready to use writer function.
+/// \brief Write a graph to the output.
+///
+/// Write a graph to the output.
+/// \param os The output stream.
+/// \param g The graph.
 template<typename Graph>
 void writeGraph(std::ostream& os, const Graph &g) {
 GraphWriter<Graph> reader(os, g);
 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
 reader.addNodeMap("id", nodeIdMap);
 IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
 reader.addEdgeMap("id", edgeIdMap);
 reader.run();
 }
+/// @}
 }
 #endif

changeset 1333	2640cf6547ff
parent 1311	b810a07248a0
child 1343	a81f9cfc9775