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