graph_writer.h

Go to the documentation of this file.
00001 /* -*- C++ -*-
00002  *
00003  * This file is a part of LEMON, a generic C++ optimization library
00004  *
00005  * Copyright (C) 2003-2006
00006  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
00007  * (Egervary Research Group on Combinatorial Optimization, EGRES).
00008  *
00009  * Permission to use, modify and distribute this software is granted
00010  * provided that this copyright notice appears in all copies. For
00011  * precise terms see the accompanying LICENSE file.
00012  *
00013  * This software is provided "AS IS" with no warranty of any kind,
00014  * express or implied, and with no claim as to its suitability for any
00015  * purpose.
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

Generated on Fri Feb 3 18:37:41 2006 for LEMON by  doxygen 1.4.6