COIN-OR::LEMON - Graph Library

source: lemon-0.x/lemon/graph_writer.h @ 1517:b303c1741c9a

Last change on this file since 1517:b303c1741c9a was 1435:8e85e6bbefdf, checked in by Akos Ladanyi, 16 years ago

trunk/src/* move to trunk/

File size: 22.5 KB
Line 
1/* -*- C++ -*-
2 * lemon/graph_writer.h - Part of LEMON, a generic C++ optimization library
3 *
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
5 * (Egervary Research Group on Combinatorial Optimization, EGRES).
6 *
7 * Permission to use, modify and distribute this software is granted
8 * provided that this copyright notice appears in all copies. For
9 * precise terms see the accompanying LICENSE file.
10 *
11 * This software is provided "AS IS" with no warranty of any kind,
12 * express or implied, and with no claim as to its suitability for any
13 * purpose.
14 *
15 */
16
17///\ingroup io_group
18///\file
19///\brief Lemon Graph Format writer.
20
21#ifndef LEMON_GRAPH_WRITER_H
22#define LEMON_GRAPH_WRITER_H
23
24#include <iostream>
25
26#include <lemon/error.h>
27#include <lemon/lemon_writer.h>
28
29namespace lemon {
30
31  /// \addtogroup io_group
32  /// @{
33
34  /// \brief The graph writer class.
35  ///
36  /// The \c GraphWriter class provides the graph output. To write a graph
37  /// you should first give writing commands for the writer. You can declare
38  /// write command as \c NodeMap or \c EdgeMap writing and labeled Node and
39  /// Edge writing.
40  ///
41  /// \code
42  /// GraphWriter<ListGraph> writer(std::cout, graph);
43  /// \endcode
44  ///
45  /// The \c writeNodeMap() function declares a \c NodeMap writing
46  /// command in the \c GraphWriter. You should give as parameter
47  /// the name of the map and the map object. The NodeMap writing
48  /// command with name "id" should write a unique map because it
49  /// is regarded as ID map.
50  ///
51  /// \code
52  /// IdMap<ListGraph, Node> nodeIdMap;
53  /// writer.writeNodeMap("id", nodeIdMap);
54  ///
55  /// writer.writeNodeMap("coords", coords);
56  /// writer.writeNodeMap("color", colorMap);
57  /// \endcode
58  ///
59  /// With the \c writeEdgeMap() member function you can give an edge map
60  /// writing command similar to the NodeMaps.
61  ///
62  /// \code
63  /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
64  ///   edgeDescMap(graph);
65  /// writer.writeEdgeMap("descriptor", edgeDescMap);
66  ///
67  /// writer.writeEdgeMap("weight", weightMap);
68  /// writer.writeEdgeMap("label", labelMap);
69  /// \endcode
70  ///
71  /// With \c writeNode() and \c writeEdge() functions you can
72  /// point out Nodes and Edges in the graph. By example, you can
73  /// write out the source and target of the graph.
74  ///
75  /// \code
76  /// writer.writeNode("source", sourceNode);
77  /// writer.writeNode("target", targetNode);
78  ///
79  /// writer.writeEdge("observed", edge);
80  /// \endcode
81  ///
82  /// After you give all write commands you must call the \c run() member
83  /// function, which execute all the writer commands.
84  ///
85  /// \code
86  /// writer.run();
87  /// \endcode
88  ///
89  /// \see DefaultWriterTraits
90  /// \see QuotedStringWriter
91  /// \see IdMap
92  /// \see DescriptorMap
93  /// \see \ref GraphReader
94  /// \see \ref graph-io-page
95  /// \author Balazs Dezso
96  template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
97  class GraphWriter {
98  public:
99   
100    typedef _Graph Graph;
101    typedef typename Graph::Node Node;
102    typedef typename Graph::Edge Edge;
103
104    typedef _WriterTraits WriterTraits;
105
106    /// \brief Construct a new GraphWriter.
107    ///
108    /// Construct a new GraphWriter. It writes the given graph
109    /// to the given stream.
110    GraphWriter(std::ostream& _os, const Graph& _graph)
111      : writer(new LemonWriter(_os)), own_writer(true),
112        nodeset_writer(*writer, _graph, std::string()),
113        edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
114        node_writer(*writer, nodeset_writer, std::string()),
115        edge_writer(*writer, edgeset_writer, std::string()),
116        attribute_writer(*writer, std::string()) {}
117
118    /// \brief Construct a new GraphWriter.
119    ///
120    /// Construct a new GraphWriter. It writes into the given graph
121    /// to the given file.
122    GraphWriter(const std::string& _filename, const Graph& _graph)
123      : writer(new LemonWriter(_filename)), own_writer(true),
124        nodeset_writer(*writer, _graph, std::string()),
125        edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
126        node_writer(*writer, nodeset_writer, std::string()),
127        edge_writer(*writer, edgeset_writer, std::string()),
128        attribute_writer(*writer, std::string()) {}
129
130    /// \brief Construct a new GraphWriter.
131    ///
132    /// Construct a new GraphWriter. It writes into the given graph
133    /// to given LemonReader.
134    GraphWriter(LemonWriter& _writer, const Graph& _graph)
135      : writer(_writer), own_writer(false),
136        nodeset_writer(*writer, _graph, std::string()),
137        edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
138        node_writer(*writer, nodeset_writer, std::string()),
139        edge_writer(*writer, edgeset_writer, std::string()),
140        attribute_writer(*writer, std::string()) {}
141
142    /// \brief Destruct the graph writer.
143    ///
144    /// Destruct the graph writer.
145    ~GraphWriter() {
146      if (own_writer)
147        delete writer;
148    }
149
150    /// \brief Add a new node map writer command for the writer.
151    ///
152    /// Add a new node map writer command for the writer.
153    template <typename Map>
154    GraphWriter& writeNodeMap(std::string name, const Map& map) {
155      nodeset_writer.writeNodeMap(name, map);
156      return *this;
157    }
158
159    /// \brief Add a new node map writer command for the writer.
160    ///
161    /// Add a new node map writer command for the writer.
162    template <typename Writer, typename Map>
163    GraphWriter& writeNodeMap(std::string name, const Map& map,
164                              const Writer& writer = Writer()) {
165      nodeset_writer.writeNodeMap(name, map, writer);
166      return *this;
167    }
168
169
170    /// \brief Add a new edge map writer command for the writer.
171    ///
172    /// Add a new edge map writer command for the writer.
173    template <typename Map>
174    GraphWriter& writeEdgeMap(std::string name, const Map& map) {
175      edgeset_writer.writeEdgeMap(name, map);
176      return *this;
177    }
178
179
180    /// \brief Add a new edge map writer command for the writer.
181    ///
182    /// Add a new edge map writer command for the writer.
183    template <typename Writer, typename Map>
184    GraphWriter& writeEdgeMap(std::string name, const Map& map,
185                              const Writer& writer = Writer()) {
186      edgeset_writer.writeEdgeMap(name, map, writer);
187      return *this;
188    }
189
190    /// \brief Add a new labeled node writer for the writer.
191    ///
192    /// Add a new labeled node writer for the writer.
193    GraphWriter& writeNode(std::string name, const Node& node) {
194      node_writer.writeNode(name, node);
195      return *this;
196    }
197
198    /// \brief Add a new labeled edge writer for the writer.
199    ///
200    /// Add a new labeled edge writer for the writer.
201    GraphWriter& writeEdge(std::string name, const Edge& edge) {
202      edge_writer.writeEdge(name, edge);
203    }
204
205    /// \brief Add a new attribute writer command.
206    ///
207    ///  Add a new attribute writer command.
208    template <typename Value>
209    GraphWriter& writeAttribute(std::string name, const Value& value) {
210      attribute_writer.writeAttribute(name, value);
211      return *this;
212    }
213   
214    /// \brief Add a new attribute writer command.
215    ///
216    ///  Add a new attribute writer command.
217    template <typename Writer, typename Value>
218    GraphWriter& writeAttribute(std::string name, const Value& value,
219                               const Writer& writer) {
220      attribute_writer.writeAttribute<Writer>(name, value, writer);
221      return *this;
222    }
223
224    /// \brief Conversion operator to LemonWriter.
225    ///
226    /// Conversion operator to LemonWriter. It make possible
227    /// to access the encapsulated \e LemonWriter, this way
228    /// you can attach to this writer new instances of
229    /// \e LemonWriter::SectionWriter.
230    operator LemonWriter&() {
231      return *writer;
232    }
233
234    /// \brief Executes the writer commands.
235    ///
236    /// Executes the writer commands.
237    void run() {
238      writer->run();
239    }
240
241    /// \brief Write the id of the given node.
242    ///
243    /// It writes the id of the given node. If there was written an "id"
244    /// named node map then it will write the map value belongs to the node.
245    void writeId(std::ostream& os, const Node& item) const {
246      nodeset_writer.writeId(os, item);
247    }
248
249    /// \brief Write the id of the given edge.
250    ///
251    /// It writes the id of the given edge. If there was written an "id"
252    /// named edge map then it will write the map value belongs to the edge.
253    void writeId(std::ostream& os, const Edge& item) const {
254      edgeset_writer.writeId(os, item);
255    }
256
257  private:
258
259    LemonWriter* writer;
260    bool own_writer;
261
262    NodeSetWriter<Graph, WriterTraits> nodeset_writer;
263    EdgeSetWriter<Graph, WriterTraits> edgeset_writer;
264
265    NodeWriter<Graph> node_writer;
266    EdgeWriter<Graph> edge_writer;
267   
268    AttributeWriter<WriterTraits> attribute_writer;
269  };
270
271
272  /// \brief Write a graph to the output.
273  ///
274  /// Write a graph to the output.
275  /// \param os The output stream.
276  /// \param g The graph.
277  /// \param capacity The capacity map.
278  /// \param s The source node.
279  /// \param t The target node.
280  /// \param cost The cost map.
281  template<typename Graph, typename CapacityMap, typename CostMap>
282  void writeGraph(std::ostream& os, const Graph &g,
283                  const CapacityMap& capacity, const typename Graph::Node &s,
284                  const typename Graph::Node &t, const CostMap& cost) {
285    GraphWriter<Graph> writer(os, g);
286    IdMap<Graph, typename Graph::Node> nodeIdMap(g);
287    writer.writeNodeMap("id", nodeIdMap);
288    IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
289    writer.writeEdgeMap("id", edgeIdMap);
290    writer.writeEdgeMap("capacity", capacity);
291    writer.writeEdgeMap("cost", cost);
292    writer.writeNode("source", s);
293    writer.writeNode("target", t);
294    writer.run();
295  }
296
297  /// \brief Write a graph to the output.
298  ///
299  /// Write a graph to the output.
300  /// \param os The output stream.
301  /// \param g The graph.
302  /// \param capacity The capacity map.
303  /// \param s The source node.
304  /// \param t The target node.
305  template<typename Graph, typename CapacityMap>
306  void writeGraph(std::ostream& os, const Graph &g,
307                  const CapacityMap& capacity, const typename Graph::Node &s,
308                  const typename Graph::Node &t) {
309    GraphWriter<Graph> writer(os, g);
310    IdMap<Graph, typename Graph::Node> nodeIdMap(g);
311    writer.writeNodeMap("id", nodeIdMap);
312    IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
313    writer.writeEdgeMap("id", edgeIdMap);
314    writer.writeEdgeMap("capacity", capacity);
315    writer.writeNode("source", s);
316    writer.writeNode("target", t);
317    writer.run();
318  }
319
320  /// \brief Write a graph to the output.
321  ///
322  /// Write a graph to the output.
323  /// \param os The output stream.
324  /// \param g The graph.
325  /// \param capacity The capacity map.
326  /// \param s The source node.
327  template<typename Graph, typename CapacityMap>
328  void writeGraph(std::ostream& os, const Graph &g,
329                  const CapacityMap& capacity, const typename Graph::Node &s) {
330    GraphWriter<Graph> writer(os, g);
331    IdMap<Graph, typename Graph::Node> nodeIdMap(g);
332    writer.writeNodeMap("id", nodeIdMap);
333    IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
334    writer.writeEdgeMap("id", edgeIdMap);
335    writer.writeEdgeMap("capacity", capacity);
336    writer.writeNode("source", s);
337    writer.run();
338  }
339
340  /// \brief Write a graph to the output.
341  ///
342  /// Write a graph to the output.
343  /// \param os The output stream.
344  /// \param g The graph.
345  /// \param capacity The capacity map.
346  template<typename Graph, typename CapacityMap>
347  void writeGraph(std::ostream& os, const Graph &g,
348                  const CapacityMap& capacity) {
349    GraphWriter<Graph> writer(os, g);
350    IdMap<Graph, typename Graph::Node> nodeIdMap(g);
351    writer.writeNodeMap("id", nodeIdMap);
352    IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
353    writer.writeEdgeMap("id", edgeIdMap);
354    writer.writeEdgeMap("capacity", capacity);
355    writer.run();
356  }
357
358  /// \brief Write a graph to the output.
359  ///
360  /// Write a graph to the output.
361  /// \param os The output stream.
362  /// \param g The graph.
363  template<typename Graph>
364  void writeGraph(std::ostream& os, const Graph &g) {
365    GraphWriter<Graph> writer(os, g);
366    IdMap<Graph, typename Graph::Node> nodeIdMap(g);
367    writer.writeNodeMap("id", nodeIdMap);
368    IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
369    writer.writeEdgeMap("id", edgeIdMap);
370    writer.run();
371  }
372
373  /// \brief The undirected graph writer class.
374  ///
375  /// The \c UndirGraphWriter class provides the undir graph output. To write
376  /// a graph you should first give writing commands for the writer. You can
377  /// declare write command as \c NodeMap, \c EdgeMap or \c UndirEdgeMap
378  /// writing and labeled Node, Edge or UndirEdge writing.
379  ///
380  /// \code
381  /// UndirGraphWriter<UndirListGraph> writer(std::cout, graph);
382  /// \endcode
383  ///
384  /// The \c writeNodeMap() function declares a \c NodeMap writing
385  /// command in the \c UndirGraphWriter. You should give as parameter
386  /// the name of the map and the map object. The NodeMap writing
387  /// command with name "id" should write a unique map because it
388  /// is regarded as ID map.
389  ///
390  /// \code
391  /// IdMap<UndirListGraph, Node> nodeIdMap;
392  /// writer.writeNodeMap("id", nodeIdMap);
393  ///
394  /// writer.writeNodeMap("coords", coords);
395  /// writer.writeNodeMap("color", colorMap);
396  /// \endcode
397  ///
398  /// With the \c writeUndirEdgeMap() member function you can give an
399  /// undirected edge map writing command similar to the NodeMaps.
400  ///
401  /// \code
402  /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
403  ///   edgeDescMap(graph);
404  /// writer.writeUndirEdgeMap("descriptor", edgeDescMap);
405  ///
406  /// writer.writeUndirEdgeMap("weight", weightMap);
407  /// writer.writeUndirEdgeMap("label", labelMap);
408  /// \endcode
409  ///
410  /// The EdgeMap handling is just a syntactical sugar. It writes
411  /// two undirected edge map with '+' and '-' prefix in the name.
412  ///
413  /// \code
414  /// writer.writeEdgeMap("capacity", capacityMap);
415  /// \endcode
416  ///
417  ///
418  /// With \c writeNode() and \c writeUndirEdge() functions you can
419  /// point out nodes and undirected edges in the graph. By example, you can
420  /// write out the source and target of the graph.
421  ///
422  /// \code
423  /// writer.writeNode("source", sourceNode);
424  /// writer.writeNode("target", targetNode);
425  ///
426  /// writer.writeUndirEdge("observed", undirEdge);
427  /// \endcode
428  ///
429  /// After you give all write commands you must call the \c run() member
430  /// function, which execute all the writer commands.
431  ///
432  /// \code
433  /// writer.run();
434  /// \endcode
435  ///
436  /// \see DefaultWriterTraits
437  /// \see QuotedStringWriter
438  /// \see IdMap
439  /// \see DescriptorMap
440  /// \see \ref GraphWriter
441  /// \see \ref graph-io-page
442  /// \author Balazs Dezso
443  template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
444  class UndirGraphWriter {
445  public:
446   
447    typedef _Graph Graph;
448    typedef typename Graph::Node Node;
449    typedef typename Graph::Edge Edge;
450    typedef typename Graph::UndirEdge UndirEdge;
451
452    typedef _WriterTraits WriterTraits;
453
454    /// \brief Construct a new UndirGraphWriter.
455    ///
456    /// Construct a new UndirGraphWriter. It writes the given graph
457    /// to the given stream.
458    UndirGraphWriter(std::ostream& _os, const Graph& _graph)
459      : writer(new LemonWriter(_os)), own_writer(true),
460        nodeset_writer(*writer, _graph, std::string()),
461        undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
462        node_writer(*writer, nodeset_writer, std::string()),
463        undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
464        attribute_writer(*writer, std::string()) {}
465
466    /// \brief Construct a new UndirGraphWriter.
467    ///
468    /// Construct a new UndirGraphWriter. It writes into the given graph
469    /// to the given file.
470    UndirGraphWriter(const std::string& _filename, const Graph& _graph)
471      : writer(new LemonWriter(_filename)), own_writer(true),
472        nodeset_writer(*writer, _graph, std::string()),
473        undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
474        node_writer(*writer, nodeset_writer, std::string()),
475        undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
476        attribute_writer(*writer, std::string()) {}
477
478    /// \brief Construct a new UndirGraphWriter.
479    ///
480    /// Construct a new UndirGraphWriter. It writes into the given graph
481    /// to given LemonReader.
482    UndirGraphWriter(LemonWriter& _writer, const Graph& _graph)
483      : writer(_writer), own_writer(false),
484        nodeset_writer(*writer, _graph, std::string()),
485        undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
486        node_writer(*writer, nodeset_writer, std::string()),
487        undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
488        attribute_writer(*writer, std::string()) {}
489
490    /// \brief Destruct the graph writer.
491    ///
492    /// Destruct the graph writer.
493    ~UndirGraphWriter() {
494      if (own_writer)
495        delete writer;
496    }
497
498    /// \brief Add a new node map writer command for the writer.
499    ///
500    /// Add a new node map writer command for the writer.
501    template <typename Map>
502    UndirGraphWriter& writeNodeMap(std::string name, const Map& map) {
503      nodeset_writer.writeNodeMap(name, map);
504      return *this;
505    }
506
507    /// \brief Add a new node map writer command for the writer.
508    ///
509    /// Add a new node map writer command for the writer.
510    template <typename Writer, typename Map>
511    UndirGraphWriter& writeNodeMap(std::string name, const Map& map,
512                              const Writer& writer = Writer()) {
513      nodeset_writer.writeNodeMap(name, map, writer);
514      return *this;
515    }
516
517    /// \brief Add a new edge map writer command for the writer.
518    ///
519    /// Add a new edge map writer command for the writer.
520    template <typename Map>
521    UndirGraphWriter& writeEdgeMap(std::string name, const Map& map) {
522      undir_edgeset_writer.writeEdgeMap(name, map);
523      return *this;
524    }
525
526    /// \brief Add a new edge map writer command for the writer.
527    ///
528    /// Add a new edge map writer command for the writer.
529    template <typename Writer, typename Map>
530    UndirGraphWriter& writeEdgeMap(std::string name, const Map& map,
531                                   const Writer& writer = Writer()) {
532      undir_edgeset_writer.writeEdgeMap(name, map, writer);
533      return *this;
534    }
535
536    /// \brief Add a new undirected edge map writer command for the writer.
537    ///
538    /// Add a new undirected edge map writer command for the writer.
539    template <typename Map>
540    UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map) {
541      undir_edgeset_writer.writeUndirEdgeMap(name, map);
542      return *this;
543    }
544
545    /// \brief Add a new undirected edge map writer command for the writer.
546    ///
547    /// Add a new edge undirected map writer command for the writer.
548    template <typename Writer, typename Map>
549    UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map,
550                                        const Writer& writer = Writer()) {
551      undir_edgeset_writer.writeUndirEdgeMap(name, map, writer);
552      return *this;
553    }
554
555    /// \brief Add a new labeled node writer for the writer.
556    ///
557    /// Add a new labeled node writer for the writer.
558    UndirGraphWriter& writeNode(std::string name, const Node& node) {
559      node_writer.writeNode(name, node);
560      return *this;
561    }
562
563    /// \brief Add a new labeled edge writer for the writer.
564    ///
565    /// Add a new labeled edge writer for the writer.
566    UndirGraphWriter& writeEdge(std::string name, const Edge& edge) {
567      undir_edge_writer.writeEdge(name, edge);
568    }
569
570    /// \brief Add a new labeled undirected edge writer for the writer.
571    ///
572    /// Add a new labeled undirected edge writer for the writer.
573    UndirGraphWriter& writeUndirEdge(std::string name, const UndirEdge& edge) {
574      undir_edge_writer.writeUndirEdge(name, edge);
575    }
576
577    /// \brief Add a new attribute writer command.
578    ///
579    ///  Add a new attribute writer command.
580    template <typename Value>
581    UndirGraphWriter& writeAttribute(std::string name, const Value& value) {
582      attribute_writer.writeAttribute(name, value);
583      return *this;
584    }
585   
586    /// \brief Add a new attribute writer command.
587    ///
588    ///  Add a new attribute writer command.
589    template <typename Writer, typename Value>
590    UndirGraphWriter& writeAttribute(std::string name, const Value& value,
591                               const Writer& writer) {
592      attribute_writer.writeAttribute<Writer>(name, value, writer);
593      return *this;
594    }
595
596    /// \brief Conversion operator to LemonWriter.
597    ///
598    /// Conversion operator to LemonWriter. It make possible
599    /// to access the encapsulated \e LemonWriter, this way
600    /// you can attach to this writer new instances of
601    /// \e LemonWriter::SectionWriter.
602    operator LemonWriter&() {
603      return *writer;
604    }
605
606    /// \brief Executes the writer commands.
607    ///
608    /// Executes the writer commands.
609    void run() {
610      writer->run();
611    }
612
613    /// \brief Write the id of the given node.
614    ///
615    /// It writes the id of the given node. If there was written an "id"
616    /// named node map then it will write the map value belongs to the node.
617    void writeId(std::ostream& os, const Node& item) const {
618      nodeset_writer.writeId(os, item);
619    }
620
621    /// \brief Write the id of the given edge.
622    ///
623    /// It writes the id of the given edge. If there was written an "id"
624    /// named edge map then it will write the map value belongs to the edge.
625    void writeId(std::ostream& os, const Edge& item) const {
626      undir_edgeset_writer.writeId(os, item);
627    }
628
629    /// \brief Write the id of the given undirected edge.
630    ///
631    /// It writes the id of the given undirected edge. If there was written
632    /// an "id" named edge map then it will write the map value belongs to
633    /// the edge.
634    void writeId(std::ostream& os, const UndirEdge& item) const {
635      undir_edgeset_writer.writeId(os, item);
636    }
637
638
639  private:
640
641    LemonWriter* writer;
642    bool own_writer;
643
644    NodeSetWriter<Graph, WriterTraits> nodeset_writer;
645    UndirEdgeSetWriter<Graph, WriterTraits> undir_edgeset_writer;
646
647    NodeWriter<Graph> node_writer;
648    UndirEdgeWriter<Graph> undir_edge_writer;
649   
650    AttributeWriter<WriterTraits> attribute_writer;
651  };
652
653
654  /// \brief Write an undirected graph to the output.
655  ///
656  /// Write an undirected graph to the output.
657  /// \param os The output stream.
658  /// \param g The graph.
659  /// \param capacity The capacity undirected map.
660  template<typename Graph, typename CapacityMap>
661  void writeUndirGraph(std::ostream& os, const Graph &g,
662                       const CapacityMap& capacity) {
663    UndirGraphWriter<Graph> writer(os, g);
664    writer.writeUndirEdgeMap("capacity", capacity);
665    writer.run();
666  }
667
668  /// \brief Write an undirected graph to the output.
669  ///
670  /// Write an undirected graph to the output.
671  /// \param os The output stream.
672  /// \param g The graph.
673  template<typename Graph>
674  void writeUndirGraph(std::ostream& os, const Graph &g) {
675    UndirGraphWriter<Graph> writer(os, g);
676    writer.run();
677  }
678
679  /// @}
680
681}
682
683#endif
Note: See TracBrowser for help on using the repository browser.