New URL for NEMO forge! http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.

erase.hpp in vendors/XIOS/current/extern/boost/include/boost/algorithm/string – NEMO

Context Navigation

source: vendors/XIOS/current/extern/boost/include/boost/algorithm/string/erase.hpp @ 3408

Last change on this file since 3408 was 3408, checked in by rblod, 12 years ago
importing initial XIOS vendor drop
Property svn:keywords set to `Id`
File size: 31.1 KB

Line
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.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	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 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	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 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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: