source: NonGTP/Boost/boost/algorithm/string/erase.hpp @ 857

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