PageRenderTime 104ms CodeModel.GetById 15ms app.highlight 80ms RepoModel.GetById 1ms app.codeStats 0ms

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

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