Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_33_1/boost/algorithm/string/replace.hpp @ 12

Last change on this file since 12 was 12, checked in by landauf, 17 years ago
added boost
File size: 32.6 KB

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

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

Download in other formats: