l4/pkg/boost-lite/include/boost/algorithm/string/finder.hpp

   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.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>
  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>( 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>
  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>( 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>
  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>( 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>
 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>( 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>
 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>( 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>
 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>( 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
 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
 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>
 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>
 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>
 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