Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / algorithm / string / replace.hpp
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
31 namespace 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