l4/pkg/boost-lite/include/boost/algorithm/string/erase.hpp

   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
  31 namespace 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 find_format_copy(
  58                 Output,
  59                 Input,
  60                 range_finder(SearchRange),
  61                 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 find_format_copy(
  76                 Input,
  77                 range_finder(SearchRange),
  78                 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             find_format(
  97                 Input,
  98                 range_finder(SearchRange),
  99                 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 find_format_copy(
 128                 Output,
 129                 Input,
 130                 first_finder(Search),
 131                 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 find_format_copy(
 144                 Input,
 145                 first_finder(Search),
 146                 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             find_format(
 163                 Input,
 164                 first_finder(Search),
 165                 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 find_format_copy(
 197                 Output,
 198                 Input,
 199                 first_finder(Search, is_iequal(Loc)),
 200                 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 find_format_copy(
 214                 Input,
 215                 first_finder(Search, is_iequal(Loc)),
 216                 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             find_format(
 235                 Input,
 236                 first_finder(Search, is_iequal(Loc)),
 237                 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 find_format_copy(
 266                 Output,
 267                 Input,
 268                 last_finder(Search),
 269                 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 find_format_copy(
 282                 Input,
 283                 last_finder(Search),
 284                 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             find_format(
 301                 Input,
 302                 last_finder(Search),
 303                 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 find_format_copy(
 335                 Output,
 336                 Input,
 337                 last_finder(Search, is_iequal(Loc)),
 338                 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 find_format_copy(
 352                 Input,
 353                 last_finder(Search, is_iequal(Loc)),
 354                 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             find_format(
 373                 Input,
 374                 last_finder(Search, is_iequal(Loc)),
 375                 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 find_format_copy(
 408                 Output,
 409                 Input,
 410                 nth_finder(Search, Nth),
 411                 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 find_format_copy(
 425                 Input,
 426                 nth_finder(Search, Nth),
 427                 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             find_format(
 447                 Input,
 448                 nth_finder(Search, Nth),
 449                 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 find_format_copy(
 484                 Output,
 485                 Input,
 486                 nth_finder(Search, Nth, is_iequal(Loc)),
 487                 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 find_format_copy(
 502                 Input,
 503                 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             find_format(
 526                 Input,
 527                 nth_finder(Search, Nth, is_iequal(Loc)),
 528                 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 find_format_all_copy(
 559                 Output,
 560                 Input,
 561                 first_finder(Search),
 562                 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 find_format_all_copy(
 575                 Input,
 576                 first_finder(Search),
 577                 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             find_format_all(
 594                 Input,
 595                 first_finder(Search),
 596                 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 find_format_all_copy(
 628                 Output,
 629                 Input,
 630                 first_finder(Search, is_iequal(Loc)),
 631                 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 find_format_all_copy(
 645                 Input,
 646                 first_finder(Search, is_iequal(Loc)),
 647                 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             find_format_all(
 666                 Input,
 667                 first_finder(Search, is_iequal(Loc)),
 668                 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 find_format_copy(
 700                 Output,
 701                 Input,
 702                 head_finder(N),
 703                 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 find_format_copy(
 716                 Input,
 717                 head_finder(N),
 718                 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             find_format(
 738                 Input,
 739                 head_finder(N),
 740                 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 head.
 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 find_format_copy(
 772                 Output,
 773                 Input,
 774                 tail_finder(N),
 775                 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 find_format_copy(
 788                 Input,
 789                 tail_finder(N),
 790                 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 head
 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             find_format(
 810                 Input,
 811                 tail_finder(N),
 812                 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