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

graph_reader.h

Go to the documentation of this file.
00001 /* -*- C++ -*-
00002  * lemon/graph_reader.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 
00020 
00021 #ifndef LEMON_GRAPH_READER_H
00022 #define LEMON_GRAPH_READER_H
00023 
00024 #include <iostream>
00025 
00026 #include <lemon/error.h>
00027 #include <lemon/lemon_reader.h>
00028 
00029 namespace lemon {
00030 
00033 
00110   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 
00111   class GraphReader {
00112   public:
00113     
00114     typedef _Graph Graph;
00115     typedef typename Graph::Node Node;
00116     typedef typename Graph::Edge Edge;
00117 
00118     typedef _ReaderTraits ReaderTraits;
00119     typedef typename ReaderTraits::Skipper DefaultSkipper;
00120 
00125     GraphReader(std::istream& _is, 
00126                 typename SmartParameter<Graph>::Type _graph, 
00127                 const DefaultSkipper& _skipper = DefaultSkipper()) 
00128       : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
00129         nodeset_reader(*reader, _graph, std::string(), skipper),
00130         edgeset_reader(*reader, _graph, nodeset_reader, 
00131                        std::string(), skipper),
00132         node_reader(*reader, nodeset_reader, std::string()),
00133         edge_reader(*reader, edgeset_reader, std::string()),
00134         attribute_reader(*reader, std::string()) {}
00135 
00140     GraphReader(const std::string& _filename, 
00141                 typename SmartParameter<Graph>::Type _graph, 
00142                 const DefaultSkipper& _skipper = DefaultSkipper()) 
00143       : reader(new LemonReader(_filename)), own_reader(true), 
00144         skipper(_skipper),
00145         nodeset_reader(*reader, _graph, std::string(), skipper),
00146         edgeset_reader(*reader, _graph, nodeset_reader, 
00147                        std::string(), skipper),
00148         node_reader(*reader, nodeset_reader, std::string()),
00149         edge_reader(*reader, edgeset_reader, std::string()),
00150         attribute_reader(*reader, std::string()) {}
00151 
00156     GraphReader(LemonReader& _reader, 
00157                 typename SmartParameter<Graph>::Type _graph, 
00158                 const DefaultSkipper& _skipper = DefaultSkipper()) 
00159       : reader(_reader), own_reader(false), skipper(_skipper),
00160         nodeset_reader(*reader, _graph, std::string(), skipper),
00161         edgeset_reader(*reader, _graph, nodeset_reader, 
00162                        std::string(), skipper),
00163         node_reader(*reader, nodeset_reader, std::string()),
00164         edge_reader(*reader, edgeset_reader, std::string()),
00165         attribute_reader(*reader, std::string()) {}
00166 
00170     ~GraphReader() {
00171       if (own_reader) 
00172         delete reader;
00173     }
00174 
00178     template <typename Map>
00179     GraphReader& readNodeMap(std::string name, Map& map) {
00180       nodeset_reader.readNodeMap(name, map);
00181       return *this;
00182     }
00183 
00184     template <typename Map>
00185     GraphReader& readNodeMap(std::string name, const Map& map) {
00186       nodeset_reader.readNodeMap(name, map);
00187       return *this;
00188     }
00189 
00193     template <typename Reader, typename Map>
00194     GraphReader& readNodeMap(std::string name, Map& map, 
00195                              const Reader& reader = Reader()) {
00196       nodeset_reader.readNodeMap(name, map, reader);
00197       return *this;
00198     }
00199 
00200     template <typename Reader, typename Map>
00201     GraphReader& readNodeMap(std::string name, const Map& map, 
00202                              const Reader& reader = Reader()) {
00203       nodeset_reader.readNodeMap(name, map, reader);
00204       return *this;
00205     }
00206 
00210     template <typename Reader>
00211     GraphReader& skipNodeMap(std::string name, 
00212                              const Reader& reader = Reader()) {
00213       nodeset_reader.skipNodeMap(name, reader);
00214       return *this;
00215     }
00216 
00220     template <typename Map>
00221     GraphReader& readEdgeMap(std::string name, Map& map) { 
00222       edgeset_reader.readEdgeMap(name, map);
00223       return *this;
00224     }
00225 
00226     template <typename Map>
00227     GraphReader& readEdgeMap(std::string name, const Map& map) { 
00228       edgeset_reader.readEdgeMap(name, map);
00229       return *this;
00230     }
00231 
00232 
00236     template <typename Reader, typename Map>
00237     GraphReader& readEdgeMap(std::string name, Map& map,
00238                              const Reader& reader = Reader()) {
00239       edgeset_reader.readEdgeMap(name, map, reader);
00240       return *this;
00241     }
00242 
00243     template <typename Reader, typename Map>
00244     GraphReader& readEdgeMap(std::string name, const Map& map,
00245                              const Reader& reader = Reader()) {
00246       edgeset_reader.readEdgeMap(name, map, reader);
00247       return *this;
00248     }
00249 
00253     template <typename Reader>
00254     GraphReader& skipEdgeMap(std::string name, 
00255                              const Reader& reader = Reader()) {
00256       edgeset_reader.skipEdgeMap(name, reader);
00257       return *this;
00258     }
00259 
00263     GraphReader& readNode(std::string name, Node& node) {
00264       node_reader.readNode(name, node);
00265       return *this;
00266     }
00267 
00271     GraphReader& readEdge(std::string name, Edge& edge) {
00272       edge_reader.readEdge(name, edge);
00273       return *this;
00274     }
00275 
00279     template <typename Value>
00280     GraphReader& readAttribute(std::string name, Value& value) {
00281       attribute_reader.readAttribute(name, value);
00282       return *this;
00283     }
00284     
00288     template <typename Reader, typename Value>
00289     GraphReader& readAttribute(std::string name, Value& value, 
00290                                const Reader& reader) {
00291       attribute_reader.readAttribute<Reader>(name, value, reader);
00292       return *this;
00293     }
00294 
00301     operator LemonReader&() {
00302       return *reader;
00303     }
00304 
00308     void run() {
00309       reader->run();
00310     }
00311 
00316     Node readId(std::istream& is, Node) const {
00317       return nodeset_reader.readId(is, Node());
00318     } 
00319 
00324     Edge readId(std::istream& is, Edge) const {
00325       return edgeset_reader.readId(is, Edge());
00326     } 
00327 
00328   private:
00329 
00330     LemonReader* reader;
00331     bool own_reader;
00332 
00333     DefaultSkipper skipper;
00334 
00335     NodeSetReader<Graph, ReaderTraits> nodeset_reader;
00336     EdgeSetReader<Graph, ReaderTraits> edgeset_reader;
00337 
00338     NodeReader<Graph> node_reader;
00339     EdgeReader<Graph> edge_reader;
00340     
00341     AttributeReader<ReaderTraits> attribute_reader;
00342   };
00343 
00344 
00352   template<typename Graph>
00353   void readGraph(std::istream& is, Graph &g) {
00354     GraphReader<Graph> reader(is, g);
00355     reader.run();
00356   }
00357 
00365   template<typename Graph, typename CapacityMap>
00366   void readGraph(std::istream& is, Graph &g, CapacityMap& capacity) {
00367     GraphReader<Graph> reader(is, g);
00368     reader.readEdgeMap("capacity", capacity);
00369     reader.run();
00370   }
00371 
00380   template<typename Graph, typename CapacityMap>
00381   void readGraph(std::istream& is, Graph &g, CapacityMap& capacity, 
00382                   typename Graph::Node &s) {
00383     GraphReader<Graph> reader(is, g);
00384     reader.readEdgeMap("capacity", capacity);
00385     reader.readNode("source", s);
00386     reader.run();
00387   }
00388 
00389 
00390 
00401   template<typename Graph, typename CapacityMap>
00402   void readGraph(std::istream& is, Graph &g, CapacityMap& capacity, 
00403                   typename Graph::Node &s, typename Graph::Node &t) {
00404     GraphReader<Graph> reader(is, g);
00405     reader.readEdgeMap("capacity", capacity);
00406     reader.readNode("source", s);
00407     reader.readNode("target", t);
00408     reader.run();
00409   }
00410 
00422   template<typename Graph, typename CapacityMap, typename CostMap>
00423   void readGraph(std::istream& is, Graph &g, CapacityMap& capacity, 
00424                   typename Graph::Node &s, typename Graph::Node &t, 
00425                   CostMap& cost) {
00426     GraphReader<Graph> reader(is, g);
00427     reader.readEdgeMap("capacity", capacity);
00428     reader.readEdgeMap("cost", cost);
00429     reader.readNode("source", s);
00430     reader.readNode("target", t);
00431     reader.run();
00432   }
00433 
00434 
00519   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 
00520   class UndirGraphReader {
00521   public:
00522     
00523     typedef _Graph Graph;
00524     typedef typename Graph::Node Node;
00525     typedef typename Graph::Edge Edge;
00526     typedef typename Graph::UndirEdge UndirEdge;
00527 
00528     typedef _ReaderTraits ReaderTraits;
00529     typedef typename ReaderTraits::Skipper DefaultSkipper;
00530 
00535     UndirGraphReader(std::istream& _is, Graph& _graph, 
00536                      const DefaultSkipper& _skipper = DefaultSkipper()) 
00537       : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
00538         nodeset_reader(*reader, _graph, std::string(), skipper),
00539         undir_edgeset_reader(*reader, _graph, nodeset_reader, 
00540                              std::string(), skipper),
00541         node_reader(*reader, nodeset_reader, std::string()),
00542         undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
00543         attribute_reader(*reader, std::string()) {}
00544 
00549     UndirGraphReader(const std::string& _filename, Graph& _graph, 
00550                      const DefaultSkipper& _skipper = DefaultSkipper()) 
00551       : reader(new LemonReader(_filename)), own_reader(true), 
00552         skipper(_skipper),
00553         nodeset_reader(*reader, _graph, std::string(), skipper),
00554         undir_edgeset_reader(*reader, _graph, nodeset_reader, 
00555                              std::string(), skipper),
00556         node_reader(*reader, nodeset_reader, std::string()),
00557         undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
00558         attribute_reader(*reader, std::string()) {}
00559 
00564     UndirGraphReader(LemonReader& _reader, Graph& _graph, 
00565                      const DefaultSkipper& _skipper = DefaultSkipper()) 
00566       : reader(_reader), own_reader(false), skipper(_skipper),
00567         nodeset_reader(*reader, _graph, std::string(), skipper),
00568         undir_edgeset_reader(*reader, _graph, nodeset_reader, 
00569                              std::string(), skipper),
00570         node_reader(*reader, nodeset_reader, std::string()),
00571         undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
00572         attribute_reader(*reader, std::string()) {}
00573 
00577     ~UndirGraphReader() {
00578       if (own_reader) 
00579         delete reader;
00580     }
00581 
00585     template <typename Map>
00586     UndirGraphReader& readNodeMap(std::string name, Map& map) {
00587       nodeset_reader.readNodeMap(name, map);
00588       return *this;
00589     }
00590 
00591     template <typename Map>
00592     UndirGraphReader& readNodeMap(std::string name, const Map& map) {
00593       nodeset_reader.readNodeMap(name, map);
00594       return *this;
00595     }
00596 
00600     template <typename Reader, typename Map>
00601     UndirGraphReader& readNodeMap(std::string name, Map& map, 
00602                                   const Reader& reader = Reader()) {
00603       nodeset_reader.readNodeMap(name, map, reader);
00604       return *this;
00605     }
00606 
00607     template <typename Reader, typename Map>
00608     UndirGraphReader& readNodeMap(std::string name, const Map& map, 
00609                                   const Reader& reader = Reader()) {
00610       nodeset_reader.readNodeMap(name, map, reader);
00611       return *this;
00612     }
00613 
00617     template <typename Reader>
00618     UndirGraphReader& skipNodeMap(std::string name, 
00619                              const Reader& reader = Reader()) {
00620       nodeset_reader.skipNodeMap(name, reader);
00621       return *this;
00622     }
00623 
00627     template <typename Map>
00628     UndirGraphReader& readUndirEdgeMap(std::string name, Map& map) { 
00629       undir_edgeset_reader.readUndirEdgeMap(name, map);
00630       return *this;
00631     }
00632 
00633     template <typename Map>
00634     UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map) { 
00635       undir_edgeset_reader.readUndirEdgeMap(name, map);
00636       return *this;
00637     }
00638 
00639 
00643     template <typename Reader, typename Map>
00644     UndirGraphReader& readUndirEdgeMap(std::string name, Map& map,
00645                                        const Reader& reader = Reader()) {
00646       undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
00647       return *this;
00648     }
00649 
00650     template <typename Reader, typename Map>
00651     UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map,
00652                                        const Reader& reader = Reader()) {
00653       undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
00654       return *this;
00655     }
00656 
00660     template <typename Reader>
00661     UndirGraphReader& skipUndirEdgeMap(std::string name,
00662                                        const Reader& reader = Reader()) {
00663       undir_edgeset_reader.skipUndirMap(name, reader);
00664       return *this;
00665     }
00666 
00667 
00671     template <typename Map>
00672     UndirGraphReader& readEdgeMap(std::string name, Map& map) { 
00673       undir_edgeset_reader.readEdgeMap(name, map);
00674       return *this;
00675     }
00676 
00677     template <typename Map>
00678     UndirGraphReader& readEdgeMap(std::string name, const Map& map) { 
00679       undir_edgeset_reader.readEdgeMap(name, map);
00680       return *this;
00681     }
00682 
00683 
00687     template <typename Reader, typename Map>
00688     UndirGraphReader& readEdgeMap(std::string name, Map& map,
00689                                        const Reader& reader = Reader()) {
00690       undir_edgeset_reader.readEdgeMap(name, map, reader);
00691       return *this;
00692     }
00693 
00694     template <typename Reader, typename Map>
00695     UndirGraphReader& readEdgeMap(std::string name, const Map& map,
00696                                        const Reader& reader = Reader()) {
00697       undir_edgeset_reader.readEdgeMap(name, map, reader);
00698       return *this;
00699     }
00700 
00704     template <typename Reader>
00705     UndirGraphReader& skipEdgeMap(std::string name,
00706                                        const Reader& reader = Reader()) {
00707       undir_edgeset_reader.skipEdgeMap(name, reader);
00708       return *this;
00709     }
00710 
00714     UndirGraphReader& readNode(std::string name, Node& node) {
00715       node_reader.readNode(name, node);
00716       return *this;
00717     }
00718 
00722     UndirGraphReader& readEdge(std::string name, Edge& edge) {
00723       undir_edge_reader.readEdge(name, edge);
00724     }
00725 
00730     UndirGraphReader& readUndirEdge(std::string name, UndirEdge& edge) {
00731       undir_edge_reader.readUndirEdge(name, edge);
00732     }
00733 
00737     template <typename Value>
00738     UndirGraphReader& readAttribute(std::string name, Value& value) {
00739       attribute_reader.readAttribute(name, value);
00740       return *this;
00741     }
00742     
00746     template <typename Reader, typename Value>
00747     UndirGraphReader& readAttribute(std::string name, Value& value, 
00748                                const Reader& reader) {
00749       attribute_reader.readAttribute<Reader>(name, value, reader);
00750       return *this;
00751     }
00752 
00759     operator LemonReader&() {
00760       return *reader;
00761     }
00762 
00766     void run() {
00767       reader->run();
00768     }
00769 
00774     Node readId(std::istream& is, Node) const {
00775       return nodeset_reader.readId(is, Node());
00776     } 
00777 
00782     Edge readId(std::istream& is, Edge) const {
00783       return undir_edgeset_reader.readId(is, Edge());
00784     } 
00785 
00791     UndirEdge readId(std::istream& is, UndirEdge) const {
00792       return undir_edgeset_reader.readId(is, UndirEdge());
00793     } 
00794     
00795 
00796   private:
00797 
00798     LemonReader* reader;
00799     bool own_reader;
00800 
00801     DefaultSkipper skipper;
00802 
00803     NodeSetReader<Graph, ReaderTraits> nodeset_reader;
00804     UndirEdgeSetReader<Graph, ReaderTraits> undir_edgeset_reader;
00805 
00806     NodeReader<Graph> node_reader;
00807     UndirEdgeReader<Graph> undir_edge_reader;
00808     
00809     AttributeReader<ReaderTraits> attribute_reader;
00810   };
00811 
00817   template<typename Graph>
00818   void readUndirGraph(std::istream& is, Graph &g) {
00819     UndirGraphReader<Graph> reader(is, g);
00820     reader.run();
00821   }
00822 
00831   template<typename Graph, typename CapacityMap>
00832   void readUndirGraph(std::istream& is, Graph &g, CapacityMap& capacity) {
00833     UndirGraphReader<Graph> reader(is, g);
00834     reader.readUndirEdgeMap("capacity", capacity);
00835     reader.run();
00836   }
00837 
00838 
00840 }
00841 
00842 #endif

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