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