00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00023
00024 #ifndef LEMON_GRAPH_WRITER_H
00025 #define LEMON_GRAPH_WRITER_H
00026
00027 #include <iostream>
00028
00029 #include <lemon/error.h>
00030 #include <lemon/lemon_writer.h>
00031
00032 namespace lemon {
00033
00036
00107 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
00108 class GraphWriter {
00109 public:
00110
00111 typedef _Graph Graph;
00112 typedef typename Graph::Node Node;
00113 typedef typename Graph::Edge Edge;
00114
00115 typedef _WriterTraits WriterTraits;
00116
00121 GraphWriter(std::ostream& _os, const Graph& _graph)
00122 : writer(new LemonWriter(_os)), own_writer(true),
00123 nodeset_writer(*writer, _graph, std::string()),
00124 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00125 node_writer(*writer, nodeset_writer, std::string()),
00126 edge_writer(*writer, edgeset_writer, std::string()),
00127 attribute_writer(*writer, std::string()) {}
00128
00133 GraphWriter(const std::string& _filename, const Graph& _graph)
00134 : writer(new LemonWriter(_filename)), own_writer(true),
00135 nodeset_writer(*writer, _graph, std::string()),
00136 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00137 node_writer(*writer, nodeset_writer, std::string()),
00138 edge_writer(*writer, edgeset_writer, std::string()),
00139 attribute_writer(*writer, std::string()) {}
00140
00145 GraphWriter(LemonWriter& _writer, const Graph& _graph)
00146 : writer(_writer), own_writer(false),
00147 nodeset_writer(*writer, _graph, std::string()),
00148 edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00149 node_writer(*writer, nodeset_writer, std::string()),
00150 edge_writer(*writer, edgeset_writer, std::string()),
00151 attribute_writer(*writer, std::string()) {}
00152
00156 ~GraphWriter() {
00157 if (own_writer)
00158 delete writer;
00159 }
00160
00164 template <typename Map>
00165 GraphWriter& writeNodeMap(std::string name, const Map& map) {
00166 nodeset_writer.writeNodeMap(name, map);
00167 return *this;
00168 }
00169
00170
00174 template <typename Writer, typename Map>
00175 GraphWriter& writeNodeMap(std::string name, const Map& map,
00176 const Writer& writer = Writer()) {
00177 nodeset_writer.writeNodeMap(name, map, writer);
00178 return *this;
00179 }
00180
00181
00185 template <typename Map>
00186 GraphWriter& writeEdgeMap(std::string name, const Map& map) {
00187 edgeset_writer.writeEdgeMap(name, map);
00188 return *this;
00189 }
00190
00191
00195 template <typename Writer, typename Map>
00196 GraphWriter& writeEdgeMap(std::string name, const Map& map,
00197 const Writer& writer = Writer()) {
00198 edgeset_writer.writeEdgeMap(name, map, writer);
00199 return *this;
00200 }
00201
00206 GraphWriter& writeNode(std::string name, const Node& node) {
00207 node_writer.writeNode(name, node);
00208 return *this;
00209 }
00210
00215 GraphWriter& writeEdge(std::string name, const Edge& edge) {
00216 edge_writer.writeEdge(name, edge);
00217 }
00218
00223 template <typename Value>
00224 GraphWriter& writeAttribute(std::string name, const Value& value) {
00225 attribute_writer.writeAttribute(name, value);
00226 return *this;
00227 }
00228
00233 template <typename Writer, typename Value>
00234 GraphWriter& writeAttribute(std::string name, const Value& value,
00235 const Writer& writer) {
00236 attribute_writer.writeAttribute<Writer>(name, value, writer);
00237 return *this;
00238 }
00239
00247 operator LemonWriter&() {
00248 return *writer;
00249 }
00250
00254 void run() {
00255 writer->run();
00256 }
00257
00262 void writeLabel(std::ostream& os, const Node& item) const {
00263 nodeset_writer.writeLabel(os, item);
00264 }
00265
00270 void writeLabel(std::ostream& os, const Edge& item) const {
00271 edgeset_writer.writeLabel(os, item);
00272 }
00273
00274 private:
00275
00276 LemonWriter* writer;
00277 bool own_writer;
00278
00279 NodeSetWriter<Graph, WriterTraits> nodeset_writer;
00280 EdgeSetWriter<Graph, WriterTraits> edgeset_writer;
00281
00282 NodeWriter<Graph> node_writer;
00283 EdgeWriter<Graph> edge_writer;
00284
00285 AttributeWriter<WriterTraits> attribute_writer;
00286 };
00287
00288
00289
00299 template <typename Graph>
00300 GraphWriter<Graph> graphWriter(std::ostream& os, const Graph &g) {
00301 return GraphWriter<Graph>(os, g);
00302 }
00303
00313 template <typename Graph>
00314 GraphWriter<Graph> graphWriter(const std::string& fn, const Graph &g) {
00315 return GraphWriter<Graph>(fn, g);
00316 }
00317
00388 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
00389 class UGraphWriter {
00390 public:
00391
00392 typedef _Graph Graph;
00393 typedef typename Graph::Node Node;
00394 typedef typename Graph::Edge Edge;
00395 typedef typename Graph::UEdge UEdge;
00396
00397 typedef _WriterTraits WriterTraits;
00398
00403 UGraphWriter(std::ostream& _os, const Graph& _graph)
00404 : writer(new LemonWriter(_os)), own_writer(true),
00405 nodeset_writer(*writer, _graph, std::string()),
00406 u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00407 node_writer(*writer, nodeset_writer, std::string()),
00408 u_edge_writer(*writer, u_edgeset_writer, std::string()),
00409 attribute_writer(*writer, std::string()) {}
00410
00415 UGraphWriter(const std::string& _filename, const Graph& _graph)
00416 : writer(new LemonWriter(_filename)), own_writer(true),
00417 nodeset_writer(*writer, _graph, std::string()),
00418 u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00419 node_writer(*writer, nodeset_writer, std::string()),
00420 u_edge_writer(*writer, u_edgeset_writer, std::string()),
00421 attribute_writer(*writer, std::string()) {}
00422
00427 UGraphWriter(LemonWriter& _writer, const Graph& _graph)
00428 : writer(_writer), own_writer(false),
00429 nodeset_writer(*writer, _graph, std::string()),
00430 u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
00431 node_writer(*writer, nodeset_writer, std::string()),
00432 u_edge_writer(*writer, u_edgeset_writer, std::string()),
00433 attribute_writer(*writer, std::string()) {}
00434
00438 ~UGraphWriter() {
00439 if (own_writer)
00440 delete writer;
00441 }
00442
00446 template <typename Map>
00447 UGraphWriter& writeNodeMap(std::string name, const Map& map) {
00448 nodeset_writer.writeNodeMap(name, map);
00449 return *this;
00450 }
00451
00455 template <typename Writer, typename Map>
00456 UGraphWriter& writeNodeMap(std::string name, const Map& map,
00457 const Writer& writer = Writer()) {
00458 nodeset_writer.writeNodeMap(name, map, writer);
00459 return *this;
00460 }
00461
00465 template <typename Map>
00466 UGraphWriter& writeEdgeMap(std::string name, const Map& map) {
00467 u_edgeset_writer.writeEdgeMap(name, map);
00468 return *this;
00469 }
00470
00474 template <typename Writer, typename Map>
00475 UGraphWriter& writeEdgeMap(std::string name, const Map& map,
00476 const Writer& writer = Writer()) {
00477 u_edgeset_writer.writeEdgeMap(name, map, writer);
00478 return *this;
00479 }
00480
00485 template <typename Map>
00486 UGraphWriter& writeUEdgeMap(std::string name, const Map& map) {
00487 u_edgeset_writer.writeUEdgeMap(name, map);
00488 return *this;
00489 }
00490
00495 template <typename Writer, typename Map>
00496 UGraphWriter& writeUEdgeMap(std::string name, const Map& map,
00497 const Writer& writer = Writer()) {
00498 u_edgeset_writer.writeUEdgeMap(name, map, writer);
00499 return *this;
00500 }
00501
00506 UGraphWriter& writeNode(std::string name, const Node& node) {
00507 node_writer.writeNode(name, node);
00508 return *this;
00509 }
00510
00515 UGraphWriter& writeEdge(std::string name, const Edge& edge) {
00516 u_edge_writer.writeEdge(name, edge);
00517 }
00518
00524 UGraphWriter& writeUEdge(std::string name, const UEdge& edge) {
00525 u_edge_writer.writeUEdge(name, edge);
00526 }
00527
00532 template <typename Value>
00533 UGraphWriter& writeAttribute(std::string name, const Value& value) {
00534 attribute_writer.writeAttribute(name, value);
00535 return *this;
00536 }
00537
00542 template <typename Writer, typename Value>
00543 UGraphWriter& writeAttribute(std::string name, const Value& value,
00544 const Writer& writer) {
00545 attribute_writer.writeAttribute<Writer>(name, value, writer);
00546 return *this;
00547 }
00548
00555 operator LemonWriter&() {
00556 return *writer;
00557 }
00558
00562 void run() {
00563 writer->run();
00564 }
00565
00570 void writeLabel(std::ostream& os, const Node& item) const {
00571 nodeset_writer.writeLabel(os, item);
00572 }
00573
00578 void writeLabel(std::ostream& os, const Edge& item) const {
00579 u_edgeset_writer.writeLabel(os, item);
00580 }
00581
00587 void writeLabel(std::ostream& os, const UEdge& item) const {
00588 u_edgeset_writer.writeLabel(os, item);
00589 }
00590
00591
00592 private:
00593
00594 LemonWriter* writer;
00595 bool own_writer;
00596
00597 NodeSetWriter<Graph, WriterTraits> nodeset_writer;
00598 UEdgeSetWriter<Graph, WriterTraits> u_edgeset_writer;
00599
00600 NodeWriter<Graph> node_writer;
00601 UEdgeWriter<Graph> u_edge_writer;
00602
00603 AttributeWriter<WriterTraits> attribute_writer;
00604 };
00605
00615 template <typename Graph>
00616 UGraphWriter<Graph> uGraphWriter(std::ostream& os, const Graph &g) {
00617 return UGraphWriter<Graph>(os, g);
00618 }
00619
00631 template <typename Graph>
00632 UGraphWriter<Graph> uGraphWriter(const std::string& fn,
00633 const Graph &g) {
00634 return UGraphWriter<Graph>(fn, g);
00635 }
00636
00638
00639 }
00640
00641 #endif