← Back to branch summary

~ubuntu-branches/ubuntu/wily/bombono-dvd/wily

« back to all changes in this revision

Viewing changes to libs/boost-lib/boost/algorithm/string/replace.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-04 11:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20101104114625-8xfdhvhpsm51i0nu
Tags: upstream-0.8.0
Import upstream version 0.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/boost-lib/boost/algorithm/string/replace.hpp
 
1
//  Boost string_algo library replace.hpp header file  ---------------------------//
 
2
 
 
3
//  Copyright Pavol Droba 2002-2006.
 
4
//
 
5
// Distributed under the Boost Software License, Version 1.0.
 
6
//    (See accompanying file LICENSE_1_0.txt or copy at
 
7
//          http://www.boost.org/LICENSE_1_0.txt)
 
8
 
 
9
//  See http://www.boost.org/ for updates, documentation, and revision history.
 
10
 
 
11
#ifndef BOOST_STRING_REPLACE_HPP
 
12
#define BOOST_STRING_REPLACE_HPP
 
13
 
 
14
#include <boost/algorithm/string/config.hpp>
 
15
 
 
16
#include <boost/range/iterator_range.hpp>
 
17
#include <boost/range/begin.hpp>
 
18
#include <boost/range/end.hpp>
 
19
#include <boost/range/iterator.hpp>
 
20
#include <boost/range/const_iterator.hpp>
 
21
 
 
22
#include <boost/algorithm/string/find_format.hpp>
 
23
#include <boost/algorithm/string/finder.hpp>
 
24
#include <boost/algorithm/string/formatter.hpp>
 
25
#include <boost/algorithm/string/compare.hpp>
 
26
 
 
27
/*! \file
 
28
    Defines various replace algorithms. Each algorithm replaces
 
29
    part(s) of the input according to set of searching and replace criteria.
 
30
*/
 
31
 
 
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
            \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