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 */
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 ::boost::algorithm::find_format(
413 Input,
414 ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
415 ::boost::algorithm::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 For negative N, matches are counted from the end of string.
432 \param Format A substitute string
433 \return An output iterator pointing just after the last inserted character or
434 a modified copy of the input
435
436 \note The second variant of this function provides the strong exception-safety guarantee
437 */
438 template<
439 typename OutputIteratorT,
440 typename Range1T,
441 typename Range2T,
442 typename Range3T>
443 inline OutputIteratorT replace_nth_copy(
444 OutputIteratorT Output,
445 const Range1T& Input,
446 const Range2T& Search,
447 int Nth,
448 const Range3T& Format )
449 {
450 return ::boost::algorithm::find_format_copy(
451 Output,
452 Input,
453 ::boost::algorithm::nth_finder(Search, Nth),
454 ::boost::algorithm::const_formatter(Format) );
455 }
456
457 //! Replace nth algorithm
458 /*!
459 \overload
460 */
461 template<typename SequenceT, typename Range1T, typename Range2T>
462 inline SequenceT replace_nth_copy(
463 const SequenceT& Input,
464 const Range1T& Search,
465 int Nth,
466 const Range2T& Format )
467 {
468 return ::boost::algorithm::find_format_copy(
469 Input,
470 ::boost::algorithm::nth_finder(Search, Nth),
471 ::boost::algorithm::const_formatter(Format) );
472 }
473
474 //! Replace nth algorithm
475 /*!
476 Replace an Nth (zero-indexed) match of the search string in the input
477 with the format string. Input sequence is modified in-place.
478
479 \param Input An input string
480 \param Search A substring to be searched for
481 \param Nth An index of the match to be replaced. The index is 0-based.
482 For negative N, matches are counted from the end of string.
483 \param Format A substitute string
484 */
485 template<typename SequenceT, typename Range1T, typename Range2T>
486 inline void replace_nth(
487 SequenceT& Input,
488 const Range1T& Search,
489 int Nth,
490 const Range2T& Format )
491 {
492 ::boost::algorithm::find_format(
493 Input,
494 ::boost::algorithm::nth_finder(Search, Nth),
495 ::boost::algorithm::const_formatter(Format) );
496 }
497
498// replace_nth ( case insensitive ) -----------------------------------------------//
499
500 //! Replace nth algorithm ( case insensitive )
501 /*!
502 Replace an Nth (zero-indexed) match of the search string in the input
503 with the format string.
504 The result is a modified copy of the input. It is returned as a sequence
505 or copied to the output iterator.
506 Searching is case insensitive.
507
508 \param Output An output iterator to which the result will be copied
509 \param Input An input string
510 \param Search A substring to be searched for
511 \param Nth An index of the match to be replaced. The index is 0-based.
512 For negative N, matches are counted from the end of string.
513 \param Format A substitute string
514 \param Loc A locale used for case insensitive comparison
515 \return An output iterator pointing just after the last inserted character or
516 a modified copy of the input
517
518 \note The second variant of this function provides the strong exception-safety guarantee
519 */
520 template<
521 typename OutputIteratorT,
522 typename Range1T,
523 typename Range2T,
524 typename Range3T>
525 inline OutputIteratorT ireplace_nth_copy(
526 OutputIteratorT Output,
527 const Range1T& Input,
528 const Range2T& Search,
529 int Nth,
530 const Range3T& Format,
531 const std::locale& Loc=std::locale() )
532 {
533 return ::boost::algorithm::find_format_copy(
534 Output,
535 Input,
536 ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
537 ::boost::algorithm::const_formatter(Format) );
538 }
539
540 //! Replace nth algorithm ( case insensitive )
541 /*!
542 \overload
543 */
544 template<typename SequenceT, typename Range1T, typename Range2T>
545 inline SequenceT ireplace_nth_copy(
546 const SequenceT& Input,
547 const Range1T& Search,
548 int Nth,
549 const Range2T& Format,
550 const std::locale& Loc=std::locale() )
551 {
552 return ::boost::algorithm::find_format_copy(
553 Input,
554 ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
555 ::boost::algorithm::const_formatter(Format) );
556 }
557
558 //! Replace nth algorithm ( case insensitive )
559 /*!
560 Replace an Nth (zero-indexed) match of the search string in the input
561 with the format string. Input sequence is modified in-place.
562 Searching is case insensitive.
563
564 \param Input An input string
565 \param Search A substring to be searched for
566 \param Nth An index of the match to be replaced. The index is 0-based.
567 For negative N, matches are counted from the end of string.
568 \param Format A substitute string
569 \param Loc A locale used for case insensitive comparison
570 */
571 template<typename SequenceT, typename Range1T, typename Range2T>
572 inline void ireplace_nth(
573 SequenceT& Input,
574 const Range1T& Search,
575 int Nth,
576 const Range2T& Format,
577 const std::locale& Loc=std::locale() )
578 {
579 ::boost::algorithm::find_format(
580 Input,
581 ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
582 ::boost::algorithm::const_formatter(Format) );
583 }
584
585// replace_all --------------------------------------------------------------------//
586
587 //! Replace all algorithm
588 /*!
589 Replace all occurrences of the search string in the input
590 with the format string.
591 The result is a modified copy of the input. It is returned as a sequence
592 or copied to the output iterator.
593
594 \param Output An output iterator to which the result will be copied
595 \param Input An input string
596 \param Search A substring to be searched for
597 \param Format A substitute string
598 \return An output iterator pointing just after the last inserted character or
599 a modified copy of the input
600
601 \note The second variant of this function provides the strong exception-safety guarantee
602 */
603 template<
604 typename OutputIteratorT,
605 typename Range1T,
606 typename Range2T,
607 typename Range3T>
608 inline OutputIteratorT replace_all_copy(
609 OutputIteratorT Output,
610 const Range1T& Input,
611 const Range2T& Search,
612 const Range3T& Format )
613 {
614 return ::boost::algorithm::find_format_all_copy(
615 Output,
616 Input,
617 ::boost::algorithm::first_finder(Search),
618 ::boost::algorithm::const_formatter(Format) );
619 }
620
621 //! Replace all algorithm
622 /*!
623 \overload
624 */
625 template<typename SequenceT, typename Range1T, typename Range2T>
626 inline SequenceT replace_all_copy(
627 const SequenceT& Input,
628 const Range1T& Search,
629 const Range2T& Format )
630 {
631 return ::boost::algorithm::find_format_all_copy(
632 Input,
633 ::boost::algorithm::first_finder(Search),
634 ::boost::algorithm::const_formatter(Format) );
635 }
636
637 //! Replace all algorithm
638 /*!
639 Replace all occurrences of the search string in the input
640 with the format string. The input sequence is modified in-place.
641
642 \param Input An input string
643 \param Search A substring to be searched for
644 \param Format A substitute string
645 */
646 template<typename SequenceT, typename Range1T, typename Range2T>
647 inline void replace_all(
648 SequenceT& Input,
649 const Range1T& Search,
650 const Range2T& Format )
651 {
652 ::boost::algorithm::find_format_all(
653 Input,
654 ::boost::algorithm::first_finder(Search),
655 ::boost::algorithm::const_formatter(Format) );
656 }
657
658// replace_all ( case insensitive ) -----------------------------------------------//
659
660 //! Replace all algorithm ( case insensitive )
661 /*!
662 Replace all occurrences of the search string in the input
663 with the format string.
664 The result is a modified copy of the input. It is returned as a sequence
665 or copied to the output iterator.
666 Searching is case insensitive.
667
668 \param Output An output iterator to which the result will be copied
669 \param Input An input string
670 \param Search A substring to be searched for
671 \param Format A substitute string
672 \param Loc A locale used for case insensitive comparison
673 \return An output iterator pointing just after the last inserted character or
674 a modified copy of the input
675
676 \note The second variant of this function provides the strong exception-safety guarantee
677 */
678 template<
679 typename OutputIteratorT,
680 typename Range1T,
681 typename Range2T,
682 typename Range3T>
683 inline OutputIteratorT ireplace_all_copy(
684 OutputIteratorT Output,
685 const Range1T& Input,
686 const Range2T& Search,
687 const Range3T& Format,
688 const std::locale& Loc=std::locale() )
689 {
690 return ::boost::algorithm::find_format_all_copy(
691 Output,
692 Input,
693 ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
694 ::boost::algorithm::const_formatter(Format) );
695 }
696
697 //! Replace all algorithm ( case insensitive )
698 /*!
699 \overload
700 */
701 template<typename SequenceT, typename Range1T, typename Range2T>
702 inline SequenceT ireplace_all_copy(
703 const SequenceT& Input,
704 const Range1T& Search,
705 const Range2T& Format,
706 const std::locale& Loc=std::locale() )
707 {
708 return ::boost::algorithm::find_format_all_copy(
709 Input,
710 ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
711 ::boost::algorithm::const_formatter(Format) );
712 }
713
714 //! Replace all algorithm ( case insensitive )
715 /*!
716 Replace all occurrences of the search string in the input
717 with the format string.The input sequence is modified in-place.
718 Searching is case insensitive.
719
720 \param Input An input string
721 \param Search A substring to be searched for
722 \param Format A substitute string
723 \param Loc A locale used for case insensitive comparison
724 */
725 template<typename SequenceT, typename Range1T, typename Range2T>
726 inline void ireplace_all(
727 SequenceT& Input,
728 const Range1T& Search,
729 const Range2T& Format,
730 const std::locale& Loc=std::locale() )
731 {
732 ::boost::algorithm::find_format_all(
733 Input,
734 ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
735 ::boost::algorithm::const_formatter(Format) );
736 }
737
738// replace_head --------------------------------------------------------------------//
739
740 //! Replace head algorithm
741 /*!
742 Replace the head of the input with the given format string.
743 The head is a prefix of a string of given size.
744 If the sequence is shorter then required, whole string if
745 considered to be the head.
746 The result is a modified copy of the input. It is returned as a sequence
747 or copied to the output iterator.
748
749 \param Output An output iterator to which the result will be copied
750 \param Input An input string
751 \param N Length of the head.
752 For N>=0, at most N characters are extracted.
753 For N<0, size(Input)-|N| characters are extracted.
754 \param Format A substitute string
755 \return An output iterator pointing just after the last inserted character or
756 a modified copy of the input
757
758 \note The second variant of this function provides the strong exception-safety guarantee
759 */
760 template<
761 typename OutputIteratorT,
762 typename Range1T,
763 typename Range2T>
764 inline OutputIteratorT replace_head_copy(
765 OutputIteratorT Output,
766 const Range1T& Input,
767 int N,
768 const Range2T& Format )
769 {
770 return ::boost::algorithm::find_format_copy(
771 Output,
772 Input,
773 ::boost::algorithm::head_finder(N),
774 ::boost::algorithm::const_formatter(Format) );
775 }
776
777 //! Replace head algorithm
778 /*!
779 \overload
780 */
781 template<typename SequenceT, typename RangeT>
782 inline SequenceT replace_head_copy(
783 const SequenceT& Input,
784 int N,
785 const RangeT& Format )
786 {
787 return ::boost::algorithm::find_format_copy(
788 Input,
789 ::boost::algorithm::head_finder(N),
790 ::boost::algorithm::const_formatter(Format) );
791 }
792
793 //! Replace head algorithm
794 /*!
795 Replace the head of the input with the given format string.
796 The head is a prefix of a string of given size.
797 If the sequence is shorter then required, the whole string is
798 considered to be the head. The input sequence is modified in-place.
799
800 \param Input An input string
801 \param N Length of the head.
802 For N>=0, at most N characters are extracted.
803 For N<0, size(Input)-|N| characters are extracted.
804 \param Format A substitute string
805 */
806 template<typename SequenceT, typename RangeT>
807 inline void replace_head(
808 SequenceT& Input,
809 int N,
810 const RangeT& Format )
811 {
812 ::boost::algorithm::find_format(
813 Input,
814 ::boost::algorithm::head_finder(N),
815 ::boost::algorithm::const_formatter(Format) );
816 }
817
818// replace_tail --------------------------------------------------------------------//
819
820 //! Replace tail algorithm
821 /*!
822 Replace the tail of the input with the given format string.
823 The tail is a suffix of a string of given size.
824 If the sequence is shorter then required, whole string is
825 considered to be the tail.
826 The result is a modified copy of the input. It is returned as a sequence
827 or copied to the output iterator.
828
829 \param Output An output iterator to which the result will be copied
830 \param Input An input string
831 \param N Length of the tail.
832 For N>=0, at most N characters are extracted.
833 For N<0, size(Input)-|N| characters are extracted.
834 \param Format A substitute string
835 \return An output iterator pointing just after the last inserted character or
836 a modified copy of the input
837
838 \note The second variant of this function provides the strong exception-safety guarantee
839 */
840 template<
841 typename OutputIteratorT,
842 typename Range1T,
843 typename Range2T>
844 inline OutputIteratorT replace_tail_copy(
845 OutputIteratorT Output,
846 const Range1T& Input,
847 int N,
848 const Range2T& Format )
849 {
850 return ::boost::algorithm::find_format_copy(
851 Output,
852 Input,
853 ::boost::algorithm::tail_finder(N),
854 ::boost::algorithm::const_formatter(Format) );
855 }
856
857 //! Replace tail algorithm
858 /*!
859 \overload
860 */
861 template<typename SequenceT, typename RangeT>
862 inline SequenceT replace_tail_copy(
863 const SequenceT& Input,
864 int N,
865 const RangeT& Format )
866 {
867 return ::boost::algorithm::find_format_copy(
868 Input,
869 ::boost::algorithm::tail_finder(N),
870 ::boost::algorithm::const_formatter(Format) );
871 }
872
873 //! Replace tail algorithm
874 /*!
875 Replace the tail of the input with the given format sequence.
876 The tail is a suffix of a string of given size.
877 If the sequence is shorter then required, the whole string is
878 considered to be the tail. The input sequence is modified in-place.
879
880 \param Input An input string
881 \param N Length of the tail.
882 For N>=0, at most N characters are extracted.
883 For N<0, size(Input)-|N| characters are extracted.
884 \param Format A substitute string
885 */
886 template<typename SequenceT, typename RangeT>
887 inline void replace_tail(
888 SequenceT& Input,
889 int N,
890 const RangeT& Format )
891 {
892 ::boost::algorithm::find_format(
893 Input,
894 ::boost::algorithm::tail_finder(N),
895 ::boost::algorithm::const_formatter(Format) );
896 }
897
898 } // namespace algorithm
899
900 // pull names to the boost namespace
901 using algorithm::replace_range_copy;
902 using algorithm::replace_range;
903 using algorithm::replace_first_copy;
904 using algorithm::replace_first;
905 using algorithm::ireplace_first_copy;
906 using algorithm::ireplace_first;
907 using algorithm::replace_last_copy;
908 using algorithm::replace_last;
909 using algorithm::ireplace_last_copy;
910 using algorithm::ireplace_last;
911 using algorithm::replace_nth_copy;
912 using algorithm::replace_nth;
913 using algorithm::ireplace_nth_copy;
914 using algorithm::ireplace_nth;
915 using algorithm::replace_all_copy;
916 using algorithm::replace_all;
917 using algorithm::ireplace_all_copy;
918 using algorithm::ireplace_all;
919 using algorithm::replace_head_copy;
920 using algorithm::replace_head;
921 using algorithm::replace_tail_copy;
922 using algorithm::replace_tail;
923
924} // namespace boost
925
926#endif // BOOST_REPLACE_HPP
927

source code of include/boost/algorithm/string/replace.hpp