Changeset 1909:2d806130e700 in lemon-0.x for lemon/graph_reader.h
- Timestamp:
- 01/26/06 16:42:13 (18 years ago)
- Branch:
- default
- Phase:
- public
- Convert:
- svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2484
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
lemon/graph_reader.h
r1901 r1909 379 379 /// \brief The undirected graph reader class. 380 380 /// 381 /// The \c U ndirGraphReader class provides the graph input.381 /// The \c UGraphReader class provides the graph input. 382 382 /// Before you read this documentation it might be useful to read the general 383 383 /// description of \ref graph-io-page "Graph Input-Output". … … 391 391 /// 392 392 /// If you read a graph you need not read all the maps and items just those 393 /// that you need. The interface of the \c U ndirGraphReader is very similar394 /// to the U ndirGraphWriter but the reading method does not depend on the393 /// that you need. The interface of the \c UGraphReader is very similar 394 /// to the UGraphWriter but the reading method does not depend on the 395 395 /// order of the given commands. 396 396 /// … … 400 400 /// 401 401 /// \code 402 /// U ndirGraphReader<UndirListGraph> reader(std::cin, graph);402 /// UGraphReader<ListUGraph> reader(std::cin, graph); 403 403 /// \endcode 404 404 /// … … 417 417 /// \endcode 418 418 /// 419 /// With the \c readU ndirEdgeMap() member function you can give an420 /// u ndiredge map reading command similar to the NodeMaps.421 /// 422 /// \code 423 /// reader.readU ndirEdgeMap("capacity", capacityMap);419 /// With the \c readUEdgeMap() member function you can give an 420 /// uedge map reading command similar to the NodeMaps. 421 /// 422 /// \code 423 /// reader.readUEdgeMap("capacity", capacityMap); 424 424 /// \endcode 425 425 /// … … 433 433 /// \endcode 434 434 /// 435 /// With \c readNode() and \c readU ndirEdge() functions you can read436 /// labeled Nodes and U ndirEdges.435 /// With \c readNode() and \c readUEdge() functions you can read 436 /// labeled Nodes and UEdges. 437 437 /// 438 438 /// \code … … 440 440 /// reader.readNode("target", targetNode); 441 441 /// 442 /// reader.readU ndirEdge("observed", undirEdge);442 /// reader.readUEdge("observed", uEdge); 443 443 /// \endcode 444 444 /// … … 456 456 /// \see GraphReader 457 457 /// \see DefaultReaderTraits 458 /// \see \ref U ndirGraphWriter458 /// \see \ref UGraphWriter 459 459 /// \see \ref graph-io-page 460 460 /// 461 461 /// \author Balazs Dezso 462 462 template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 463 class U ndirGraphReader {463 class UGraphReader { 464 464 public: 465 465 … … 467 467 typedef typename Graph::Node Node; 468 468 typedef typename Graph::Edge Edge; 469 typedef typename Graph::U ndirEdge UndirEdge;469 typedef typename Graph::UEdge UEdge; 470 470 471 471 typedef _ReaderTraits ReaderTraits; 472 472 typedef typename ReaderTraits::Skipper DefaultSkipper; 473 473 474 /// \brief Construct a new U ndirGraphReader.475 /// 476 /// Construct a new U ndirGraphReader. It reads into the given graph474 /// \brief Construct a new UGraphReader. 475 /// 476 /// Construct a new UGraphReader. It reads into the given graph 477 477 /// and it use the given reader as the default skipper. 478 U ndirGraphReader(std::istream& _is, Graph& _graph,478 UGraphReader(std::istream& _is, Graph& _graph, 479 479 const DefaultSkipper& _skipper = DefaultSkipper()) 480 480 : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper), 481 481 nodeset_reader(*reader, _graph, std::string(), skipper), 482 u ndir_edgeset_reader(*reader, _graph, nodeset_reader,482 u_edgeset_reader(*reader, _graph, nodeset_reader, 483 483 std::string(), skipper), 484 484 node_reader(*reader, nodeset_reader, std::string()), 485 u ndir_edge_reader(*reader, undir_edgeset_reader, std::string()),485 u_edge_reader(*reader, u_edgeset_reader, std::string()), 486 486 attribute_reader(*reader, std::string()) {} 487 487 488 /// \brief Construct a new U ndirGraphReader.489 /// 490 /// Construct a new U ndirGraphReader. It reads into the given graph488 /// \brief Construct a new UGraphReader. 489 /// 490 /// Construct a new UGraphReader. It reads into the given graph 491 491 /// and it use the given reader as the default skipper. 492 U ndirGraphReader(const std::string& _filename, Graph& _graph,492 UGraphReader(const std::string& _filename, Graph& _graph, 493 493 const DefaultSkipper& _skipper = DefaultSkipper()) 494 494 : reader(new LemonReader(_filename)), own_reader(true), 495 495 skipper(_skipper), 496 496 nodeset_reader(*reader, _graph, std::string(), skipper), 497 u ndir_edgeset_reader(*reader, _graph, nodeset_reader,497 u_edgeset_reader(*reader, _graph, nodeset_reader, 498 498 std::string(), skipper), 499 499 node_reader(*reader, nodeset_reader, std::string()), 500 u ndir_edge_reader(*reader, undir_edgeset_reader, std::string()),500 u_edge_reader(*reader, u_edgeset_reader, std::string()), 501 501 attribute_reader(*reader, std::string()) {} 502 502 503 /// \brief Construct a new U ndirGraphReader.504 /// 505 /// Construct a new U ndirGraphReader. It reads into the given graph503 /// \brief Construct a new UGraphReader. 504 /// 505 /// Construct a new UGraphReader. It reads into the given graph 506 506 /// and it use the given reader as the default skipper. 507 U ndirGraphReader(LemonReader& _reader, Graph& _graph,507 UGraphReader(LemonReader& _reader, Graph& _graph, 508 508 const DefaultSkipper& _skipper = DefaultSkipper()) 509 509 : reader(_reader), own_reader(false), skipper(_skipper), 510 510 nodeset_reader(*reader, _graph, std::string(), skipper), 511 u ndir_edgeset_reader(*reader, _graph, nodeset_reader,511 u_edgeset_reader(*reader, _graph, nodeset_reader, 512 512 std::string(), skipper), 513 513 node_reader(*reader, nodeset_reader, std::string()), 514 u ndir_edge_reader(*reader, undir_edgeset_reader, std::string()),514 u_edge_reader(*reader, u_edgeset_reader, std::string()), 515 515 attribute_reader(*reader, std::string()) {} 516 516 … … 518 518 /// 519 519 /// Destruct the graph reader. 520 ~U ndirGraphReader() {520 ~UGraphReader() { 521 521 if (own_reader) 522 522 delete reader; … … 527 527 /// Give a new node map reading command to the reader. 528 528 template <typename Map> 529 U ndirGraphReader& readNodeMap(std::string name, Map& map) {529 UGraphReader& readNodeMap(std::string name, Map& map) { 530 530 nodeset_reader.readNodeMap(name, map); 531 531 return *this; … … 533 533 534 534 template <typename Map> 535 U ndirGraphReader& readNodeMap(std::string name, const Map& map) {535 UGraphReader& readNodeMap(std::string name, const Map& map) { 536 536 nodeset_reader.readNodeMap(name, map); 537 537 return *this; … … 542 542 /// Give a new node map reading command to the reader. 543 543 template <typename Reader, typename Map> 544 U ndirGraphReader& readNodeMap(std::string name, Map& map,544 UGraphReader& readNodeMap(std::string name, Map& map, 545 545 const Reader& reader = Reader()) { 546 546 nodeset_reader.readNodeMap(name, map, reader); … … 549 549 550 550 template <typename Reader, typename Map> 551 U ndirGraphReader& readNodeMap(std::string name, const Map& map,551 UGraphReader& readNodeMap(std::string name, const Map& map, 552 552 const Reader& reader = Reader()) { 553 553 nodeset_reader.readNodeMap(name, map, reader); … … 559 559 /// Give a new node map skipping command to the reader. 560 560 template <typename Reader> 561 U ndirGraphReader& skipNodeMap(std::string name,561 UGraphReader& skipNodeMap(std::string name, 562 562 const Reader& reader = Reader()) { 563 563 nodeset_reader.skipNodeMap(name, reader); … … 569 569 /// Give a new undirected edge map reading command to the reader. 570 570 template <typename Map> 571 U ndirGraphReader& readUndirEdgeMap(std::string name, Map& map) {572 u ndir_edgeset_reader.readUndirEdgeMap(name, map);573 return *this; 574 } 575 576 template <typename Map> 577 U ndirGraphReader& readUndirEdgeMap(std::string name, const Map& map) {578 u ndir_edgeset_reader.readUndirEdgeMap(name, map);571 UGraphReader& readUEdgeMap(std::string name, Map& map) { 572 u_edgeset_reader.readUEdgeMap(name, map); 573 return *this; 574 } 575 576 template <typename Map> 577 UGraphReader& readUEdgeMap(std::string name, const Map& map) { 578 u_edgeset_reader.readUEdgeMap(name, map); 579 579 return *this; 580 580 } … … 585 585 /// Give a new undirected edge map reading command to the reader. 586 586 template <typename Reader, typename Map> 587 U ndirGraphReader& readUndirEdgeMap(std::string name, Map& map,587 UGraphReader& readUEdgeMap(std::string name, Map& map, 588 588 const Reader& reader = Reader()) { 589 u ndir_edgeset_reader.readUndirEdgeMap(name, map, reader);590 return *this; 591 } 592 593 template <typename Reader, typename Map> 594 U ndirGraphReader& readUndirEdgeMap(std::string name, const Map& map,589 u_edgeset_reader.readUEdgeMap(name, map, reader); 590 return *this; 591 } 592 593 template <typename Reader, typename Map> 594 UGraphReader& readUEdgeMap(std::string name, const Map& map, 595 595 const Reader& reader = Reader()) { 596 u ndir_edgeset_reader.readUndirEdgeMap(name, map, reader);596 u_edgeset_reader.readUEdgeMap(name, map, reader); 597 597 return *this; 598 598 } … … 602 602 /// Give a new undirected edge map skipping command to the reader. 603 603 template <typename Reader> 604 U ndirGraphReader& skipUndirEdgeMap(std::string name,604 UGraphReader& skipUEdgeMap(std::string name, 605 605 const Reader& reader = Reader()) { 606 u ndir_edgeset_reader.skipUndirMap(name, reader);606 u_edgeset_reader.skipUMap(name, reader); 607 607 return *this; 608 608 } … … 613 613 /// Give a new edge map reading command to the reader. 614 614 template <typename Map> 615 U ndirGraphReader& readEdgeMap(std::string name, Map& map) {616 u ndir_edgeset_reader.readEdgeMap(name, map);617 return *this; 618 } 619 620 template <typename Map> 621 U ndirGraphReader& readEdgeMap(std::string name, const Map& map) {622 u ndir_edgeset_reader.readEdgeMap(name, map);615 UGraphReader& readEdgeMap(std::string name, Map& map) { 616 u_edgeset_reader.readEdgeMap(name, map); 617 return *this; 618 } 619 620 template <typename Map> 621 UGraphReader& readEdgeMap(std::string name, const Map& map) { 622 u_edgeset_reader.readEdgeMap(name, map); 623 623 return *this; 624 624 } … … 629 629 /// Give a new edge map reading command to the reader. 630 630 template <typename Reader, typename Map> 631 U ndirGraphReader& readEdgeMap(std::string name, Map& map,631 UGraphReader& readEdgeMap(std::string name, Map& map, 632 632 const Reader& reader = Reader()) { 633 u ndir_edgeset_reader.readEdgeMap(name, map, reader);634 return *this; 635 } 636 637 template <typename Reader, typename Map> 638 U ndirGraphReader& readEdgeMap(std::string name, const Map& map,633 u_edgeset_reader.readEdgeMap(name, map, reader); 634 return *this; 635 } 636 637 template <typename Reader, typename Map> 638 UGraphReader& readEdgeMap(std::string name, const Map& map, 639 639 const Reader& reader = Reader()) { 640 u ndir_edgeset_reader.readEdgeMap(name, map, reader);640 u_edgeset_reader.readEdgeMap(name, map, reader); 641 641 return *this; 642 642 } … … 646 646 /// Give a new edge map skipping command to the reader. 647 647 template <typename Reader> 648 U ndirGraphReader& skipEdgeMap(std::string name,648 UGraphReader& skipEdgeMap(std::string name, 649 649 const Reader& reader = Reader()) { 650 u ndir_edgeset_reader.skipEdgeMap(name, reader);650 u_edgeset_reader.skipEdgeMap(name, reader); 651 651 return *this; 652 652 } … … 655 655 /// 656 656 /// Give a new labeled node reading command to the reader. 657 U ndirGraphReader& readNode(std::string name, Node& node) {657 UGraphReader& readNode(std::string name, Node& node) { 658 658 node_reader.readNode(name, node); 659 659 return *this; … … 663 663 /// 664 664 /// Give a new labeled edge reading command to the reader. 665 U ndirGraphReader& readEdge(std::string name, Edge& edge) {666 u ndir_edge_reader.readEdge(name, edge);665 UGraphReader& readEdge(std::string name, Edge& edge) { 666 u_edge_reader.readEdge(name, edge); 667 667 } 668 668 … … 671 671 /// 672 672 /// Give a new labeled undirected edge reading command to the reader. 673 U ndirGraphReader& readUndirEdge(std::string name, UndirEdge& edge) {674 u ndir_edge_reader.readUndirEdge(name, edge);673 UGraphReader& readUEdge(std::string name, UEdge& edge) { 674 u_edge_reader.readUEdge(name, edge); 675 675 } 676 676 … … 679 679 /// Give a new attribute reading command. 680 680 template <typename Value> 681 U ndirGraphReader& readAttribute(std::string name, Value& value) {681 UGraphReader& readAttribute(std::string name, Value& value) { 682 682 attribute_reader.readAttribute(name, value); 683 683 return *this; … … 688 688 /// Give a new attribute reading command. 689 689 template <typename Reader, typename Value> 690 U ndirGraphReader& readAttribute(std::string name, Value& value,690 UGraphReader& readAttribute(std::string name, Value& value, 691 691 const Reader& reader) { 692 692 attribute_reader.readAttribute<Reader>(name, value, reader); … … 717 717 bool isLabelReader() const { 718 718 return nodeset_reader.isLabelReader() && 719 u ndir_edgeset_reader.isLabelReader();719 u_edgeset_reader.isLabelReader(); 720 720 } 721 721 … … 733 733 /// it. It is possible only if there was read an "label" named edge map. 734 734 void readLabel(std::istream& is, Edge& edge) const { 735 return u ndir_edgeset_reader.readLabel(is, edge);735 return u_edgeset_reader.readLabel(is, edge); 736 736 } 737 737 … … 741 741 /// belongs to it. It is possible only if there was read an "label" named 742 742 /// edge map. 743 void readLabel(std::istream& is, U ndirEdge& uedge) const {744 return u ndir_edgeset_reader.readLabel(is, uedge);743 void readLabel(std::istream& is, UEdge& uedge) const { 744 return u_edgeset_reader.readLabel(is, uedge); 745 745 } 746 746 … … 754 754 755 755 NodeSetReader<Graph, ReaderTraits> nodeset_reader; 756 U ndirEdgeSetReader<Graph, ReaderTraits> undir_edgeset_reader;756 UEdgeSetReader<Graph, ReaderTraits> u_edgeset_reader; 757 757 758 758 NodeReader<Graph> node_reader; 759 U ndirEdgeReader<Graph> undir_edge_reader;759 UEdgeReader<Graph> u_edge_reader; 760 760 761 761 AttributeReader<ReaderTraits> attribute_reader; … … 765 765 /// 766 766 /// It is a helper function to read an undirected graph from the given input 767 /// stream. It gives back an U ndirGraphReader object and this object767 /// stream. It gives back an UGraphReader object and this object 768 768 /// can read more maps, labeled nodes, edges, undirected edges and 769 769 /// attributes. … … 774 774 /// \param g The graph. 775 775 template<typename Graph> 776 U ndirGraphReader<Graph> undirGraphReader(std::istream& is, Graph &g) {776 UGraphReader<Graph> uGraphReader(std::istream& is, Graph &g) { 777 777 return GraphReader<Graph>(is, g); 778 778 } … … 781 781 /// 782 782 /// It is a helper function to read an undirected graph from the given input 783 /// file. It gives back an U ndirGraphReader object and this object783 /// file. It gives back an UGraphReader object and this object 784 784 /// can read more maps, labeled nodes, edges, undirected edges and 785 785 /// attributes. … … 790 790 /// \param g The graph. 791 791 template<typename Graph> 792 U ndirGraphReader<Graph> undirGraphReader(const std::string& fn, Graph &g) {792 UGraphReader<Graph> uGraphReader(const std::string& fn, Graph &g) { 793 793 return GraphReader<Graph>(fn, g); 794 794 }
Note: See TracChangeset
for help on using the changeset viewer.