PageRenderTime 89ms CodeModel.GetById 41ms app.highlight 42ms RepoModel.GetById 1ms app.codeStats 1ms

/Src/Dependencies/Boost/boost/algorithm/string/erase.hpp

http://hadesmem.googlecode.com/
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