Changeset 156:e561aa7675de in lemon-1.0
- Timestamp:
- 05/17/08 07:30:02 (16 years ago)
- Branch:
- default
- Phase:
- public
- Files:
-
- 1 added
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/Makefile.am
r154 r156 4 4 doc/dirs.dox \ 5 5 doc/groups.dox \ 6 doc/lgf.dox \ 6 7 doc/license.dox \ 7 8 doc/mainpage.dox \ -
doc/groups.dox
r83 r156 484 484 485 485 /** 486 @defgroup section_io Section readers and writers487 @ingroup lemon_io488 \brief Section readers and writers for LEMON Input-Output.489 490 This group describes section reader and writer classes that can be491 attached to \ref LemonReader and \ref LemonWriter.492 */493 494 /**495 @defgroup item_io Item readers and writers496 @ingroup lemon_io497 \brief Item readers and writers for LEMON Input-Output.498 499 This group describes reader and writer classes for various data types500 (e.g. map or attribute values). These classes can be attached to501 \ref LemonReader and \ref LemonWriter.502 */503 504 /**505 486 @defgroup eps_io Postscript exporting 506 487 @ingroup io_group -
lemon/lgf_reader.h
r148 r156 269 269 return is; 270 270 } 271 272 std::istream& readIdentifier(std::istream& is, std::string& str) {273 std::ostringstream os;274 275 char c;276 is >> std::ws;277 278 if (!is.get(c))279 return is;280 281 if (!isIdentifierFirstChar(c))282 throw DataFormatError("Wrong char in identifier");283 284 os << c;285 286 while (is.get(c) && !isWhiteSpace(c)) {287 if (!isIdentifierChar(c))288 throw DataFormatError("Wrong char in identifier");289 os << c;290 }291 if (!is) is.clear();292 293 str = os.str();294 return is;295 }296 271 297 272 } 298 299 /// \e 273 274 /// \ingroup lemon_io 275 /// 276 /// \brief LGF reader for directed graphs 277 /// 278 /// This utility reads an \ref lgf-format "LGF" file. 279 /// 280 /// The reading method does a batch processing. The user creates a 281 /// reader object, then various reading rules can be added to the 282 /// reader, and eventually the reading is executed with the \c run() 283 /// member function. A map reading rule can be added to the reader 284 /// with the \c nodeMap() or \c arcMap() members. An optional 285 /// converter parameter can also be added as a standard functor converting from 286 /// std::string to the value type of the map. If it is set, it will 287 /// determine how the tokens in the file should be is converted to the map's 288 /// value type. If the functor is not set, then a default conversion 289 /// will be used. One map can be read into multiple map objects at the 290 /// same time. The \c attribute(), \c node() and \c arc() functions 291 /// are used to add attribute reading rules. 292 /// 293 ///\code 294 /// DigraphReader<Digraph>(std::cin, digraph). 295 /// nodeMap("coordinates", coord_map). 296 /// arcMap("capacity", cap_map). 297 /// node("source", src). 298 /// node("target", trg). 299 /// attribute("caption", caption). 300 /// run(); 301 ///\endcode 302 /// 303 /// By default the reader uses the first section in the file of the 304 /// proper type. If a section has an optional name, then it can be 305 /// selected for reading by giving an optional name parameter to 306 /// the \c nodes(), \c arcs() or \c attributes() 307 /// functions. 308 /// 309 /// The \c useNodes() and \c useArcs() functions are used to tell the reader 310 /// that the nodes or arcs should not be constructed (added to the 311 /// graph) during the reading, but instead the label map of the items 312 /// are given as a parameter of these functions. An 313 /// application of these function is multipass reading, which is 314 /// important if two \e \@arcs sections must be read from the 315 /// file. In this example the first phase would read the node set and one 316 /// of the arc sets, while the second phase would read the second arc 317 /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet). 318 /// The previously read label node map should be passed to the \c 319 /// useNodes() functions. Another application of multipass reading when 320 /// paths are given as a node map or an arc map. It is impossible read this in 321 /// a single pass, because the arcs are not constructed when the node 322 /// maps are read. 300 323 template <typename _Digraph> 301 324 class DigraphReader { … … 342 365 public: 343 366 344 /// \e 367 /// \brief Constructor 368 /// 369 /// Construct a directed graph reader, which reads from the given 370 /// input stream. 345 371 DigraphReader(std::istream& is, Digraph& digraph) 346 372 : _is(&is), local_is(false), _digraph(digraph), 347 373 _use_nodes(false), _use_arcs(false) {} 348 374 349 /// \e 375 /// \brief Constructor 376 /// 377 /// Construct a directed graph reader, which reads from the given 378 /// file. 350 379 DigraphReader(const std::string& fn, Digraph& digraph) 351 380 : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph), 352 381 _use_nodes(false), _use_arcs(false) {} 353 354 355 /// \e 382 383 /// \brief Constructor 384 /// 385 /// Construct a directed graph reader, which reads from the given 386 /// file. 356 387 DigraphReader(const char* fn, Digraph& digraph) 357 388 : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph), 358 389 _use_nodes(false), _use_arcs(false) {} 359 390 360 /// \e 391 /// \brief Copy constructor 392 /// 393 /// The copy constructor transfers all data from the other reader, 394 /// therefore the copied reader will not be usable more. 361 395 DigraphReader(DigraphReader& other) 362 396 : _is(other._is), local_is(other.local_is), _digraph(other._digraph), … … 378 412 } 379 413 380 /// \ e414 /// \brief Destructor 381 415 ~DigraphReader() { 382 416 for (typename NodeMaps::iterator it = _node_maps.begin(); … … 407 441 public: 408 442 409 /// \e 443 /// \name Reading rules 444 /// @{ 445 446 /// \brief Node map reading rule 447 /// 448 /// Add a node map reading rule to the reader. 410 449 template <typename Map> 411 450 DigraphReader& nodeMap(const std::string& caption, Map& map) { … … 417 456 } 418 457 419 /// \e 458 /// \brief Node map reading rule 459 /// 460 /// Add a node map reading rule with specialized converter to the 461 /// reader. 420 462 template <typename Map, typename Converter> 421 463 DigraphReader& nodeMap(const std::string& caption, Map& map, … … 428 470 } 429 471 430 /// \e 472 /// \brief Arc map reading rule 473 /// 474 /// Add an arc map reading rule to the reader. 431 475 template <typename Map> 432 476 DigraphReader& arcMap(const std::string& caption, Map& map) { … … 438 482 } 439 483 440 /// \e 484 /// \brief Arc map reading rule 485 /// 486 /// Add an arc map reading rule with specialized converter to the 487 /// reader. 441 488 template <typename Map, typename Converter> 442 489 DigraphReader& arcMap(const std::string& caption, Map& map, … … 449 496 } 450 497 451 /// \e 498 /// \brief Attribute reading rule 499 /// 500 /// Add an attribute reading rule to the reader. 452 501 template <typename Value> 453 502 DigraphReader& attribute(const std::string& caption, Value& value) { … … 458 507 } 459 508 460 /// \e 509 /// \brief Attribute reading rule 510 /// 511 /// Add an attribute reading rule with specialized converter to the 512 /// reader. 461 513 template <typename Value, typename Converter> 462 514 DigraphReader& attribute(const std::string& caption, Value& value, … … 468 520 } 469 521 470 /// \e 522 /// \brief Node reading rule 523 /// 524 /// Add a node reading rule to reader. 471 525 DigraphReader& node(const std::string& caption, Node& node) { 472 526 typedef _reader_bits::MapLookUpConverter<Node> Converter; … … 478 532 } 479 533 480 /// \e 534 /// \brief Arc reading rule 535 /// 536 /// Add an arc reading rule to reader. 481 537 DigraphReader& arc(const std::string& caption, Arc& arc) { 482 538 typedef _reader_bits::MapLookUpConverter<Arc> Converter; … … 488 544 } 489 545 490 /// \e 546 /// @} 547 548 /// \name Select section by name 549 /// @{ 550 551 /// \brief Set \c \@nodes section to be read 552 /// 553 /// Set \c \@nodes section to be read 491 554 DigraphReader& nodes(const std::string& caption) { 492 555 _nodes_caption = caption; … … 494 557 } 495 558 496 /// \e 559 /// \brief Set \c \@arcs section to be read 560 /// 561 /// Set \c \@arcs section to be read 497 562 DigraphReader& arcs(const std::string& caption) { 498 563 _arcs_caption = caption; … … 500 565 } 501 566 502 /// \e 567 /// \brief Set \c \@attributes section to be read 568 /// 569 /// Set \c \@attributes section to be read 503 570 DigraphReader& attributes(const std::string& caption) { 504 571 _attributes_caption = caption; … … 506 573 } 507 574 508 /// \e 575 /// @} 576 577 /// \name Using previously constructed node or arc set 578 /// @{ 579 580 /// \brief Use previously constructed node set 581 /// 582 /// Use previously constructed node set, and specify the node 583 /// label map. 509 584 template <typename Map> 510 585 DigraphReader& useNodes(const Map& map) { … … 519 594 } 520 595 521 /// \e 596 /// \brief Use previously constructed node set 597 /// 598 /// Use previously constructed node set, and specify the node 599 /// label map and a functor which converts the label map values to 600 /// std::string. 522 601 template <typename Map, typename Converter> 523 602 DigraphReader& useNodes(const Map& map, … … 532 611 } 533 612 534 /// \e 613 /// \brief Use previously constructed arc set 614 /// 615 /// Use previously constructed arc set, and specify the arc 616 /// label map. 535 617 template <typename Map> 536 618 DigraphReader& useArcs(const Map& map) { … … 545 627 } 546 628 547 /// \e 629 /// \brief Use previously constructed arc set 630 /// 631 /// Use previously constructed arc set, and specify the arc 632 /// label map and a functor which converts the label map values to 633 /// std::string. 548 634 template <typename Map, typename Converter> 549 635 DigraphReader& useArcs(const Map& map, … … 558 644 } 559 645 646 /// @} 647 560 648 private: 561 649 … … 598 686 std::string map; 599 687 int index = 0; 600 while (_reader_bits::read Identifier(line, map)) {688 while (_reader_bits::readToken(line, map)) { 601 689 if (maps.find(map) != maps.end()) { 602 690 std::ostringstream msg; … … 681 769 std::string map; 682 770 int index = 0; 683 while (_reader_bits::read Identifier(line, map)) {771 while (_reader_bits::readToken(line, map)) { 684 772 if (maps.find(map) != maps.end()) { 685 773 std::ostringstream msg; … … 788 876 789 877 std::string attr, token; 790 if (!_reader_bits::read Identifier(line, attr))878 if (!_reader_bits::readToken(line, attr)) 791 879 throw DataFormatError("Attribute name not found"); 792 880 if (!_reader_bits::readToken(line, token)) … … 828 916 829 917 public: 830 831 /// \e 918 919 /// \name Execution of the reader 920 /// @{ 921 922 /// \brief Start the batch processing 923 /// 924 /// This function starts the batch processing 832 925 void run() { 833 926 … … 847 940 std::string section, caption; 848 941 line >> c; 849 _reader_bits::read Identifier(line, section);850 _reader_bits::read Identifier(line, caption);942 _reader_bits::readToken(line, section); 943 _reader_bits::readToken(line, caption); 851 944 852 945 if (line >> c) … … 892 985 893 986 } 987 988 /// @} 894 989 895 990 }; 896 991 992 /// \relates DigraphReader 897 993 template <typename Digraph> 898 994 DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph) { … … 900 996 } 901 997 998 /// \relates DigraphReader 902 999 template <typename Digraph> 903 1000 DigraphReader<Digraph> digraphReader(const std::string& fn, … … 906 1003 } 907 1004 1005 /// \relates DigraphReader 908 1006 template <typename Digraph> 909 1007 DigraphReader<Digraph> digraphReader(const char* fn, Digraph& digraph) { -
lemon/lgf_writer.h
r148 r156 205 205 206 206 bool requireEscape(const std::string& str) { 207 if (str.empty() || str[0] == '@') return true; 207 208 std::istringstream is(str); 208 209 char c; … … 232 233 } 233 234 234 /// \e 235 /// \ingroup lemon_io 236 /// 237 /// \brief LGF writer for directed graphs 238 /// 239 /// This utility writes an \ref lgf-format "LGF" file. 240 /// 241 /// The writing method does a batch processing. The user creates a 242 /// writer object, then various writing rules can be added to the 243 /// writer, and eventually the writing is executed with the \c run() 244 /// member function. A map writing rule can be added to the writer 245 /// with the \c nodeMap() or \c arcMap() members. An optional 246 /// converter parameter can also be added as a standard functor converting from 247 /// the value type of the map to std::string. If it is set, it will 248 /// determine how the map's value type is written to the output 249 /// stream. If the functor is not set, then a default conversion 250 /// will be used. The \c attribute(), \c node() and \c arc() functions 251 /// are used to add attribute writing rules. 252 /// 253 ///\code 254 /// DigraphWriter<Digraph>(std::cout, digraph). 255 /// nodeMap("coordinates", coord_map). 256 /// nodeMap("size", size). 257 /// nodeMap("title", title). 258 /// arcMap("capacity", cap_map). 259 /// node("source", src). 260 /// node("target", trg). 261 /// attribute("caption", caption). 262 /// run(); 263 ///\endcode 264 /// 265 /// 266 /// By default, the writer does not write additional captions to the 267 /// sections, but they can be give as an optional parameter of 268 /// the \c nodes(), \c arcs() or \c 269 /// attributes() functions. 270 /// 271 /// The \c skipNodes() and \c skipArcs() functions forbid the 272 /// writing of the sections. If two arc sections should be written to the 273 /// output, it can be done in two passes, the first pass writes the 274 /// node section and the first arc section, then the second pass 275 /// skips the node section and writes just the arc section to the 276 /// stream. The output stream can be retrieved with the \c ostream() 277 /// function, hence the second pass can append its output to the output of the 278 /// first pass. 235 279 template <typename _Digraph> 236 280 class DigraphWriter { … … 274 318 public: 275 319 276 /// \e 320 /// \brief Constructor 321 /// 322 /// Construct a directed graph writer, which writes to the given 323 /// output stream. 277 324 DigraphWriter(std::ostream& is, Digraph& digraph) 278 325 : _os(&is), local_os(false), _digraph(digraph), 279 326 _skip_nodes(false), _skip_arcs(false) {} 280 327 281 /// \e 328 /// \brief Constructor 329 /// 330 /// Construct a directed graph writer, which writes to the given 331 /// output file. 282 332 DigraphWriter(const std::string& fn, Digraph& digraph) 283 333 : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph), 284 334 _skip_nodes(false), _skip_arcs(false) {} 285 335 286 /// \e 336 /// \brief Constructor 337 /// 338 /// Construct a directed graph writer, which writes to the given 339 /// output file. 287 340 DigraphWriter(const char* fn, Digraph& digraph) 288 341 : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph), 289 342 _skip_nodes(false), _skip_arcs(false) {} 290 343 344 /// \brief Copy constructor 345 /// 346 /// The copy constructor transfers all data from the other writer, 347 /// therefore the copied writer will not be usable more. 291 348 DigraphWriter(DigraphWriter& other) 292 349 : _os(other._os), local_os(other.local_os), _digraph(other._digraph), … … 308 365 } 309 366 310 /// \ e367 /// \brief Destructor 311 368 ~DigraphWriter() { 312 369 for (typename NodeMaps::iterator it = _node_maps.begin(); … … 336 393 public: 337 394 338 /// \e 395 /// \name Writing rules 396 /// @{ 397 398 /// \brief Node map reading rule 399 /// 400 /// Add a node map reading rule to the writer. 339 401 template <typename Map> 340 402 DigraphWriter& nodeMap(const std::string& caption, const Map& map) { … … 346 408 } 347 409 348 /// \e 410 /// \brief Node map writing rule 411 /// 412 /// Add a node map writing rule with specialized converter to the 413 /// writer. 349 414 template <typename Map, typename Converter> 350 415 DigraphWriter& nodeMap(const std::string& caption, const Map& map, … … 357 422 } 358 423 359 /// \e 424 /// \brief Arc map writing rule 425 /// 426 /// Add an arc map writing rule to the writer. 360 427 template <typename Map> 361 428 DigraphWriter& arcMap(const std::string& caption, const Map& map) { … … 367 434 } 368 435 369 /// \e 436 /// \brief Arc map writing rule 437 /// 438 /// Add an arc map writing rule with specialized converter to the 439 /// writer. 370 440 template <typename Map, typename Converter> 371 441 DigraphWriter& arcMap(const std::string& caption, const Map& map, … … 378 448 } 379 449 380 /// \e 450 /// \brief Attribute writing rule 451 /// 452 /// Add an attribute writing rule to the writer. 381 453 template <typename Value> 382 454 DigraphWriter& attribute(const std::string& caption, const Value& value) { … … 387 459 } 388 460 389 /// \e 461 /// \brief Attribute writing rule 462 /// 463 /// Add an attribute writing rule with specialized converter to the 464 /// writer. 390 465 template <typename Value, typename Converter> 391 466 DigraphWriter& attribute(const std::string& caption, const Value& value, … … 397 472 } 398 473 399 /// \e 474 /// \brief Node writing rule 475 /// 476 /// Add a node writing rule to the writer. 400 477 DigraphWriter& node(const std::string& caption, const Node& node) { 401 478 typedef _writer_bits::MapLookUpConverter<Node> Converter; … … 407 484 } 408 485 409 /// \e 486 /// \brief Arc writing rule 487 /// 488 /// Add an arc writing rule to writer. 410 489 DigraphWriter& arc(const std::string& caption, const Arc& arc) { 411 490 typedef _writer_bits::MapLookUpConverter<Arc> Converter; … … 417 496 } 418 497 419 /// \e 498 /// \name Select section by name 499 /// @{ 500 501 /// \brief Set \c \@nodes section to be read 502 /// 503 /// Set \c \@nodes section to be read 420 504 DigraphWriter& nodes(const std::string& caption) { 421 505 _nodes_caption = caption; … … 423 507 } 424 508 425 /// \e 509 /// \brief Set \c \@arcs section to be read 510 /// 511 /// Set \c \@arcs section to be read 426 512 DigraphWriter& arcs(const std::string& caption) { 427 513 _arcs_caption = caption; … … 429 515 } 430 516 431 /// \e 517 /// \brief Set \c \@attributes section to be read 518 /// 519 /// Set \c \@attributes section to be read 432 520 DigraphWriter& attributes(const std::string& caption) { 433 521 _attributes_caption = caption; … … 435 523 } 436 524 525 /// \name Skipping section 526 /// @{ 527 528 /// \brief Skip writing the node set 529 /// 530 /// The \c \@nodes section will be not written to the stream. 437 531 DigraphWriter& skipNodes() { 438 532 LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member"); … … 440 534 } 441 535 536 /// \brief Skip writing arc set 537 /// 538 /// The \c \@arcs section will be not written to the stream. 442 539 DigraphWriter& skipArcs() { 443 540 LEMON_ASSERT(!_skip_arcs, "Multiple usage of skipArcs() member"); 444 541 return *this; 445 542 } 543 544 /// @} 446 545 447 546 private: … … 459 558 *_os << "@nodes"; 460 559 if (!_nodes_caption.empty()) { 461 *_os << ' ' << _nodes_caption;560 _writer_bits::writeToken(*_os << ' ', _nodes_caption); 462 561 } 463 562 *_os << std::endl; … … 468 567 for (typename NodeMaps::iterator it = _node_maps.begin(); 469 568 it != _node_maps.end(); ++it) { 470 *_os << it->first<< '\t';569 _writer_bits::writeToken(*_os, it->first) << '\t'; 471 570 } 472 571 *_os << std::endl; … … 519 618 *_os << "@arcs"; 520 619 if (!_arcs_caption.empty()) { 521 *_os << ' ' << _arcs_caption;620 _writer_bits::writeToken(*_os << ' ', _arcs_caption); 522 621 } 523 622 *_os << std::endl; … … 529 628 for (typename ArcMaps::iterator it = _arc_maps.begin(); 530 629 it != _arc_maps.end(); ++it) { 531 *_os << it->first<< '\t';630 _writer_bits::writeToken(*_os, it->first) << '\t'; 532 631 } 533 632 *_os << std::endl; … … 578 677 *_os << "@attributes"; 579 678 if (!_attributes_caption.empty()) { 580 *_os << ' ' << _attributes_caption;679 _writer_bits::writeToken(*_os << ' ', _attributes_caption); 581 680 } 582 681 *_os << std::endl; 583 682 for (typename Attributes::iterator it = _attributes.begin(); 584 683 it != _attributes.end(); ++it) { 585 *_os << it->first<< ' ';684 _writer_bits::writeToken(*_os, it->first) << ' '; 586 685 _writer_bits::writeToken(*_os, it->second->get()); 587 686 *_os << std::endl; … … 591 690 public: 592 691 593 /// \e 692 /// \name Execution of the writer 693 /// @{ 694 695 /// \brief Start the batch processing 696 /// 697 /// This function starts the batch processing 594 698 void run() { 595 699 if (!_skip_nodes) { … … 602 706 } 603 707 604 /// \e 605 std::ostream& stream() { 708 /// \brief Gives back the stream of the writer 709 /// 710 /// Gives back the stream of the writer 711 std::ostream& ostream() { 606 712 return *_os; 607 713 } 714 715 /// @} 608 716 }; 609 717 718 /// \relates DigraphWriter 610 719 template <typename Digraph> 611 720 DigraphWriter<Digraph> digraphWriter(std::istream& is, Digraph& digraph) { … … 613 722 } 614 723 724 /// \relates DigraphWriter 615 725 template <typename Digraph> 616 726 DigraphWriter<Digraph> digraphWriter(const std::string& fn, … … 619 729 } 620 730 731 /// \relates DigraphWriter 621 732 template <typename Digraph> 622 733 DigraphWriter<Digraph> digraphWriter(const char* fn, Digraph& digraph) {
Note: See TracChangeset
for help on using the changeset viewer.