Line data Source code
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 :
32 : namespace 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 562 : 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 562 : ::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 0 : inline void replace_all(
648 : SequenceT& Input,
649 : const Range1T& Search,
650 : const Range2T& Format )
651 : {
652 0 : ::boost::algorithm::find_format_all(
653 : Input,
654 : ::boost::algorithm::first_finder(Search),
655 : ::boost::algorithm::const_formatter(Format) );
656 0 : }
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 0 : 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 0 : ::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
|
