/Src/Dependencies/Boost/boost/algorithm/string/erase.hpp
C++ Header | 844 lines | 442 code | 58 blank | 344 comment | 0 complexity | ba9f3085b59811ec4c30690a7eca2d9a MD5 | raw file
1// Boost string_algo library erase.hpp header file ---------------------------// 2 3// Copyright Pavol Droba 2002-2006. 4// 5// Distributed under the Boost Software License, Version 1.0. 6// (See accompanying file LICENSE_1_0.txt or copy at 7// http://www.boost.org/LICENSE_1_0.txt) 8 9// See http://www.boost.org/ for updates, documentation, and revision history. 10 11#ifndef BOOST_STRING_ERASE_HPP 12#define BOOST_STRING_ERASE_HPP 13 14#include <boost/algorithm/string/config.hpp> 15 16#include <boost/range/iterator_range.hpp> 17#include <boost/range/begin.hpp> 18#include <boost/range/end.hpp> 19#include <boost/range/iterator.hpp> 20#include <boost/range/const_iterator.hpp> 21 22#include <boost/algorithm/string/find_format.hpp> 23#include <boost/algorithm/string/finder.hpp> 24#include <boost/algorithm/string/formatter.hpp> 25 26/*! \file 27 Defines various erase algorithms. Each algorithm removes 28 part(s) of the input according to a searching criteria. 29*/ 30 31namespace boost { 32 namespace algorithm { 33 34// erase_range -------------------------------------------------------// 35 36 //! Erase range algorithm 37 /*! 38 Remove the given range from the input. The result is a modified copy of 39 the input. It is returned as a sequence or copied to the output iterator. 40 41 \param Output An output iterator to which the result will be copied 42 \param Input An input sequence 43 \param SearchRange A range in the input to be removed 44 \return An output iterator pointing just after the last inserted character or 45 a modified copy of the input 46 47 \note The second variant of this function provides the strong exception-safety guarantee 48 */ 49 template<typename OutputIteratorT, typename RangeT> 50 inline OutputIteratorT erase_range_copy( 51 OutputIteratorT Output, 52 const RangeT& Input, 53 const iterator_range< 54 BOOST_STRING_TYPENAME 55 range_const_iterator<RangeT>::type>& SearchRange ) 56 { 57 return ::boost::algorithm::find_format_copy( 58 Output, 59 Input, 60 ::boost::algorithm::range_finder(SearchRange), 61 ::boost::algorithm::empty_formatter(Input) ); 62 } 63 64 //! Erase range algorithm 65 /*! 66 \overload 67 */ 68 template<typename SequenceT> 69 inline SequenceT erase_range_copy( 70 const SequenceT& Input, 71 const iterator_range< 72 BOOST_STRING_TYPENAME 73 range_const_iterator<SequenceT>::type>& SearchRange ) 74 { 75 return ::boost::algorithm::find_format_copy( 76 Input, 77 ::boost::algorithm::range_finder(SearchRange), 78 ::boost::algorithm::empty_formatter(Input) ); 79 } 80 81 //! Erase range algorithm 82 /*! 83 Remove the given range from the input. 84 The input sequence is modified in-place. 85 86 \param Input An input sequence 87 \param SearchRange A range in the input to be removed 88 */ 89 template<typename SequenceT> 90 inline void erase_range( 91 SequenceT& Input, 92 const iterator_range< 93 BOOST_STRING_TYPENAME 94 range_iterator<SequenceT>::type>& SearchRange ) 95 { 96 ::boost::algorithm::find_format( 97 Input, 98 ::boost::algorithm::range_finder(SearchRange), 99 ::boost::algorithm::empty_formatter(Input) ); 100 } 101 102// erase_first --------------------------------------------------------// 103 104 //! Erase first algorithm 105 /*! 106 Remove the first occurrence of the substring from the input. 107 The result is a modified copy of the input. It is returned as a sequence 108 or copied to the output iterator. 109 110 \param Output An output iterator to which the result will be copied 111 \param Input An input string 112 \param Search A substring to be searched for 113 \return An output iterator pointing just after the last inserted character or 114 a modified copy of the input 115 116 \note The second variant of this function provides the strong exception-safety guarantee 117 */ 118 template< 119 typename OutputIteratorT, 120 typename Range1T, 121 typename Range2T> 122 inline OutputIteratorT erase_first_copy( 123 OutputIteratorT Output, 124 const Range1T& Input, 125 const Range2T& Search ) 126 { 127 return ::boost::algorithm::find_format_copy( 128 Output, 129 Input, 130 ::boost::algorithm::first_finder(Search), 131 ::boost::algorithm::empty_formatter(Input) ); 132 } 133 134 //! Erase first algorithm 135 /*! 136 \overload 137 */ 138 template<typename SequenceT, typename RangeT> 139 inline SequenceT erase_first_copy( 140 const SequenceT& Input, 141 const RangeT& Search ) 142 { 143 return ::boost::algorithm::find_format_copy( 144 Input, 145 ::boost::algorithm::first_finder(Search), 146 ::boost::algorithm::empty_formatter(Input) ); 147 } 148 149 //! Erase first algorithm 150 /*! 151 Remove the first occurrence of the substring from the input. 152 The input sequence is modified in-place. 153 154 \param Input An input string 155 \param Search A substring to be searched for. 156 */ 157 template<typename SequenceT, typename RangeT> 158 inline void erase_first( 159 SequenceT& Input, 160 const RangeT& Search ) 161 { 162 ::boost::algorithm::find_format( 163 Input, 164 ::boost::algorithm::first_finder(Search), 165 ::boost::algorithm::empty_formatter(Input) ); 166 } 167 168// erase_first ( case insensitive ) ------------------------------------// 169 170 //! Erase first algorithm ( case insensitive ) 171 /*! 172 Remove the first occurrence of the substring from the input. 173 The result is a modified copy of the input. It is returned as a sequence 174 or copied to the output iterator. 175 Searching is case insensitive. 176 177 \param Output An output iterator to which the result will be copied 178 \param Input An input string 179 \param Search A substring to be searched for 180 \param Loc A locale used for case insensitive comparison 181 \return An output iterator pointing just after the last inserted character or 182 a modified copy of the input 183 184 \note The second variant of this function provides the strong exception-safety guarantee 185 */ 186 template< 187 typename OutputIteratorT, 188 typename Range1T, 189 typename Range2T> 190 inline OutputIteratorT ierase_first_copy( 191 OutputIteratorT Output, 192 const Range1T& Input, 193 const Range2T& Search, 194 const std::locale& Loc=std::locale() ) 195 { 196 return ::boost::algorithm::find_format_copy( 197 Output, 198 Input, 199 ::boost::algorithm::first_finder(Search, is_iequal(Loc)), 200 ::boost::algorithm::empty_formatter(Input) ); 201 } 202 203 //! Erase first algorithm ( case insensitive ) 204 /*! 205 \overload 206 */ 207 template<typename SequenceT, typename RangeT> 208 inline SequenceT ierase_first_copy( 209 const SequenceT& Input, 210 const RangeT& Search, 211 const std::locale& Loc=std::locale() ) 212 { 213 return ::boost::algorithm::find_format_copy( 214 Input, 215 ::boost::algorithm::first_finder(Search, is_iequal(Loc)), 216 ::boost::algorithm::empty_formatter(Input) ); 217 } 218 219 //! Erase first algorithm ( case insensitive ) 220 /*! 221 Remove the first occurrence of the substring from the input. 222 The input sequence is modified in-place. Searching is case insensitive. 223 224 \param Input An input string 225 \param Search A substring to be searched for 226 \param Loc A locale used for case insensitive comparison 227 */ 228 template<typename SequenceT, typename RangeT> 229 inline void ierase_first( 230 SequenceT& Input, 231 const RangeT& Search, 232 const std::locale& Loc=std::locale() ) 233 { 234 ::boost::algorithm::find_format( 235 Input, 236 ::boost::algorithm::first_finder(Search, is_iequal(Loc)), 237 ::boost::algorithm::empty_formatter(Input) ); 238 } 239 240// erase_last --------------------------------------------------------// 241 242 //! Erase last algorithm 243 /*! 244 Remove the last occurrence of the substring from the input. 245 The result is a modified copy of the input. It is returned as a sequence 246 or copied to the output iterator. 247 248 \param Output An output iterator to which the result will be copied 249 \param Input An input string 250 \param Search A substring to be searched for. 251 \return An output iterator pointing just after the last inserted character or 252 a modified copy of the input 253 254 \note The second variant of this function provides the strong exception-safety guarantee 255 */ 256 template< 257 typename OutputIteratorT, 258 typename Range1T, 259 typename Range2T> 260 inline OutputIteratorT erase_last_copy( 261 OutputIteratorT Output, 262 const Range1T& Input, 263 const Range2T& Search ) 264 { 265 return ::boost::algorithm::find_format_copy( 266 Output, 267 Input, 268 ::boost::algorithm::last_finder(Search), 269 ::boost::algorithm::empty_formatter(Input) ); 270 } 271 272 //! Erase last algorithm 273 /*! 274 \overload 275 */ 276 template<typename SequenceT, typename RangeT> 277 inline SequenceT erase_last_copy( 278 const SequenceT& Input, 279 const RangeT& Search ) 280 { 281 return ::boost::algorithm::find_format_copy( 282 Input, 283 ::boost::algorithm::last_finder(Search), 284 ::boost::algorithm::empty_formatter(Input) ); 285 } 286 287 //! Erase last algorithm 288 /*! 289 Remove the last occurrence of the substring from the input. 290 The input sequence is modified in-place. 291 292 \param Input An input string 293 \param Search A substring to be searched for 294 */ 295 template<typename SequenceT, typename RangeT> 296 inline void erase_last( 297 SequenceT& Input, 298 const RangeT& Search ) 299 { 300 ::boost::algorithm::find_format( 301 Input, 302 ::boost::algorithm::last_finder(Search), 303 ::boost::algorithm::empty_formatter(Input) ); 304 } 305 306// erase_last ( case insensitive ) ------------------------------------// 307 308 //! Erase last algorithm ( case insensitive ) 309 /*! 310 Remove the last occurrence of the substring from the input. 311 The result is a modified copy of the input. It is returned as a sequence 312 or copied to the output iterator. 313 Searching is case insensitive. 314 315 \param Output An output iterator to which the result will be copied 316 \param Input An input string 317 \param Search A substring to be searched for 318 \param Loc A locale used for case insensitive comparison 319 \return An output iterator pointing just after the last inserted character or 320 a modified copy of the input 321 322 \note The second variant of this function provides the strong exception-safety guarantee 323 */ 324 template< 325 typename OutputIteratorT, 326 typename Range1T, 327 typename Range2T> 328 inline OutputIteratorT ierase_last_copy( 329 OutputIteratorT Output, 330 const Range1T& Input, 331 const Range2T& Search, 332 const std::locale& Loc=std::locale() ) 333 { 334 return ::boost::algorithm::find_format_copy( 335 Output, 336 Input, 337 ::boost::algorithm::last_finder(Search, is_iequal(Loc)), 338 ::boost::algorithm::empty_formatter(Input) ); 339 } 340 341 //! Erase last algorithm ( case insensitive ) 342 /*! 343 \overload 344 */ 345 template<typename SequenceT, typename RangeT> 346 inline SequenceT ierase_last_copy( 347 const SequenceT& Input, 348 const RangeT& Search, 349 const std::locale& Loc=std::locale() ) 350 { 351 return ::boost::algorithm::find_format_copy( 352 Input, 353 ::boost::algorithm::last_finder(Search, is_iequal(Loc)), 354 ::boost::algorithm::empty_formatter(Input) ); 355 } 356 357 //! Erase last algorithm ( case insensitive ) 358 /*! 359 Remove the last occurrence of the substring from the input. 360 The input sequence is modified in-place. Searching is case insensitive. 361 362 \param Input An input string 363 \param Search A substring to be searched for 364 \param Loc A locale used for case insensitive comparison 365 */ 366 template<typename SequenceT, typename RangeT> 367 inline void ierase_last( 368 SequenceT& Input, 369 const RangeT& Search, 370 const std::locale& Loc=std::locale() ) 371 { 372 ::boost::algorithm::find_format( 373 Input, 374 ::boost::algorithm::last_finder(Search, is_iequal(Loc)), 375 ::boost::algorithm::empty_formatter(Input) ); 376 } 377 378// erase_nth --------------------------------------------------------------------// 379 380 //! Erase nth algorithm 381 /*! 382 Remove the Nth occurrence of the substring in the input. 383 The result is a modified copy of the input. It is returned as a sequence 384 or copied to the output iterator. 385 386 387 \param Output An output iterator to which the result will be copied 388 \param Input An input string 389 \param Search A substring to be searched for 390 \param Nth An index of the match to be replaced. The index is 0-based. 391 For negative N, matches are counted from the end of string. 392 \return An output iterator pointing just after the last inserted character or 393 a modified copy of the input 394 395 \note The second variant of this function provides the strong exception-safety guarantee 396 */ 397 template< 398 typename OutputIteratorT, 399 typename Range1T, 400 typename Range2T> 401 inline OutputIteratorT erase_nth_copy( 402 OutputIteratorT Output, 403 const Range1T& Input, 404 const Range2T& Search, 405 int Nth ) 406 { 407 return ::boost::algorithm::find_format_copy( 408 Output, 409 Input, 410 ::boost::algorithm::nth_finder(Search, Nth), 411 ::boost::algorithm::empty_formatter(Input) ); 412 } 413 414 //! Erase nth algorithm 415 /*! 416 \overload 417 */ 418 template<typename SequenceT, typename RangeT> 419 inline SequenceT erase_nth_copy( 420 const SequenceT& Input, 421 const RangeT& Search, 422 int Nth ) 423 { 424 return ::boost::algorithm::find_format_copy( 425 Input, 426 ::boost::algorithm::nth_finder(Search, Nth), 427 ::boost::algorithm::empty_formatter(Input) ); 428 } 429 430 //! Erase nth algorithm 431 /*! 432 Remove the Nth occurrence of the substring in the input. 433 The input sequence is modified in-place. 434 435 \param Input An input string 436 \param Search A substring to be searched for. 437 \param Nth An index of the match to be replaced. The index is 0-based. 438 For negative N, matches are counted from the end of string. 439 */ 440 template<typename SequenceT, typename RangeT> 441 inline void erase_nth( 442 SequenceT& Input, 443 const RangeT& Search, 444 int Nth ) 445 { 446 ::boost::algorithm::find_format( 447 Input, 448 ::boost::algorithm::nth_finder(Search, Nth), 449 ::boost::algorithm::empty_formatter(Input) ); 450 } 451 452// erase_nth ( case insensitive ) ---------------------------------------------// 453 454 //! Erase nth algorithm ( case insensitive ) 455 /*! 456 Remove the Nth occurrence of the substring in the input. 457 The result is a modified copy of the input. It is returned as a sequence 458 or copied to the output iterator. 459 Searching is case insensitive. 460 461 \param Output An output iterator to which the result will be copied 462 \param Input An input string 463 \param Search A substring to be searched for. 464 \param Nth An index of the match to be replaced. The index is 0-based. 465 For negative N, matches are counted from the end of string. 466 \param Loc A locale used for case insensitive comparison 467 \return An output iterator pointing just after the last inserted character or 468 a modified copy of the input 469 470 \note The second variant of this function provides the strong exception-safety guarantee 471 */ 472 template< 473 typename OutputIteratorT, 474 typename Range1T, 475 typename Range2T> 476 inline OutputIteratorT ierase_nth_copy( 477 OutputIteratorT Output, 478 const Range1T& Input, 479 const Range2T& Search, 480 int Nth, 481 const std::locale& Loc=std::locale() ) 482 { 483 return ::boost::algorithm::find_format_copy( 484 Output, 485 Input, 486 ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), 487 ::boost::algorithm::empty_formatter(Input) ); 488 } 489 490 //! Erase nth algorithm 491 /*! 492 \overload 493 */ 494 template<typename SequenceT, typename RangeT> 495 inline SequenceT ierase_nth_copy( 496 const SequenceT& Input, 497 const RangeT& Search, 498 int Nth, 499 const std::locale& Loc=std::locale() ) 500 { 501 return ::boost::algorithm::find_format_copy( 502 Input, 503 ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), 504 empty_formatter(Input) ); 505 } 506 507 //! Erase nth algorithm 508 /*! 509 Remove the Nth occurrence of the substring in the input. 510 The input sequence is modified in-place. Searching is case insensitive. 511 512 \param Input An input string 513 \param Search A substring to be searched for. 514 \param Nth An index of the match to be replaced. The index is 0-based. 515 For negative N, matches are counted from the end of string. 516 \param Loc A locale used for case insensitive comparison 517 */ 518 template<typename SequenceT, typename RangeT> 519 inline void ierase_nth( 520 SequenceT& Input, 521 const RangeT& Search, 522 int Nth, 523 const std::locale& Loc=std::locale() ) 524 { 525 ::boost::algorithm::find_format( 526 Input, 527 ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), 528 ::boost::algorithm::empty_formatter(Input) ); 529 } 530 531 532// erase_all --------------------------------------------------------// 533 534 //! Erase all algorithm 535 /*! 536 Remove all the occurrences of the string from the input. 537 The result is a modified copy of the input. It is returned as a sequence 538 or copied to the output iterator. 539 540 541 \param Output An output iterator to which the result will be copied 542 \param Input An input sequence 543 \param Search A substring to be searched for. 544 \return An output iterator pointing just after the last inserted character or 545 a modified copy of the input 546 547 \note The second variant of this function provides the strong exception-safety guarantee 548 */ 549 template< 550 typename OutputIteratorT, 551 typename Range1T, 552 typename Range2T> 553 inline OutputIteratorT erase_all_copy( 554 OutputIteratorT Output, 555 const Range1T& Input, 556 const Range2T& Search ) 557 { 558 return ::boost::algorithm::find_format_all_copy( 559 Output, 560 Input, 561 ::boost::algorithm::first_finder(Search), 562 ::boost::algorithm::empty_formatter(Input) ); 563 } 564 565 //! Erase all algorithm 566 /*! 567 \overload 568 */ 569 template<typename SequenceT, typename RangeT> 570 inline SequenceT erase_all_copy( 571 const SequenceT& Input, 572 const RangeT& Search ) 573 { 574 return ::boost::algorithm::find_format_all_copy( 575 Input, 576 ::boost::algorithm::first_finder(Search), 577 ::boost::algorithm::empty_formatter(Input) ); 578 } 579 580 //! Erase all algorithm 581 /*! 582 Remove all the occurrences of the string from the input. 583 The input sequence is modified in-place. 584 585 \param Input An input string 586 \param Search A substring to be searched for. 587 */ 588 template<typename SequenceT, typename RangeT> 589 inline void erase_all( 590 SequenceT& Input, 591 const RangeT& Search ) 592 { 593 ::boost::algorithm::find_format_all( 594 Input, 595 ::boost::algorithm::first_finder(Search), 596 ::boost::algorithm::empty_formatter(Input) ); 597 } 598 599// erase_all ( case insensitive ) ------------------------------------// 600 601 //! Erase all algorithm ( case insensitive ) 602 /*! 603 Remove all the occurrences of the string from the input. 604 The result is a modified copy of the input. It is returned as a sequence 605 or copied to the output iterator. 606 Searching is case insensitive. 607 608 \param Output An output iterator to which the result will be copied 609 \param Input An input string 610 \param Search A substring to be searched for 611 \param Loc A locale used for case insensitive comparison 612 \return An output iterator pointing just after the last inserted character or 613 a modified copy of the input 614 615 \note The second variant of this function provides the strong exception-safety guarantee 616 */ 617 template< 618 typename OutputIteratorT, 619 typename Range1T, 620 typename Range2T> 621 inline OutputIteratorT ierase_all_copy( 622 OutputIteratorT Output, 623 const Range1T& Input, 624 const Range2T& Search, 625 const std::locale& Loc=std::locale() ) 626 { 627 return ::boost::algorithm::find_format_all_copy( 628 Output, 629 Input, 630 ::boost::algorithm::first_finder(Search, is_iequal(Loc)), 631 ::boost::algorithm::empty_formatter(Input) ); 632 } 633 634 //! Erase all algorithm ( case insensitive ) 635 /*! 636 \overload 637 */ 638 template<typename SequenceT, typename RangeT> 639 inline SequenceT ierase_all_copy( 640 const SequenceT& Input, 641 const RangeT& Search, 642 const std::locale& Loc=std::locale() ) 643 { 644 return ::boost::algorithm::find_format_all_copy( 645 Input, 646 ::boost::algorithm::first_finder(Search, is_iequal(Loc)), 647 ::boost::algorithm::empty_formatter(Input) ); 648 } 649 650 //! Erase all algorithm ( case insensitive ) 651 /*! 652 Remove all the occurrences of the string from the input. 653 The input sequence is modified in-place. Searching is case insensitive. 654 655 \param Input An input string 656 \param Search A substring to be searched for. 657 \param Loc A locale used for case insensitive comparison 658 */ 659 template<typename SequenceT, typename RangeT> 660 inline void ierase_all( 661 SequenceT& Input, 662 const RangeT& Search, 663 const std::locale& Loc=std::locale() ) 664 { 665 ::boost::algorithm::find_format_all( 666 Input, 667 ::boost::algorithm::first_finder(Search, is_iequal(Loc)), 668 ::boost::algorithm::empty_formatter(Input) ); 669 } 670 671// erase_head --------------------------------------------------------------------// 672 673 //! Erase head algorithm 674 /*! 675 Remove the head from the input. The head is a prefix of a sequence of given size. 676 If the sequence is shorter then required, the whole string is 677 considered to be the head. The result is a modified copy of the input. 678 It is returned as a sequence or copied to the output iterator. 679 680 681 \param Output An output iterator to which the result will be copied 682 \param Input An input string 683 \param N Length of the head. 684 For N>=0, at most N characters are extracted. 685 For N<0, size(Input)-|N| characters are extracted. 686 \return An output iterator pointing just after the last inserted character or 687 a modified copy of the input 688 689 \note The second variant of this function provides the strong exception-safety guarantee 690 */ 691 template< 692 typename OutputIteratorT, 693 typename RangeT> 694 inline OutputIteratorT erase_head_copy( 695 OutputIteratorT Output, 696 const RangeT& Input, 697 int N ) 698 { 699 return ::boost::algorithm::find_format_copy( 700 Output, 701 Input, 702 ::boost::algorithm::head_finder(N), 703 ::boost::algorithm::empty_formatter( Input ) ); 704 } 705 706 //! Erase head algorithm 707 /*! 708 \overload 709 */ 710 template<typename SequenceT> 711 inline SequenceT erase_head_copy( 712 const SequenceT& Input, 713 int N ) 714 { 715 return ::boost::algorithm::find_format_copy( 716 Input, 717 ::boost::algorithm::head_finder(N), 718 ::boost::algorithm::empty_formatter( Input ) ); 719 } 720 721 //! Erase head algorithm 722 /*! 723 Remove the head from the input. The head is a prefix of a sequence of given size. 724 If the sequence is shorter then required, the whole string is 725 considered to be the head. The input sequence is modified in-place. 726 727 \param Input An input string 728 \param N Length of the head 729 For N>=0, at most N characters are extracted. 730 For N<0, size(Input)-|N| characters are extracted. 731 */ 732 template<typename SequenceT> 733 inline void erase_head( 734 SequenceT& Input, 735 int N ) 736 { 737 ::boost::algorithm::find_format( 738 Input, 739 ::boost::algorithm::head_finder(N), 740 ::boost::algorithm::empty_formatter( Input ) ); 741 } 742 743// erase_tail --------------------------------------------------------------------// 744 745 //! Erase tail algorithm 746 /*! 747 Remove the tail from the input. The tail is a suffix of a sequence of given size. 748 If the sequence is shorter then required, the whole string is 749 considered to be the tail. 750 The result is a modified copy of the input. It is returned as a sequence 751 or copied to the output iterator. 752 753 \param Output An output iterator to which the result will be copied 754 \param Input An input string 755 \param N Length of the tail. 756 For N>=0, at most N characters are extracted. 757 For N<0, size(Input)-|N| characters are extracted. 758 \return An output iterator pointing just after the last inserted character or 759 a modified copy of the input 760 761 \note The second variant of this function provides the strong exception-safety guarantee 762 */ 763 template< 764 typename OutputIteratorT, 765 typename RangeT> 766 inline OutputIteratorT erase_tail_copy( 767 OutputIteratorT Output, 768 const RangeT& Input, 769 int N ) 770 { 771 return ::boost::algorithm::find_format_copy( 772 Output, 773 Input, 774 ::boost::algorithm::tail_finder(N), 775 ::boost::algorithm::empty_formatter( Input ) ); 776 } 777 778 //! Erase tail algorithm 779 /*! 780 \overload 781 */ 782 template<typename SequenceT> 783 inline SequenceT erase_tail_copy( 784 const SequenceT& Input, 785 int N ) 786 { 787 return ::boost::algorithm::find_format_copy( 788 Input, 789 ::boost::algorithm::tail_finder(N), 790 ::boost::algorithm::empty_formatter( Input ) ); 791 } 792 793 //! Erase tail algorithm 794 /*! 795 Remove the tail from the input. The tail is a suffix of a sequence of given size. 796 If the sequence is shorter then required, the whole string is 797 considered to be the tail. The input sequence is modified in-place. 798 799 \param Input An input string 800 \param N Length of the tail 801 For N>=0, at most N characters are extracted. 802 For N<0, size(Input)-|N| characters are extracted. 803 */ 804 template<typename SequenceT> 805 inline void erase_tail( 806 SequenceT& Input, 807 int N ) 808 { 809 ::boost::algorithm::find_format( 810 Input, 811 ::boost::algorithm::tail_finder(N), 812 ::boost::algorithm::empty_formatter( Input ) ); 813 } 814 815 } // namespace algorithm 816 817 // pull names into the boost namespace 818 using algorithm::erase_range_copy; 819 using algorithm::erase_range; 820 using algorithm::erase_first_copy; 821 using algorithm::erase_first; 822 using algorithm::ierase_first_copy; 823 using algorithm::ierase_first; 824 using algorithm::erase_last_copy; 825 using algorithm::erase_last; 826 using algorithm::ierase_last_copy; 827 using algorithm::ierase_last; 828 using algorithm::erase_nth_copy; 829 using algorithm::erase_nth; 830 using algorithm::ierase_nth_copy; 831 using algorithm::ierase_nth; 832 using algorithm::erase_all_copy; 833 using algorithm::erase_all; 834 using algorithm::ierase_all_copy; 835 using algorithm::ierase_all; 836 using algorithm::erase_head_copy; 837 using algorithm::erase_head; 838 using algorithm::erase_tail_copy; 839 using algorithm::erase_tail; 840 841} // namespace boost 842 843 844#endif // BOOST_ERASE_HPP