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> find(RangeT & Input,const FinderT & Finder)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> find_first(Range1T & Input,const Range2T & Search)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> ifind_first(Range1T & Input,const Range2T & Search,const std::locale & Loc=std::locale ())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> find_last(Range1T & Input,const Range2T & Search)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> ifind_last(Range1T & Input,const Range2T & Search,const std::locale & Loc=std::locale ())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> find_nth(Range1T & Input,const Range2T & Search,int Nth)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> ifind_nth(Range1T & Input,const Range2T & Search,int Nth,const std::locale & Loc=std::locale ())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> find_head(RangeT & Input,int N)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> find_tail(RangeT & Input,int N)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> find_token(RangeT & Input,PredicateT Pred,token_compress_mode_type eCompress=token_compress_off)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 335