Statistics
| Revision:

root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / algorithm / string / find_format.hpp @ 2486

History | View | Annotate | Download (10 kB)

1
//  Boost string_algo library find_format.hpp header file  ---------------------------//
2

    
3
//  Copyright Pavol Droba 2002-2003.
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_FIND_FORMAT_HPP
12
#define BOOST_STRING_FIND_FORMAT_HPP
13

    
14
#include <deque>
15
#include <boost/detail/iterator.hpp>
16
#include <boost/range/iterator_range_core.hpp>
17
#include <boost/range/begin.hpp>
18
#include <boost/range/end.hpp>
19
#include <boost/range/const_iterator.hpp>
20
#include <boost/range/as_literal.hpp>
21

    
22
#include <boost/algorithm/string/concept.hpp>
23
#include <boost/algorithm/string/detail/find_format.hpp>
24
#include <boost/algorithm/string/detail/find_format_all.hpp>
25

    
26
/*! \file
27
    Defines generic replace algorithms. Each algorithm replaces
28
    part(s) of the input. The part to be replaced is looked up using a Finder object.
29
    Result of finding is then used by a Formatter object to generate the replacement.
30
*/
31

    
32
namespace boost {
33
    namespace algorithm {
34

    
35
// generic replace  -----------------------------------------------------------------//
36

    
37
        //! Generic replace algorithm
38
        /*!
39
            Use the Finder to search for a substring. Use the Formatter to format
40
            this substring and replace it in the input.
41
            The result is a modified copy of the input. It is returned as a sequence 
42
            or copied to the output iterator.
43
    
44
            \param Output An output iterator to which the result will be copied
45
            \param Input An input sequence
46
            \param Finder A Finder object used to search for a match to be replaced
47
            \param Formatter A Formatter object used to format a match
48
            \return An output iterator pointing just after the last inserted character or
49
                a modified copy of the input
50

51
            \note The second variant of this function provides the strong exception-safety guarantee
52
        */
53
        template< 
54
            typename OutputIteratorT,
55
            typename RangeT,
56
            typename FinderT,
57
            typename FormatterT>
58
        inline OutputIteratorT find_format_copy(
59
            OutputIteratorT Output,
60
            const RangeT& Input,
61
            FinderT Finder,
62
            FormatterT Formatter )
63
        {
64
            // Concept check
65
            BOOST_CONCEPT_ASSERT((
66
                FinderConcept<
67
                    FinderT,
68
                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
69
                ));
70
            BOOST_CONCEPT_ASSERT((
71
                FormatterConcept<
72
                    FormatterT,
73
                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
74
                ));
75

    
76
            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
77

    
78
            return detail::find_format_copy_impl(
79
                Output,
80
                lit_input,
81
                Formatter,
82
                Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
83
        }
84

    
85
        //! Generic replace algorithm
86
        /*!
87
            \overload
88
        */
89
        template< 
90
            typename SequenceT, 
91
            typename FinderT,
92
            typename FormatterT>
93
        inline SequenceT find_format_copy(
94
            const SequenceT& Input,
95
            FinderT Finder,
96
            FormatterT Formatter )
97
        {
98
            // Concept check
99
            BOOST_CONCEPT_ASSERT((
100
                FinderConcept<
101
                    FinderT,
102
                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
103
                ));
104
            BOOST_CONCEPT_ASSERT((
105
                FormatterConcept<
106
                    FormatterT,
107
                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
108
                ));
109

    
110
            return detail::find_format_copy_impl(
111
                Input,
112
                Formatter,
113
                Finder(::boost::begin(Input), ::boost::end(Input)));
114
        }
115

    
116
        //! Generic replace algorithm
117
        /*!
118
            Use the Finder to search for a substring. Use the Formatter to format
119
            this substring and replace it in the input. The input is modified in-place.
120

121
            \param Input An input sequence
122
            \param Finder A Finder object used to search for a match to be replaced
123
            \param Formatter A Formatter object used to format a match
124
        */
125
        template<
126
            typename SequenceT,
127
            typename FinderT,
128
            typename FormatterT>
129
        inline void find_format( 
130
            SequenceT& Input,
131
            FinderT Finder,
132
            FormatterT Formatter)
133
        {
134
            // Concept check
135
            BOOST_CONCEPT_ASSERT((
136
                FinderConcept<
137
                    FinderT,
138
                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
139
                ));
140
            BOOST_CONCEPT_ASSERT(( 
141
                FormatterConcept<
142
                    FormatterT,
143
                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
144
                ));
145

    
146
            detail::find_format_impl(
147
                Input,
148
                Formatter,
149
                Finder(::boost::begin(Input), ::boost::end(Input)));
150
        }
151

    
152

    
153
//  find_format_all generic ----------------------------------------------------------------//
154

    
155
        //! Generic replace all algorithm
156
        /*!
157
            Use the Finder to search for a substring. Use the Formatter to format
158
            this substring and replace it in the input. Repeat this for all matching
159
            substrings.
160
            The result is a modified copy of the input. It is returned as a sequence 
161
            or copied to the output iterator.
162

163
            \param Output An output iterator to which the result will be copied
164
            \param Input An input sequence
165
            \param Finder A Finder object used to search for a match to be replaced
166
            \param Formatter A Formatter object used to format a match
167
            \return An output iterator pointing just after the last inserted character or
168
                a modified copy of the input
169

170
             \note The second variant of this function provides the strong exception-safety guarantee
171
        */
172
        template< 
173
            typename OutputIteratorT,
174
            typename RangeT,
175
            typename FinderT,
176
            typename FormatterT>
177
        inline OutputIteratorT find_format_all_copy(
178
            OutputIteratorT Output,
179
            const RangeT& Input,
180
            FinderT Finder,
181
            FormatterT Formatter)
182
        {
183
            // Concept check
184
            BOOST_CONCEPT_ASSERT(( 
185
                FinderConcept<
186
                    FinderT,
187
                    BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
188
                ));
189
            BOOST_CONCEPT_ASSERT(( 
190
                FormatterConcept<
191
                    FormatterT,
192
                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
193
                ));
194

    
195
            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
196

    
197
            return detail::find_format_all_copy_impl(
198
                Output,
199
                lit_input,
200
                Finder,
201
                Formatter,
202
                Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
203
        }
204

    
205
        //! Generic replace all algorithm
206
        /*!
207
            \overload
208
        */
209
        template< 
210
            typename SequenceT, 
211
            typename FinderT,
212
            typename FormatterT >
213
        inline SequenceT find_format_all_copy(
214
            const SequenceT& Input,
215
            FinderT Finder,
216
            FormatterT Formatter )
217
        {
218
            // Concept check
219
            BOOST_CONCEPT_ASSERT((
220
                FinderConcept<
221
                    FinderT,
222
                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
223
                ));
224
            BOOST_CONCEPT_ASSERT((
225
                FormatterConcept<
226
                    FormatterT,
227
                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
228
                ));
229

    
230
            return detail::find_format_all_copy_impl(
231
                Input,
232
                Finder,
233
                Formatter,
234
                Finder( ::boost::begin(Input), ::boost::end(Input) ) );
235
        }
236

    
237
        //! Generic replace all algorithm
238
        /*!
239
            Use the Finder to search for a substring. Use the Formatter to format
240
            this substring and replace it in the input. Repeat this for all matching
241
            substrings.The input is modified in-place.
242

243
            \param Input An input sequence
244
            \param Finder A Finder object used to search for a match to be replaced
245
            \param Formatter A Formatter object used to format a match
246
        */
247
        template<
248
            typename SequenceT,
249
            typename FinderT,
250
            typename FormatterT >
251
        inline void find_format_all( 
252
            SequenceT& Input,
253
            FinderT Finder,
254
            FormatterT Formatter )
255
        {
256
            // Concept check
257
            BOOST_CONCEPT_ASSERT((
258
                FinderConcept<
259
                    FinderT,
260
                    BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
261
                ));
262
            BOOST_CONCEPT_ASSERT((
263
                FormatterConcept<
264
                    FormatterT,
265
                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
266
                ));
267

    
268
            detail::find_format_all_impl(
269
                Input,
270
                Finder,
271
                Formatter,
272
                Finder(::boost::begin(Input), ::boost::end(Input)));
273

    
274
        }
275

    
276
    } // namespace algorithm
277

    
278
    // pull the names to the boost namespace
279
    using algorithm::find_format_copy;
280
    using algorithm::find_format;
281
    using algorithm::find_format_all_copy;
282
    using algorithm::find_format_all;
283

    
284
} // namespace boost
285

    
286

    
287
#endif  // BOOST_STRING_FIND_FORMAT_HPP