]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost string_algo library find.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_HPP | |
12 | #define BOOST_STRING_FIND_HPP | |
13 | ||
14 | #include <boost/algorithm/string/config.hpp> | |
15 | ||
16 | #include <boost/range/iterator_range_core.hpp> | |
17 | #include <boost/range/begin.hpp> | |
18 | #include <boost/range/end.hpp> | |
19 | #include <boost/range/iterator.hpp> | |
20 | #include <boost/range/as_literal.hpp> | |
21 | ||
22 | #include <boost/algorithm/string/finder.hpp> | |
23 | #include <boost/algorithm/string/compare.hpp> | |
24 | #include <boost/algorithm/string/constants.hpp> | |
25 | ||
26 | /*! \file | |
27 | Defines a set of find algorithms. The algorithms are searching | |
28 | for a substring of the input. The result is given as an \c iterator_range | |
29 | delimiting the substring. | |
30 | */ | |
31 | ||
32 | namespace boost { | |
33 | namespace algorithm { | |
34 | ||
35 | // Generic find -----------------------------------------------// | |
36 | ||
37 | //! Generic find algorithm | |
38 | /*! | |
39 | Search the input using the given finder. | |
40 | ||
41 | \param Input A string which will be searched. | |
42 | \param Finder Finder object used for searching. | |
43 | \return | |
44 | An \c iterator_range delimiting the match. | |
45 | Returned iterator is either \c RangeT::iterator or | |
46 | \c RangeT::const_iterator, depending on the constness of | |
47 | the input parameter. | |
48 | */ | |
49 | template<typename RangeT, typename FinderT> | |
50 | inline iterator_range< | |
51 | BOOST_STRING_TYPENAME range_iterator<RangeT>::type> | |
52 | find( | |
53 | RangeT& Input, | |
54 | const FinderT& Finder) | |
55 | { | |
56 | iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); | |
57 | ||
58 | return Finder(::boost::begin(lit_input),::boost::end(lit_input)); | |
59 | } | |
60 | ||
61 | // find_first -----------------------------------------------// | |
62 | ||
63 | //! Find first algorithm | |
64 | /*! | |
65 | Search for the first occurrence of the substring in the input. | |
66 | ||
67 | \param Input A string which will be searched. | |
68 | \param Search A substring to be searched for. | |
69 | \return | |
70 | An \c iterator_range delimiting the match. | |
71 | Returned iterator is either \c RangeT::iterator or | |
72 | \c RangeT::const_iterator, depending on the constness of | |
73 | the input parameter. | |
74 | ||
75 | \note This function provides the strong exception-safety guarantee | |
76 | */ | |
77 | template<typename Range1T, typename Range2T> | |
78 | inline iterator_range< | |
79 | BOOST_STRING_TYPENAME range_iterator<Range1T>::type> | |
80 | find_first( | |
81 | Range1T& Input, | |
82 | const Range2T& Search) | |
83 | { | |
84 | return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search)); | |
85 | } | |
86 | ||
87 | //! Find first algorithm ( case insensitive ) | |
88 | /*! | |
89 | Search for the first occurrence of the substring in the input. | |
90 | Searching is case insensitive. | |
91 | ||
92 | \param Input A string which will be searched. | |
93 | \param Search A substring to be searched for. | |
94 | \param Loc A locale used for case insensitive comparison | |
95 | \return | |
96 | An \c iterator_range delimiting the match. | |
97 | Returned iterator is either \c Range1T::iterator or | |
98 | \c Range1T::const_iterator, depending on the constness of | |
99 | the input parameter. | |
100 | ||
101 | \note This function provides the strong exception-safety guarantee | |
102 | */ | |
103 | template<typename Range1T, typename Range2T> | |
104 | inline iterator_range< | |
105 | BOOST_STRING_TYPENAME range_iterator<Range1T>::type> | |
106 | ifind_first( | |
107 | Range1T& Input, | |
108 | const Range2T& Search, | |
109 | const std::locale& Loc=std::locale()) | |
110 | { | |
111 | return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc))); | |
112 | } | |
113 | ||
114 | // find_last -----------------------------------------------// | |
115 | ||
116 | //! Find last algorithm | |
117 | /*! | |
118 | Search for the last occurrence of the substring in the input. | |
119 | ||
120 | \param Input A string which will be searched. | |
121 | \param Search A substring to be searched for. | |
122 | \return | |
123 | An \c iterator_range delimiting the match. | |
124 | Returned iterator is either \c Range1T::iterator or | |
125 | \c Range1T::const_iterator, depending on the constness of | |
126 | the input parameter. | |
127 | ||
128 | \note This function provides the strong exception-safety guarantee | |
129 | */ | |
130 | template<typename Range1T, typename Range2T> | |
131 | inline iterator_range< | |
132 | BOOST_STRING_TYPENAME range_iterator<Range1T>::type> | |
133 | find_last( | |
134 | Range1T& Input, | |
135 | const Range2T& Search) | |
136 | { | |
137 | return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search)); | |
138 | } | |
139 | ||
140 | //! Find last algorithm ( case insensitive ) | |
141 | /*! | |
142 | Search for the last match a string in the input. | |
143 | Searching is case insensitive. | |
144 | ||
145 | \param Input A string which will be searched. | |
146 | \param Search A substring to be searched for. | |
147 | \param Loc A locale used for case insensitive comparison | |
148 | \return | |
149 | An \c iterator_range delimiting the match. | |
150 | Returned iterator is either \c Range1T::iterator or | |
151 | \c Range1T::const_iterator, depending on the constness of | |
152 | the input parameter. | |
153 | ||
154 | \note This function provides the strong exception-safety guarantee | |
155 | */ | |
156 | template<typename Range1T, typename Range2T> | |
157 | inline iterator_range< | |
158 | BOOST_STRING_TYPENAME range_iterator<Range1T>::type> | |
159 | ifind_last( | |
160 | Range1T& Input, | |
161 | const Range2T& Search, | |
162 | const std::locale& Loc=std::locale()) | |
163 | { | |
164 | return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc))); | |
165 | } | |
166 | ||
167 | // find_nth ----------------------------------------------------------------------// | |
168 | ||
169 | //! Find n-th algorithm | |
170 | /*! | |
171 | Search for the n-th (zero-indexed) occurrence of the substring in the | |
172 | input. | |
173 | ||
174 | \param Input A string which will be searched. | |
175 | \param Search A substring to be searched for. | |
176 | \param Nth An index (zero-indexed) of the match to be found. | |
177 | For negative N, the matches are counted from the end of string. | |
178 | \return | |
179 | An \c iterator_range delimiting the match. | |
180 | Returned iterator is either \c Range1T::iterator or | |
181 | \c Range1T::const_iterator, depending on the constness of | |
182 | the input parameter. | |
183 | */ | |
184 | template<typename Range1T, typename Range2T> | |
185 | inline iterator_range< | |
186 | BOOST_STRING_TYPENAME range_iterator<Range1T>::type> | |
187 | find_nth( | |
188 | Range1T& Input, | |
189 | const Range2T& Search, | |
190 | int Nth) | |
191 | { | |
192 | return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth)); | |
193 | } | |
194 | ||
195 | //! Find n-th algorithm ( case insensitive ). | |
196 | /*! | |
197 | Search for the n-th (zero-indexed) occurrence of the substring in the | |
198 | input. Searching is case insensitive. | |
199 | ||
200 | \param Input A string which will be searched. | |
201 | \param Search A substring to be searched for. | |
202 | \param Nth An index (zero-indexed) of the match to be found. | |
203 | For negative N, the matches are counted from the end of string. | |
204 | \param Loc A locale used for case insensitive comparison | |
205 | \return | |
206 | An \c iterator_range delimiting the match. | |
207 | Returned iterator is either \c Range1T::iterator or | |
208 | \c Range1T::const_iterator, depending on the constness of | |
209 | the input parameter. | |
210 | ||
211 | ||
212 | \note This function provides the strong exception-safety guarantee | |
213 | */ | |
214 | template<typename Range1T, typename Range2T> | |
215 | inline iterator_range< | |
216 | BOOST_STRING_TYPENAME range_iterator<Range1T>::type> | |
217 | ifind_nth( | |
218 | Range1T& Input, | |
219 | const Range2T& Search, | |
220 | int Nth, | |
221 | const std::locale& Loc=std::locale()) | |
222 | { | |
223 | return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc))); | |
224 | } | |
225 | ||
226 | // find_head ----------------------------------------------------------------------// | |
227 | ||
228 | //! Find head algorithm | |
229 | /*! | |
230 | Get the head of the input. Head is a prefix of the string of the | |
231 | given size. If the input is shorter then required, whole input is considered | |
232 | to be the head. | |
233 | ||
234 | \param Input An input string | |
235 | \param N Length of the head | |
236 | For N>=0, at most N characters are extracted. | |
237 | For N<0, at most size(Input)-|N| characters are extracted. | |
238 | \return | |
239 | An \c iterator_range delimiting the match. | |
240 | Returned iterator is either \c Range1T::iterator or | |
241 | \c Range1T::const_iterator, depending on the constness of | |
242 | the input parameter. | |
243 | ||
244 | \note This function provides the strong exception-safety guarantee | |
245 | */ | |
246 | template<typename RangeT> | |
247 | inline iterator_range< | |
248 | BOOST_STRING_TYPENAME range_iterator<RangeT>::type> | |
249 | find_head( | |
250 | RangeT& Input, | |
251 | int N) | |
252 | { | |
253 | return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N)); | |
254 | } | |
255 | ||
256 | // find_tail ----------------------------------------------------------------------// | |
257 | ||
258 | //! Find tail algorithm | |
259 | /*! | |
260 | Get the tail of the input. Tail is a suffix of the string of the | |
261 | given size. If the input is shorter then required, whole input is considered | |
262 | to be the tail. | |
263 | ||
264 | \param Input An input string | |
265 | \param N Length of the tail. | |
266 | For N>=0, at most N characters are extracted. | |
267 | For N<0, at most size(Input)-|N| characters are extracted. | |
268 | \return | |
269 | An \c iterator_range delimiting the match. | |
270 | Returned iterator is either \c RangeT::iterator or | |
271 | \c RangeT::const_iterator, depending on the constness of | |
272 | the input parameter. | |
273 | ||
274 | ||
275 | \note This function provides the strong exception-safety guarantee | |
276 | */ | |
277 | template<typename RangeT> | |
278 | inline iterator_range< | |
279 | BOOST_STRING_TYPENAME range_iterator<RangeT>::type> | |
280 | find_tail( | |
281 | RangeT& Input, | |
282 | int N) | |
283 | { | |
284 | return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N)); | |
285 | } | |
286 | ||
287 | // find_token --------------------------------------------------------------------// | |
288 | ||
289 | //! Find token algorithm | |
290 | /*! | |
291 | Look for a given token in the string. Token is a character that matches the | |
292 | given predicate. | |
293 | If the "token compress mode" is enabled, adjacent tokens are considered to be one match. | |
294 | ||
295 | \param Input A input string. | |
296 | \param Pred A unary predicate to identify a token | |
297 | \param eCompress Enable/Disable compressing of adjacent tokens | |
298 | \return | |
299 | An \c iterator_range delimiting the match. | |
300 | Returned iterator is either \c RangeT::iterator or | |
301 | \c RangeT::const_iterator, depending on the constness of | |
302 | the input parameter. | |
303 | ||
304 | \note This function provides the strong exception-safety guarantee | |
305 | */ | |
306 | template<typename RangeT, typename PredicateT> | |
307 | inline iterator_range< | |
308 | BOOST_STRING_TYPENAME range_iterator<RangeT>::type> | |
309 | find_token( | |
310 | RangeT& Input, | |
311 | PredicateT Pred, | |
312 | token_compress_mode_type eCompress=token_compress_off) | |
313 | { | |
314 | return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress)); | |
315 | } | |
316 | ||
317 | } // namespace algorithm | |
318 | ||
319 | // pull names to the boost namespace | |
320 | using algorithm::find; | |
321 | using algorithm::find_first; | |
322 | using algorithm::ifind_first; | |
323 | using algorithm::find_last; | |
324 | using algorithm::ifind_last; | |
325 | using algorithm::find_nth; | |
326 | using algorithm::ifind_nth; | |
327 | using algorithm::find_head; | |
328 | using algorithm::find_tail; | |
329 | using algorithm::find_token; | |
330 | ||
331 | } // namespace boost | |
332 | ||
333 | ||
334 | #endif // BOOST_STRING_FIND_HPP |