1 //  Boost string_algo library finder.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_FINDER_HPP
12 #define BOOST_STRING_FINDER_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/const_iterator.hpp>
21 
22 #include <boost/algorithm/string/constants.hpp>
23 #include <boost/algorithm/string/detail/finder.hpp>
24 #include <boost/algorithm/string/compare.hpp>
25 
26 /*! \file
27     Defines Finder generators. Finder object is a functor which is able to
28     find a substring matching a specific criteria in the input.
29     Finders are used as a pluggable components for replace, find
30     and split facilities. This header contains generator functions
31     for finders provided in this library.
32 */
33 
34 namespace boost {
35     namespace algorithm {
36 
37 //  Finder generators ------------------------------------------//
38 
39         //! "First" finder
40         /*!
41             Construct the \c first_finder. The finder searches for the first
42             occurrence of the string in a given input.
43             The result is given as an \c iterator_range delimiting the match.
44 
45             \param Search A substring to be searched for.
46             \param Comp An element comparison predicate
47             \return An instance of the \c first_finder object
48         */
49         template<typename RangeT>
50         inline detail::first_finderF<
51             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
52             is_equal>
first_finder(const RangeT & Search)53         first_finder( const RangeT& Search )
54         {
55             return
56                 detail::first_finderF<
57                     BOOST_STRING_TYPENAME
58                         range_const_iterator<RangeT>::type,
59                         is_equal>( ::boost::as_literal(Search), is_equal() ) ;
60         }
61 
62         //! "First" finder
63         /*!
64             \overload
65         */
66         template<typename RangeT,typename PredicateT>
67         inline detail::first_finderF<
68             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
69             PredicateT>
first_finder(const RangeT & Search,PredicateT Comp)70         first_finder(
71             const RangeT& Search, PredicateT Comp )
72         {
73             return
74                 detail::first_finderF<
75                     BOOST_STRING_TYPENAME
76                         range_const_iterator<RangeT>::type,
77                     PredicateT>( ::boost::as_literal(Search), Comp );
78         }
79 
80         //! "Last" finder
81         /*!
82             Construct the \c last_finder. The finder searches for the last
83             occurrence of the string in a given input.
84             The result is given as an \c iterator_range delimiting the match.
85 
86             \param Search A substring to be searched for.
87             \param Comp An element comparison predicate
88             \return An instance of the \c last_finder object
89         */
90         template<typename RangeT>
91         inline detail::last_finderF<
92             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
93             is_equal>
last_finder(const RangeT & Search)94         last_finder( const RangeT& Search )
95         {
96             return
97                 detail::last_finderF<
98                     BOOST_STRING_TYPENAME
99                         range_const_iterator<RangeT>::type,
100                     is_equal>( ::boost::as_literal(Search), is_equal() );
101         }
102         //! "Last" finder
103         /*!
104             \overload
105         */
106         template<typename RangeT, typename PredicateT>
107         inline detail::last_finderF<
108             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
109             PredicateT>
last_finder(const RangeT & Search,PredicateT Comp)110         last_finder( const RangeT& Search, PredicateT Comp )
111         {
112             return
113                 detail::last_finderF<
114                     BOOST_STRING_TYPENAME
115                         range_const_iterator<RangeT>::type,
116                     PredicateT>( ::boost::as_literal(Search), Comp ) ;
117         }
118 
119         //! "Nth" finder
120         /*!
121             Construct the \c nth_finder. The finder searches for the n-th (zero-indexed)
122             occurrence of the string in a given input.
123             The result is given as an \c iterator_range delimiting the match.
124 
125             \param Search A substring to be searched for.
126             \param Nth An index of the match to be find
127             \param Comp An element comparison predicate
128             \return An instance of the \c nth_finder object
129         */
130         template<typename RangeT>
131         inline detail::nth_finderF<
132             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
133             is_equal>
nth_finder(const RangeT & Search,int Nth)134         nth_finder(
135             const RangeT& Search,
136             int Nth)
137         {
138             return
139                 detail::nth_finderF<
140                     BOOST_STRING_TYPENAME
141                         range_const_iterator<RangeT>::type,
142                     is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
143         }
144         //! "Nth" finder
145         /*!
146             \overload
147         */
148         template<typename RangeT, typename PredicateT>
149         inline detail::nth_finderF<
150             BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
151             PredicateT>
nth_finder(const RangeT & Search,int Nth,PredicateT Comp)152         nth_finder(
153             const RangeT& Search,
154             int Nth,
155             PredicateT Comp )
156         {
157             return
158                 detail::nth_finderF<
159                     BOOST_STRING_TYPENAME
160                         range_const_iterator<RangeT>::type,
161                     PredicateT>( ::boost::as_literal(Search), Nth, Comp );
162         }
163 
164         //! "Head" finder
165         /*!
166             Construct the \c head_finder. The finder returns a head of a given
167             input. The head is a prefix of a string up to n elements in
168             size. If an input has less then n elements, whole input is
169             considered a head.
170             The result is given as an \c iterator_range delimiting the match.
171 
172             \param N The size of the head
173             \return An instance of the \c head_finder object
174         */
175         inline detail::head_finderF
head_finder(int N)176         head_finder( int N )
177         {
178             return detail::head_finderF(N);
179         }
180 
181         //! "Tail" finder
182         /*!
183             Construct the \c tail_finder. The finder returns a tail of a given
184             input. The tail is a suffix of a string up to n elements in
185             size. If an input has less then n elements, whole input is
186             considered a head.
187             The result is given as an \c iterator_range delimiting the match.
188 
189             \param N The size of the head
190             \return An instance of the \c tail_finder object
191         */
192         inline detail::tail_finderF
tail_finder(int N)193         tail_finder( int N )
194         {
195             return detail::tail_finderF(N);
196         }
197 
198         //! "Token" finder
199         /*!
200             Construct the \c token_finder. The finder searches for a token
201             specified by a predicate. It is similar to std::find_if
202             algorithm, with an exception that it return a range of
203             instead of a single iterator.
204 
205             If "compress token mode" is enabled, adjacent matching tokens are
206             concatenated into one match. Thus the finder can be used to
207             search for continuous segments of characters satisfying the
208             given predicate.
209 
210             The result is given as an \c iterator_range delimiting the match.
211 
212             \param Pred An element selection predicate
213             \param eCompress Compress flag
214             \return An instance of the \c token_finder object
215         */
216         template< typename PredicateT >
217         inline detail::token_finderF<PredicateT>
token_finder(PredicateT Pred,token_compress_mode_type eCompress=token_compress_off)218         token_finder(
219             PredicateT Pred,
220             token_compress_mode_type eCompress=token_compress_off )
221         {
222             return detail::token_finderF<PredicateT>( Pred, eCompress );
223         }
224 
225         //! "Range" finder
226         /*!
227             Construct the \c range_finder. The finder does not perform
228             any operation. It simply returns the given range for
229             any input.
230 
231             \param Begin Beginning of the range
232             \param End End of the range
233             \param Range The range.
234             \return An instance of the \c range_finger object
235         */
236         template< typename ForwardIteratorT >
237         inline detail::range_finderF<ForwardIteratorT>
range_finder(ForwardIteratorT Begin,ForwardIteratorT End)238         range_finder(
239             ForwardIteratorT Begin,
240             ForwardIteratorT End )
241         {
242             return detail::range_finderF<ForwardIteratorT>( Begin, End );
243         }
244 
245         //! "Range" finder
246         /*!
247             \overload
248         */
249         template< typename ForwardIteratorT >
250         inline detail::range_finderF<ForwardIteratorT>
range_finder(iterator_range<ForwardIteratorT> Range)251         range_finder( iterator_range<ForwardIteratorT> Range )
252         {
253             return detail::range_finderF<ForwardIteratorT>( Range );
254         }
255 
256     } // namespace algorithm
257 
258     // pull the names to the boost namespace
259     using algorithm::first_finder;
260     using algorithm::last_finder;
261     using algorithm::nth_finder;
262     using algorithm::head_finder;
263     using algorithm::tail_finder;
264     using algorithm::token_finder;
265     using algorithm::range_finder;
266 
267 } // namespace boost
268 
269 
270 #endif  // BOOST_STRING_FINDER_HPP
271