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_core.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
929