root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / algorithm / string / erase.hpp @ 2486
History  View  Annotate  Download (31.1 kB)
1 
// Boost string_algo library erase.hpp header file //


2  
3 
// Copyright Pavol Droba 20022006.

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 exceptionsafety 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 inplace.

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 exceptionsafety 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 inplace.

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 exceptionsafety 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 inplace. 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 exceptionsafety 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 inplace.

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 exceptionsafety 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 inplace. 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 0based.

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 exceptionsafety 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 inplace.

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 0based.

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 0based.

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 exceptionsafety 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 inplace. 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 0based.

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 exceptionsafety 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 inplace.

584 

585 
\param Input An input string

586 
\param Search A substring to be searched for.

587 
*/

588 
template<typename SequenceT, typename RangeT> 
589 
inline void erase_all( 
590 
SequenceT& Input, 
591 
const RangeT& Search )

592 
{ 
593 
::boost::algorithm::find_format_all( 
594 
Input, 
595 
::boost::algorithm::first_finder(Search), 
596 
::boost::algorithm::empty_formatter(Input) ); 
597 
} 
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 exceptionsafety 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 inplace. 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 exceptionsafety 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 inplace.

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 exceptionsafety 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 
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 
::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 inplace.

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 