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