Better handling of inexact computation.
We do not use tolerance for excess, just for edges
3 * This file is a part of LEMON, a generic C++ optimization library
5 * Copyright (C) 2003-2006
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
21 ///\brief Lemon Graph Format writer.
24 #ifndef LEMON_GRAPH_WRITER_H
25 #define LEMON_GRAPH_WRITER_H
29 #include <lemon/error.h>
30 #include <lemon/lemon_writer.h>
34 /// \addtogroup lemon_io
37 /// \brief The graph writer class.
39 /// The \c GraphWriter class provides the graph output. Before you
40 /// read this documentation it might be useful to read the general
41 /// description of \ref graph-io-page "Graph Input-Output".
43 /// To write a graph you should first give writing commands to the
44 /// writer. You can declare write commands as \c NodeMap or \c
45 /// EdgeMap writing and labeled Node and Edge writing.
48 /// GraphWriter<ListGraph> writer(std::cout, graph);
51 /// The \c writeNodeMap() function declares a \c NodeMap writing
52 /// command in the \c GraphWriter. You should give as parameter the
53 /// name of the map and the map object. The NodeMap writing command
54 /// with name "label" should write a unique map because it is
55 /// regarded as label map (such a map is essential if the graph has
59 /// IdMap<ListGraph, Node> nodeLabelMap;
60 /// writer.writeNodeMap("label", nodeLabelMap);
62 /// writer.writeNodeMap("coords", coords);
63 /// writer.writeNodeMap("color", colorMap);
66 /// With the \c writeEdgeMap() member function you can give an edge map
67 /// writing command similar to the NodeMaps.
70 /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
71 /// edgeDescMap(graph);
72 /// writer.writeEdgeMap("descriptor", edgeDescMap);
74 /// writer.writeEdgeMap("weight", weightMap);
75 /// writer.writeEdgeMap("label", labelMap);
78 /// With \c writeNode() and \c writeEdge() functions you can
79 /// point out Nodes and Edges in the graph. For example, you can
80 /// write out the source and target of a maximum flow instance.
83 /// writer.writeNode("source", sourceNode);
84 /// writer.writeNode("target", targetNode);
86 /// writer.writeEdge("observed", edge);
89 /// After you give all write commands you must call the \c run() member
90 /// function, which executes all the writing commands.
96 /// \see DefaultWriterTraits
97 /// \see QuotedStringWriter
99 /// \see DescriptorMap
100 /// \see \ref GraphReader
101 /// \see \ref graph-io-page
102 /// \author Balazs Dezso
103 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
107 typedef _Graph Graph;
108 typedef typename Graph::Node Node;
109 typedef typename Graph::Edge Edge;
111 typedef _WriterTraits WriterTraits;
113 /// \brief Construct a new GraphWriter.
115 /// This function constructs a new GraphWriter to write the given graph
116 /// to the given stream.
117 GraphWriter(std::ostream& _os, const Graph& _graph)
118 : writer(new LemonWriter(_os)), own_writer(true),
119 nodeset_writer(*writer, _graph, std::string()),
120 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
121 node_writer(*writer, nodeset_writer, std::string()),
122 edge_writer(*writer, edgeset_writer, std::string()),
123 attribute_writer(*writer, std::string()) {}
125 /// \brief Construct a new GraphWriter.
127 /// This function constructs a new GraphWriter to write the given graph
128 /// to the given file.
129 GraphWriter(const std::string& _filename, const Graph& _graph)
130 : writer(new LemonWriter(_filename)), own_writer(true),
131 nodeset_writer(*writer, _graph, std::string()),
132 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
133 node_writer(*writer, nodeset_writer, std::string()),
134 edge_writer(*writer, edgeset_writer, std::string()),
135 attribute_writer(*writer, std::string()) {}
137 /// \brief Construct a new GraphWriter.
139 /// This function constructs a new GraphWriter to write the given graph
140 /// to the given LemonReader.
141 GraphWriter(LemonWriter& _writer, const Graph& _graph)
142 : writer(_writer), own_writer(false),
143 nodeset_writer(*writer, _graph, std::string()),
144 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
145 node_writer(*writer, nodeset_writer, std::string()),
146 edge_writer(*writer, edgeset_writer, std::string()),
147 attribute_writer(*writer, std::string()) {}
149 /// \brief Destruct the graph writer.
151 /// This function destructs the graph writer.
157 /// \brief Issue a new node map writing command for the writer.
159 /// This function issues a new <i> node map writing command</i> to the writer.
160 template <typename Map>
161 GraphWriter& writeNodeMap(std::string name, const Map& map) {
162 nodeset_writer.writeNodeMap(name, map);
167 /// \brief Issue a new node map writing command for the writer.
169 /// This function issues a new <i> node map writing command</i> to the writer.
170 template <typename Writer, typename Map>
171 GraphWriter& writeNodeMap(std::string name, const Map& map,
172 const Writer& writer = Writer()) {
173 nodeset_writer.writeNodeMap(name, map, writer);
178 /// \brief Issue a new edge map writing command for the writer.
180 /// This function issues a new <i> edge map writing command</i> to the writer.
181 template <typename Map>
182 GraphWriter& writeEdgeMap(std::string name, const Map& map) {
183 edgeset_writer.writeEdgeMap(name, map);
188 /// \brief Issue a new edge map writing command for the writer.
190 /// This function issues a new <i> edge map writing command</i> to the writer.
191 template <typename Writer, typename Map>
192 GraphWriter& writeEdgeMap(std::string name, const Map& map,
193 const Writer& writer = Writer()) {
194 edgeset_writer.writeEdgeMap(name, map, writer);
198 /// \brief Issue a new labeled node writing command to the writer.
200 /// This function issues a new <i> labeled node writing command</i>
202 GraphWriter& writeNode(std::string name, const Node& node) {
203 node_writer.writeNode(name, node);
207 /// \brief Issue a new labeled edge writing command to the writer.
209 /// This function issues a new <i> labeled edge writing command</i>
211 GraphWriter& writeEdge(std::string name, const Edge& edge) {
212 edge_writer.writeEdge(name, edge);
215 /// \brief Issue a new attribute writing command.
217 /// This function issues a new <i> attribute writing command</i>
219 template <typename Value>
220 GraphWriter& writeAttribute(std::string name, const Value& value) {
221 attribute_writer.writeAttribute(name, value);
225 /// \brief Issue a new attribute writing command.
227 /// This function issues a new <i> attribute writing command</i>
229 template <typename Writer, typename Value>
230 GraphWriter& writeAttribute(std::string name, const Value& value,
231 const Writer& writer) {
232 attribute_writer.writeAttribute<Writer>(name, value, writer);
236 /// \brief Conversion operator to LemonWriter.
238 /// Conversion operator to LemonWriter. It makes possible
239 /// to access the encapsulated \e LemonWriter, this way
240 /// you can attach to this writer new instances of
241 /// \e LemonWriter::SectionWriter. For more details see
242 /// the \ref rwbackground "Background of Reading and Writing".
243 operator LemonWriter&() {
247 /// \brief Executes the writing commands.
249 /// Executes the writing commands.
254 /// \brief Write the label of the given node.
256 /// It writes the label of the given node. If there was written an "label"
257 /// named node map then it will write the map value belonging to the node.
258 void writeLabel(std::ostream& os, const Node& item) const {
259 nodeset_writer.writeLabel(os, item);
262 /// \brief Write the label of the given edge.
264 /// It writes the label of the given edge. If there was written an "label"
265 /// named edge map then it will write the map value belonging to the edge.
266 void writeLabel(std::ostream& os, const Edge& item) const {
267 edgeset_writer.writeLabel(os, item);
275 NodeSetWriter<Graph, WriterTraits> nodeset_writer;
276 EdgeSetWriter<Graph, WriterTraits> edgeset_writer;
278 NodeWriter<Graph> node_writer;
279 EdgeWriter<Graph> edge_writer;
281 AttributeWriter<WriterTraits> attribute_writer;
285 /// \brief The undirected graph writer class.
287 /// The \c UGraphWriter class provides the ugraph output. To write
288 /// a graph you should first give writing commands to the writer. You can
289 /// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap
290 /// writing and labeled Node, Edge or UEdge writing.
293 /// UGraphWriter<ListUGraph> writer(std::cout, graph);
296 /// The \c writeNodeMap() function declares a \c NodeMap writing
297 /// command in the \c UGraphWriter. You should give as parameter
298 /// the name of the map and the map object. The NodeMap writing
299 /// command with name "label" should write a unique map because it
300 /// is regarded as label map.
303 /// IdMap<ListUGraph, Node> nodeLabelMap;
304 /// writer.writeNodeMap("label", nodeLabelMap);
306 /// writer.writeNodeMap("coords", coords);
307 /// writer.writeNodeMap("color", colorMap);
310 /// With the \c writeUEdgeMap() member function you can give an
311 /// undirected edge map writing command similar to the NodeMaps.
314 /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
315 /// edgeDescMap(graph);
316 /// writer.writeUEdgeMap("descriptor", edgeDescMap);
318 /// writer.writeUEdgeMap("weight", weightMap);
319 /// writer.writeUEdgeMap("label", labelMap);
322 /// The EdgeMap handling is just a syntactical sugar. It writes
323 /// two undirected edge map with '+' and '-' prefix in the name.
326 /// writer.writeEdgeMap("capacity", capacityMap);
330 /// With \c writeNode() and \c writeUEdge() functions you can
331 /// designate nodes and undirected edges in the graph. For example, you can
332 /// write out the source and target of the graph.
335 /// writer.writeNode("source", sourceNode);
336 /// writer.writeNode("target", targetNode);
338 /// writer.writeUEdge("observed", uEdge);
341 /// After you give all write commands you must call the \c run() member
342 /// function, which executes all the writing commands.
348 /// \see DefaultWriterTraits
349 /// \see QuotedStringWriter
351 /// \see DescriptorMap
352 /// \see \ref GraphWriter
353 /// \see \ref graph-io-page
354 /// \author Balazs Dezso
355 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
359 typedef _Graph Graph;
360 typedef typename Graph::Node Node;
361 typedef typename Graph::Edge Edge;
362 typedef typename Graph::UEdge UEdge;
364 typedef _WriterTraits WriterTraits;
366 /// \brief Construct a new UGraphWriter.
368 /// Construct a new UGraphWriter. It writes the given graph
369 /// to the given stream.
370 UGraphWriter(std::ostream& _os, const Graph& _graph)
371 : writer(new LemonWriter(_os)), own_writer(true),
372 nodeset_writer(*writer, _graph, std::string()),
373 u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
374 node_writer(*writer, nodeset_writer, std::string()),
375 u_edge_writer(*writer, u_edgeset_writer, std::string()),
376 attribute_writer(*writer, std::string()) {}
378 /// \brief Construct a new UGraphWriter.
380 /// Construct a new UGraphWriter. It writes the given graph
381 /// to the given file.
382 UGraphWriter(const std::string& _filename, const Graph& _graph)
383 : writer(new LemonWriter(_filename)), own_writer(true),
384 nodeset_writer(*writer, _graph, std::string()),
385 u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
386 node_writer(*writer, nodeset_writer, std::string()),
387 u_edge_writer(*writer, u_edgeset_writer, std::string()),
388 attribute_writer(*writer, std::string()) {}
390 /// \brief Construct a new UGraphWriter.
392 /// Construct a new UGraphWriter. It writes the given graph
393 /// to given LemonReader.
394 UGraphWriter(LemonWriter& _writer, const Graph& _graph)
395 : writer(_writer), own_writer(false),
396 nodeset_writer(*writer, _graph, std::string()),
397 u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
398 node_writer(*writer, nodeset_writer, std::string()),
399 u_edge_writer(*writer, u_edgeset_writer, std::string()),
400 attribute_writer(*writer, std::string()) {}
402 /// \brief Destruct the graph writer.
404 /// Destruct the graph writer.
410 /// \brief Issue a new node map writing command to the writer.
412 /// This function issues a new <i> node map writing command</i> to
414 template <typename Map>
415 UGraphWriter& writeNodeMap(std::string name, const Map& map) {
416 nodeset_writer.writeNodeMap(name, map);
420 /// \brief Issue a new node map writing command to the writer.
422 /// This function issues a new <i> node map writing command</i> to
424 template <typename Writer, typename Map>
425 UGraphWriter& writeNodeMap(std::string name, const Map& map,
426 const Writer& writer = Writer()) {
427 nodeset_writer.writeNodeMap(name, map, writer);
431 /// \brief Issue a new edge map writing command to the writer.
433 /// This function issues a new <i> edge map writing command</i> to
435 template <typename Map>
436 UGraphWriter& writeEdgeMap(std::string name, const Map& map) {
437 u_edgeset_writer.writeEdgeMap(name, map);
441 /// \brief Issue a new edge map writing command to the writer.
443 /// This function issues a new <i> edge map writing command</i> to
445 template <typename Writer, typename Map>
446 UGraphWriter& writeEdgeMap(std::string name, const Map& map,
447 const Writer& writer = Writer()) {
448 u_edgeset_writer.writeEdgeMap(name, map, writer);
452 /// \brief Issue a new undirected edge map writing command to the writer.
454 /// This function issues a new <i> undirected edge map writing
455 /// command</i> to the writer.
456 template <typename Map>
457 UGraphWriter& writeUEdgeMap(std::string name, const Map& map) {
458 u_edgeset_writer.writeUEdgeMap(name, map);
462 /// \brief Issue a new undirected edge map writing command to the writer.
464 /// This function issues a new <i> undirected edge map writing
465 /// command</i> to the writer.
466 template <typename Writer, typename Map>
467 UGraphWriter& writeUEdgeMap(std::string name, const Map& map,
468 const Writer& writer = Writer()) {
469 u_edgeset_writer.writeUEdgeMap(name, map, writer);
473 /// \brief Issue a new labeled node writer to the writer.
475 /// This function issues a new <i> labeled node writing
476 /// command</i> to the writer.
477 UGraphWriter& writeNode(std::string name, const Node& node) {
478 node_writer.writeNode(name, node);
482 /// \brief Issue a new labeled edge writer to the writer.
484 /// This function issues a new <i> labeled edge writing
485 /// command</i> to the writer.
486 UGraphWriter& writeEdge(std::string name, const Edge& edge) {
487 u_edge_writer.writeEdge(name, edge);
490 /// \brief Issue a new labeled undirected edge writing command to
493 /// Issue a new <i>labeled undirected edge writing command</i> to
495 UGraphWriter& writeUEdge(std::string name, const UEdge& edge) {
496 u_edge_writer.writeUEdge(name, edge);
499 /// \brief Issue a new attribute writing command.
501 /// This function issues a new <i> attribute writing
502 /// command</i> to the writer.
503 template <typename Value>
504 UGraphWriter& writeAttribute(std::string name, const Value& value) {
505 attribute_writer.writeAttribute(name, value);
509 /// \brief Issue a new attribute writing command.
511 /// This function issues a new <i> attribute writing
512 /// command</i> to the writer.
513 template <typename Writer, typename Value>
514 UGraphWriter& writeAttribute(std::string name, const Value& value,
515 const Writer& writer) {
516 attribute_writer.writeAttribute<Writer>(name, value, writer);
520 /// \brief Conversion operator to LemonWriter.
522 /// Conversion operator to LemonWriter. It makes possible
523 /// to access the encapsulated \e LemonWriter, this way
524 /// you can attach to this writer new instances of
525 /// \e LemonWriter::SectionWriter.
526 operator LemonWriter&() {
530 /// \brief Executes the writing commands.
532 /// Executes the writing commands.
537 /// \brief Write the label of the given node.
539 /// It writes the label of the given node. If there was written an "label"
540 /// named node map then it will write the map value belonging to the node.
541 void writeLabel(std::ostream& os, const Node& item) const {
542 nodeset_writer.writeLabel(os, item);
545 /// \brief Write the label of the given edge.
547 /// It writes the label of the given edge. If there was written an "label"
548 /// named edge map then it will write the map value belonging to the edge.
549 void writeLabel(std::ostream& os, const Edge& item) const {
550 u_edgeset_writer.writeLabel(os, item);
553 /// \brief Write the label of the given undirected edge.
555 /// It writes the label of the given undirected edge. If there was
556 /// written an "label" named edge map then it will write the map
557 /// value belonging to the edge.
558 void writeLabel(std::ostream& os, const UEdge& item) const {
559 u_edgeset_writer.writeLabel(os, item);
568 NodeSetWriter<Graph, WriterTraits> nodeset_writer;
569 UEdgeSetWriter<Graph, WriterTraits> u_edgeset_writer;
571 NodeWriter<Graph> node_writer;
572 UEdgeWriter<Graph> u_edge_writer;
574 AttributeWriter<WriterTraits> attribute_writer;