graph_reader.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 
00022 
00023 #ifndef LEMON_GRAPH_READER_H
00024 #define LEMON_GRAPH_READER_H
00025 
00026 #include <iostream>
00027 
00028 #include <lemon/error.h>
00029 #include <lemon/lemon_reader.h>
00030 
00031 namespace lemon {
00032 
00035 
00111   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 
00112   class GraphReader {
00113   public:
00114     
00115     typedef _Graph Graph;
00116     typedef typename Graph::Node Node;
00117     typedef typename Graph::Edge Edge;
00118 
00119     typedef _ReaderTraits ReaderTraits;
00120     typedef typename ReaderTraits::Skipper DefaultSkipper;
00121 
00126     GraphReader(std::istream& _is, Graph& _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, Graph& _graph, 
00141                 const DefaultSkipper& _skipper = DefaultSkipper()) 
00142       : reader(new LemonReader(_filename)), own_reader(true), 
00143         skipper(_skipper),
00144         nodeset_reader(*reader, _graph, std::string(), skipper),
00145         edgeset_reader(*reader, _graph, nodeset_reader, 
00146                        std::string(), skipper),
00147         node_reader(*reader, nodeset_reader, std::string()),
00148         edge_reader(*reader, edgeset_reader, std::string()),
00149         attribute_reader(*reader, std::string()) {}
00150 
00155     GraphReader(LemonReader& _reader, Graph& _graph, 
00156                 const DefaultSkipper& _skipper = DefaultSkipper()) 
00157       : reader(_reader), own_reader(false), skipper(_skipper),
00158         nodeset_reader(*reader, _graph, std::string(), skipper),
00159         edgeset_reader(*reader, _graph, nodeset_reader, 
00160                        std::string(), skipper),
00161         node_reader(*reader, nodeset_reader, std::string()),
00162         edge_reader(*reader, edgeset_reader, std::string()),
00163         attribute_reader(*reader, std::string()) {}
00164 
00168     ~GraphReader() {
00169       if (own_reader) 
00170         delete reader;
00171     }
00172 
00176     template <typename Map>
00177     GraphReader& readNodeMap(std::string name, Map& map) {
00178       nodeset_reader.readNodeMap(name, map);
00179       return *this;
00180     }
00181 
00182     template <typename Map>
00183     GraphReader& readNodeMap(std::string name, const Map& map) {
00184       nodeset_reader.readNodeMap(name, map);
00185       return *this;
00186     }
00187 
00191     template <typename Reader, typename Map>
00192     GraphReader& readNodeMap(std::string name, Map& map, 
00193                              const Reader& reader = Reader()) {
00194       nodeset_reader.readNodeMap(name, map, reader);
00195       return *this;
00196     }
00197 
00198     template <typename Reader, typename Map>
00199     GraphReader& readNodeMap(std::string name, const Map& map, 
00200                              const Reader& reader = Reader()) {
00201       nodeset_reader.readNodeMap(name, map, reader);
00202       return *this;
00203     }
00204 
00208     template <typename Reader>
00209     GraphReader& skipNodeMap(std::string name, 
00210                              const Reader& reader = Reader()) {
00211       nodeset_reader.skipNodeMap(name, reader);
00212       return *this;
00213     }
00214 
00218     template <typename Map>
00219     GraphReader& readEdgeMap(std::string name, Map& map) { 
00220       edgeset_reader.readEdgeMap(name, map);
00221       return *this;
00222     }
00223 
00224     template <typename Map>
00225     GraphReader& readEdgeMap(std::string name, const Map& map) { 
00226       edgeset_reader.readEdgeMap(name, map);
00227       return *this;
00228     }
00229 
00230 
00234     template <typename Reader, typename Map>
00235     GraphReader& readEdgeMap(std::string name, Map& map,
00236                              const Reader& reader = Reader()) {
00237       edgeset_reader.readEdgeMap(name, map, reader);
00238       return *this;
00239     }
00240 
00241     template <typename Reader, typename Map>
00242     GraphReader& readEdgeMap(std::string name, const Map& map,
00243                              const Reader& reader = Reader()) {
00244       edgeset_reader.readEdgeMap(name, map, reader);
00245       return *this;
00246     }
00247 
00251     template <typename Reader>
00252     GraphReader& skipEdgeMap(std::string name, 
00253                              const Reader& reader = Reader()) {
00254       edgeset_reader.skipEdgeMap(name, reader);
00255       return *this;
00256     }
00257 
00261     GraphReader& readNode(std::string name, Node& node) {
00262       node_reader.readNode(name, node);
00263       return *this;
00264     }
00265 
00269     GraphReader& readEdge(std::string name, Edge& edge) {
00270       edge_reader.readEdge(name, edge);
00271       return *this;
00272     }
00273 
00277     template <typename Value>
00278     GraphReader& readAttribute(std::string name, Value& value) {
00279       attribute_reader.readAttribute(name, value);
00280       return *this;
00281     }
00282     
00286     template <typename Reader, typename Value>
00287     GraphReader& readAttribute(std::string name, Value& value, 
00288                                const Reader& reader) {
00289       attribute_reader.readAttribute<Reader>(name, value, reader);
00290       return *this;
00291     }
00292 
00299     operator LemonReader&() {
00300       return *reader;
00301     }
00302 
00306     void run() {
00307       reader->run();
00308     }
00309 
00310 
00314     bool isLabelReader() const {
00315       return nodeset_reader.isLabelReader() && edgeset_reader.isLabelReader();
00316     }
00317 
00322     void readLabel(std::istream& is, Node& node) const {
00323       nodeset_reader.readLabel(is, node);
00324     } 
00325 
00330     void readLabel(std::istream& is, Edge& edge) const {
00331       return edgeset_reader.readLabel(is, edge);
00332     } 
00333 
00334   private:
00335 
00336     LemonReader* reader;
00337     bool own_reader;
00338 
00339     DefaultSkipper skipper;
00340 
00341     NodeSetReader<Graph, ReaderTraits> nodeset_reader;
00342     EdgeSetReader<Graph, ReaderTraits> edgeset_reader;
00343 
00344     NodeReader<Graph> node_reader;
00345     EdgeReader<Graph> edge_reader;
00346     
00347     AttributeReader<ReaderTraits> attribute_reader;
00348   };
00349 
00350 
00361   template<typename Graph>
00362   GraphReader<Graph> graphReader(std::istream& is, Graph &g) {
00363     return GraphReader<Graph>(is, g);
00364   }
00365 
00376   template<typename Graph>
00377   GraphReader<Graph> graphReader(const std::string& fn, Graph &g) {
00378     return GraphReader<Graph>(fn, g);
00379   }
00380 
00464   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 
00465   class UGraphReader {
00466   public:
00467     
00468     typedef _Graph Graph;
00469     typedef typename Graph::Node Node;
00470     typedef typename Graph::Edge Edge;
00471     typedef typename Graph::UEdge UEdge;
00472 
00473     typedef _ReaderTraits ReaderTraits;
00474     typedef typename ReaderTraits::Skipper DefaultSkipper;
00475 
00480     UGraphReader(std::istream& _is, Graph& _graph, 
00481                      const DefaultSkipper& _skipper = DefaultSkipper()) 
00482       : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
00483         nodeset_reader(*reader, _graph, std::string(), skipper),
00484         u_edgeset_reader(*reader, _graph, nodeset_reader, 
00485                              std::string(), skipper),
00486         node_reader(*reader, nodeset_reader, std::string()),
00487         u_edge_reader(*reader, u_edgeset_reader, std::string()),
00488         attribute_reader(*reader, std::string()) {}
00489 
00494     UGraphReader(const std::string& _filename, Graph& _graph, 
00495                      const DefaultSkipper& _skipper = DefaultSkipper()) 
00496       : reader(new LemonReader(_filename)), own_reader(true), 
00497         skipper(_skipper),
00498         nodeset_reader(*reader, _graph, std::string(), skipper),
00499         u_edgeset_reader(*reader, _graph, nodeset_reader, 
00500                              std::string(), skipper),
00501         node_reader(*reader, nodeset_reader, std::string()),
00502         u_edge_reader(*reader, u_edgeset_reader, std::string()),
00503         attribute_reader(*reader, std::string()) {}
00504 
00509     UGraphReader(LemonReader& _reader, Graph& _graph, 
00510                      const DefaultSkipper& _skipper = DefaultSkipper()) 
00511       : reader(_reader), own_reader(false), skipper(_skipper),
00512         nodeset_reader(*reader, _graph, std::string(), skipper),
00513         u_edgeset_reader(*reader, _graph, nodeset_reader, 
00514                              std::string(), skipper),
00515         node_reader(*reader, nodeset_reader, std::string()),
00516         u_edge_reader(*reader, u_edgeset_reader, std::string()),
00517         attribute_reader(*reader, std::string()) {}
00518 
00522     ~UGraphReader() {
00523       if (own_reader) 
00524         delete reader;
00525     }
00526 
00530     template <typename Map>
00531     UGraphReader& readNodeMap(std::string name, Map& map) {
00532       nodeset_reader.readNodeMap(name, map);
00533       return *this;
00534     }
00535 
00536     template <typename Map>
00537     UGraphReader& readNodeMap(std::string name, const Map& map) {
00538       nodeset_reader.readNodeMap(name, map);
00539       return *this;
00540     }
00541 
00545     template <typename Reader, typename Map>
00546     UGraphReader& readNodeMap(std::string name, Map& map, 
00547                                   const Reader& reader = Reader()) {
00548       nodeset_reader.readNodeMap(name, map, reader);
00549       return *this;
00550     }
00551 
00552     template <typename Reader, typename Map>
00553     UGraphReader& readNodeMap(std::string name, const Map& map, 
00554                                   const Reader& reader = Reader()) {
00555       nodeset_reader.readNodeMap(name, map, reader);
00556       return *this;
00557     }
00558 
00562     template <typename Reader>
00563     UGraphReader& skipNodeMap(std::string name, 
00564                              const Reader& reader = Reader()) {
00565       nodeset_reader.skipNodeMap(name, reader);
00566       return *this;
00567     }
00568 
00572     template <typename Map>
00573     UGraphReader& readUEdgeMap(std::string name, Map& map) { 
00574       u_edgeset_reader.readUEdgeMap(name, map);
00575       return *this;
00576     }
00577 
00578     template <typename Map>
00579     UGraphReader& readUEdgeMap(std::string name, const Map& map) { 
00580       u_edgeset_reader.readUEdgeMap(name, map);
00581       return *this;
00582     }
00583 
00584 
00588     template <typename Reader, typename Map>
00589     UGraphReader& readUEdgeMap(std::string name, Map& map,
00590                                        const Reader& reader = Reader()) {
00591       u_edgeset_reader.readUEdgeMap(name, map, reader);
00592       return *this;
00593     }
00594 
00595     template <typename Reader, typename Map>
00596     UGraphReader& readUEdgeMap(std::string name, const Map& map,
00597                                        const Reader& reader = Reader()) {
00598       u_edgeset_reader.readUEdgeMap(name, map, reader);
00599       return *this;
00600     }
00601 
00605     template <typename Reader>
00606     UGraphReader& skipUEdgeMap(std::string name,
00607                                        const Reader& reader = Reader()) {
00608       u_edgeset_reader.skipUMap(name, reader);
00609       return *this;
00610     }
00611 
00612 
00616     template <typename Map>
00617     UGraphReader& readEdgeMap(std::string name, Map& map) { 
00618       u_edgeset_reader.readEdgeMap(name, map);
00619       return *this;
00620     }
00621 
00622     template <typename Map>
00623     UGraphReader& readEdgeMap(std::string name, const Map& map) { 
00624       u_edgeset_reader.readEdgeMap(name, map);
00625       return *this;
00626     }
00627 
00628 
00632     template <typename Reader, typename Map>
00633     UGraphReader& readEdgeMap(std::string name, Map& map,
00634                                        const Reader& reader = Reader()) {
00635       u_edgeset_reader.readEdgeMap(name, map, reader);
00636       return *this;
00637     }
00638 
00639     template <typename Reader, typename Map>
00640     UGraphReader& readEdgeMap(std::string name, const Map& map,
00641                                        const Reader& reader = Reader()) {
00642       u_edgeset_reader.readEdgeMap(name, map, reader);
00643       return *this;
00644     }
00645 
00649     template <typename Reader>
00650     UGraphReader& skipEdgeMap(std::string name,
00651                                        const Reader& reader = Reader()) {
00652       u_edgeset_reader.skipEdgeMap(name, reader);
00653       return *this;
00654     }
00655 
00659     UGraphReader& readNode(std::string name, Node& node) {
00660       node_reader.readNode(name, node);
00661       return *this;
00662     }
00663 
00667     UGraphReader& readEdge(std::string name, Edge& edge) {
00668       u_edge_reader.readEdge(name, edge);
00669     }
00670 
00675     UGraphReader& readUEdge(std::string name, UEdge& edge) {
00676       u_edge_reader.readUEdge(name, edge);
00677     }
00678 
00682     template <typename Value>
00683     UGraphReader& readAttribute(std::string name, Value& value) {
00684       attribute_reader.readAttribute(name, value);
00685       return *this;
00686     }
00687     
00691     template <typename Reader, typename Value>
00692     UGraphReader& readAttribute(std::string name, Value& value, 
00693                                const Reader& reader) {
00694       attribute_reader.readAttribute<Reader>(name, value, reader);
00695       return *this;
00696     }
00697 
00704     operator LemonReader&() {
00705       return *reader;
00706     }
00707 
00711     void run() {
00712       reader->run();
00713     }
00714 
00715 
00719     bool isLabelReader() const {
00720       return nodeset_reader.isLabelReader() && 
00721         u_edgeset_reader.isLabelReader();
00722     }
00723 
00728     void readLabel(std::istream& is, Node& node) const {
00729       return nodeset_reader.readLabel(is, node);
00730     } 
00731 
00736     void readLabel(std::istream& is, Edge& edge) const {
00737       return u_edgeset_reader.readLabel(is, edge);
00738     } 
00739 
00745     void readLabel(std::istream& is, UEdge& uedge) const {
00746       return u_edgeset_reader.readLabel(is, uedge);
00747     } 
00748     
00749 
00750   private:
00751 
00752     LemonReader* reader;
00753     bool own_reader;
00754 
00755     DefaultSkipper skipper;
00756 
00757     NodeSetReader<Graph, ReaderTraits> nodeset_reader;
00758     UEdgeSetReader<Graph, ReaderTraits> u_edgeset_reader;
00759 
00760     NodeReader<Graph> node_reader;
00761     UEdgeReader<Graph> u_edge_reader;
00762     
00763     AttributeReader<ReaderTraits> attribute_reader;
00764   };
00765 
00777   template<typename Graph>
00778   UGraphReader<Graph> uGraphReader(std::istream& is, Graph &g) {
00779     return GraphReader<Graph>(is, g);
00780   }
00781 
00793   template<typename Graph>
00794   UGraphReader<Graph> uGraphReader(const std::string& fn, Graph &g) {
00795     return GraphReader<Graph>(fn, g);
00796   }
00797 
00799 }
00800 
00801 #endif

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