Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

graph_writer.h

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

Generated on Sat Aug 27 14:14:52 2005 for LEMON by  doxygen 1.4.4