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.

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

Context Navigation

source: vendors/XIOS/current/extern/boost/include/boost/algorithm/string/replace.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: 35.2 KB

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

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

Download in other formats: