00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00021
00022 #ifndef LEMON_GRAPH_WRITER_H
00023 #define LEMON_GRAPH_WRITER_H
00024
00025 #include <iostream>
00026
00027 #include <lemon/error.h>
00028 #include <lemon/lemon_writer.h>
00029
00030 namespace lemon {
00031
00034
00105 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
00106 class GraphWriter {
00107 public:
00108
00109 typedef _Graph Graph;
00110 typedef typename Graph::Node Node;
00111 typedef typename Graph::Edge Edge;
00112
00113 typedef _WriterTraits WriterTraits;
00114
00119 GraphWriter(std::ostream& _os, const Graph& _graph)
00120 : writer(new LemonWriter(_os)), own_writer(true),
00121 nodeset_writer(*writer, _graph, std::string()),
00122 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00123 node_writer(*writer, nodeset_writer, std::string()),
00124 edge_writer(*writer, edgeset_writer, std::string()),
00125 attribute_writer(*writer, std::string()) {}
00126
00131 GraphWriter(const std::string& _filename, const Graph& _graph)
00132 : writer(new LemonWriter(_filename)), own_writer(true),
00133 nodeset_writer(*writer, _graph, std::string()),
00134 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00135 node_writer(*writer, nodeset_writer, std::string()),
00136 edge_writer(*writer, edgeset_writer, std::string()),
00137 attribute_writer(*writer, std::string()) {}
00138
00143 GraphWriter(LemonWriter& _writer, const Graph& _graph)
00144 : writer(_writer), own_writer(false),
00145 nodeset_writer(*writer, _graph, std::string()),
00146 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00147 node_writer(*writer, nodeset_writer, std::string()),
00148 edge_writer(*writer, edgeset_writer, std::string()),
00149 attribute_writer(*writer, std::string()) {}
00150
00154 ~GraphWriter() {
00155 if (own_writer)
00156 delete writer;
00157 }
00158
00162 template <typename Map>
00163 GraphWriter& writeNodeMap(std::string name, const Map& map) {
00164 nodeset_writer.writeNodeMap(name, map);
00165 return *this;
00166 }
00167
00168
00172 template <typename Writer, typename Map>
00173 GraphWriter& writeNodeMap(std::string name, const Map& map,
00174 const Writer& writer = Writer()) {
00175 nodeset_writer.writeNodeMap(name, map, writer);
00176 return *this;
00177 }
00178
00179
00183 template <typename Map>
00184 GraphWriter& writeEdgeMap(std::string name, const Map& map) {
00185 edgeset_writer.writeEdgeMap(name, map);
00186 return *this;
00187 }
00188
00189
00193 template <typename Writer, typename Map>
00194 GraphWriter& writeEdgeMap(std::string name, const Map& map,
00195 const Writer& writer = Writer()) {
00196 edgeset_writer.writeEdgeMap(name, map, writer);
00197 return *this;
00198 }
00199
00204 GraphWriter& writeNode(std::string name, const Node& node) {
00205 node_writer.writeNode(name, node);
00206 return *this;
00207 }
00208
00213 GraphWriter& writeEdge(std::string name, const Edge& edge) {
00214 edge_writer.writeEdge(name, edge);
00215 }
00216
00221 template <typename Value>
00222 GraphWriter& writeAttribute(std::string name, const Value& value) {
00223 attribute_writer.writeAttribute(name, value);
00224 return *this;
00225 }
00226
00231 template <typename Writer, typename Value>
00232 GraphWriter& writeAttribute(std::string name, const Value& value,
00233 const Writer& writer) {
00234 attribute_writer.writeAttribute<Writer>(name, value, writer);
00235 return *this;
00236 }
00237
00245 operator LemonWriter&() {
00246 return *writer;
00247 }
00248
00252 void run() {
00253 writer->run();
00254 }
00255
00260 void writeId(std::ostream& os, const Node& item) const {
00261 nodeset_writer.writeId(os, item);
00262 }
00263
00268 void writeId(std::ostream& os, const Edge& item) const {
00269 edgeset_writer.writeId(os, item);
00270 }
00271
00272 private:
00273
00274 LemonWriter* writer;
00275 bool own_writer;
00276
00277 NodeSetWriter<Graph, WriterTraits> nodeset_writer;
00278 EdgeSetWriter<Graph, WriterTraits> edgeset_writer;
00279
00280 NodeWriter<Graph> node_writer;
00281 EdgeWriter<Graph> edge_writer;
00282
00283 AttributeWriter<WriterTraits> attribute_writer;
00284 };
00285
00286
00294 template<typename Graph>
00295 void writeGraph(std::ostream& os, const Graph &g) {
00296 GraphWriter<Graph> writer(os, g);
00297 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
00298 writer.writeNodeMap("id", nodeIdMap);
00299 IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
00300 writer.writeEdgeMap("id", edgeIdMap);
00301 writer.run();
00302 }
00303
00311 template<typename Graph, typename CapacityMap>
00312 void writeGraph(std::ostream& os, const Graph &g,
00313 const CapacityMap& capacity) {
00314 GraphWriter<Graph> writer(os, g);
00315 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
00316 writer.writeNodeMap("id", nodeIdMap);
00317 IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
00318 writer.writeEdgeMap("id", edgeIdMap);
00319 writer.writeEdgeMap("capacity", capacity);
00320 writer.run();
00321 }
00322
00331 template<typename Graph, typename CapacityMap>
00332 void writeGraph(std::ostream& os, const Graph &g,
00333 const CapacityMap& capacity, const typename Graph::Node &s) {
00334 GraphWriter<Graph> writer(os, g);
00335 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
00336 writer.writeNodeMap("id", nodeIdMap);
00337 IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
00338 writer.writeEdgeMap("id", edgeIdMap);
00339 writer.writeEdgeMap("capacity", capacity);
00340 writer.writeNode("source", s);
00341 writer.run();
00342 }
00343
00344
00355 template<typename Graph, typename CapacityMap>
00356 void writeGraph(std::ostream& os, const Graph &g,
00357 const CapacityMap& capacity, const typename Graph::Node &s,
00358 const typename Graph::Node &t) {
00359 GraphWriter<Graph> writer(os, g);
00360 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
00361 writer.writeNodeMap("id", nodeIdMap);
00362 IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
00363 writer.writeEdgeMap("id", edgeIdMap);
00364 writer.writeEdgeMap("capacity", capacity);
00365 writer.writeNode("source", s);
00366 writer.writeNode("target", t);
00367 writer.run();
00368 }
00369
00381 template<typename Graph, typename CapacityMap, typename CostMap>
00382 void writeGraph(std::ostream& os, const Graph &g,
00383 const CapacityMap& capacity, const typename Graph::Node &s,
00384 const typename Graph::Node &t, const CostMap& cost) {
00385 GraphWriter<Graph> writer(os, g);
00386 IdMap<Graph, typename Graph::Node> nodeIdMap(g);
00387 writer.writeNodeMap("id", nodeIdMap);
00388 IdMap<Graph, typename Graph::Edge> edgeIdMap(g);
00389 writer.writeEdgeMap("id", edgeIdMap);
00390 writer.writeEdgeMap("capacity", capacity);
00391 writer.writeEdgeMap("cost", cost);
00392 writer.writeNode("source", s);
00393 writer.writeNode("target", t);
00394 writer.run();
00395 }
00396
00467 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
00468 class UndirGraphWriter {
00469 public:
00470
00471 typedef _Graph Graph;
00472 typedef typename Graph::Node Node;
00473 typedef typename Graph::Edge Edge;
00474 typedef typename Graph::UndirEdge UndirEdge;
00475
00476 typedef _WriterTraits WriterTraits;
00477
00482 UndirGraphWriter(std::ostream& _os, const Graph& _graph)
00483 : writer(new LemonWriter(_os)), own_writer(true),
00484 nodeset_writer(*writer, _graph, std::string()),
00485 undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00486 node_writer(*writer, nodeset_writer, std::string()),
00487 undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
00488 attribute_writer(*writer, std::string()) {}
00489
00494 UndirGraphWriter(const std::string& _filename, const Graph& _graph)
00495 : writer(new LemonWriter(_filename)), own_writer(true),
00496 nodeset_writer(*writer, _graph, std::string()),
00497 undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00498 node_writer(*writer, nodeset_writer, std::string()),
00499 undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
00500 attribute_writer(*writer, std::string()) {}
00501
00506 UndirGraphWriter(LemonWriter& _writer, const Graph& _graph)
00507 : writer(_writer), own_writer(false),
00508 nodeset_writer(*writer, _graph, std::string()),
00509 undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00510 node_writer(*writer, nodeset_writer, std::string()),
00511 undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
00512 attribute_writer(*writer, std::string()) {}
00513
00517 ~UndirGraphWriter() {
00518 if (own_writer)
00519 delete writer;
00520 }
00521
00525 template <typename Map>
00526 UndirGraphWriter& writeNodeMap(std::string name, const Map& map) {
00527 nodeset_writer.writeNodeMap(name, map);
00528 return *this;
00529 }
00530
00534 template <typename Writer, typename Map>
00535 UndirGraphWriter& writeNodeMap(std::string name, const Map& map,
00536 const Writer& writer = Writer()) {
00537 nodeset_writer.writeNodeMap(name, map, writer);
00538 return *this;
00539 }
00540
00544 template <typename Map>
00545 UndirGraphWriter& writeEdgeMap(std::string name, const Map& map) {
00546 undir_edgeset_writer.writeEdgeMap(name, map);
00547 return *this;
00548 }
00549
00553 template <typename Writer, typename Map>
00554 UndirGraphWriter& writeEdgeMap(std::string name, const Map& map,
00555 const Writer& writer = Writer()) {
00556 undir_edgeset_writer.writeEdgeMap(name, map, writer);
00557 return *this;
00558 }
00559
00564 template <typename Map>
00565 UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map) {
00566 undir_edgeset_writer.writeUndirEdgeMap(name, map);
00567 return *this;
00568 }
00569
00574 template <typename Writer, typename Map>
00575 UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map,
00576 const Writer& writer = Writer()) {
00577 undir_edgeset_writer.writeUndirEdgeMap(name, map, writer);
00578 return *this;
00579 }
00580
00585 UndirGraphWriter& writeNode(std::string name, const Node& node) {
00586 node_writer.writeNode(name, node);
00587 return *this;
00588 }
00589
00594 UndirGraphWriter& writeEdge(std::string name, const Edge& edge) {
00595 undir_edge_writer.writeEdge(name, edge);
00596 }
00597
00603 UndirGraphWriter& writeUndirEdge(std::string name, const UndirEdge& edge) {
00604 undir_edge_writer.writeUndirEdge(name, edge);
00605 }
00606
00611 template <typename Value>
00612 UndirGraphWriter& writeAttribute(std::string name, const Value& value) {
00613 attribute_writer.writeAttribute(name, value);
00614 return *this;
00615 }
00616
00621 template <typename Writer, typename Value>
00622 UndirGraphWriter& writeAttribute(std::string name, const Value& value,
00623 const Writer& writer) {
00624 attribute_writer.writeAttribute<Writer>(name, value, writer);
00625 return *this;
00626 }
00627
00634 operator LemonWriter&() {
00635 return *writer;
00636 }
00637
00641 void run() {
00642 writer->run();
00643 }
00644
00649 void writeId(std::ostream& os, const Node& item) const {
00650 nodeset_writer.writeId(os, item);
00651 }
00652
00657 void writeId(std::ostream& os, const Edge& item) const {
00658 undir_edgeset_writer.writeId(os, item);
00659 }
00660
00666 void writeId(std::ostream& os, const UndirEdge& item) const {
00667 undir_edgeset_writer.writeId(os, item);
00668 }
00669
00670
00671 private:
00672
00673 LemonWriter* writer;
00674 bool own_writer;
00675
00676 NodeSetWriter<Graph, WriterTraits> nodeset_writer;
00677 UndirEdgeSetWriter<Graph, WriterTraits> undir_edgeset_writer;
00678
00679 NodeWriter<Graph> node_writer;
00680 UndirEdgeWriter<Graph> undir_edge_writer;
00681
00682 AttributeWriter<WriterTraits> attribute_writer;
00683 };
00684
00690 template<typename Graph>
00691 void writeUndirGraph(std::ostream& os, const Graph &g) {
00692 UndirGraphWriter<Graph> writer(os, g);
00693 writer.run();
00694 }
00695
00704 template<typename Graph, typename CapacityMap>
00705 void writeUndirGraph(std::ostream& os, const Graph &g,
00706 const CapacityMap& capacity) {
00707 UndirGraphWriter<Graph> writer(os, g);
00708 writer.writeUndirEdgeMap("capacity", capacity);
00709 writer.run();
00710 }
00711
00712
00714
00715 }
00716
00717 #endif