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

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