00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
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