// Boost string_algo library find.hpp header file ---------------------------//

// Copyright Pavol Droba 2002-2003.

//

// Distributed under the Boost Software License, Version 1.0.

// (See accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

// See http://www.boost.org/ for updates, documentation, and revision history.

#ifndef BOOST_STRING_FIND_HPP

#define BOOST_STRING_FIND_HPP

#include <boost/algorithm/string/config.hpp>

#include <boost/range/iterator_range_core.hpp>

#include <boost/range/begin.hpp>

#include <boost/range/end.hpp>

#include <boost/range/iterator.hpp>

#include <boost/range/as_literal.hpp>

#include <boost/algorithm/string/finder.hpp>

#include <boost/algorithm/string/compare.hpp>

#include <boost/algorithm/string/constants.hpp>

/*! \file

Defines a set of find algorithms. The algorithms are searching

for a substring of the input. The result is given as an \c iterator_range

delimiting the substring.

*/

namespace boost {

namespace algorithm {

// Generic find -----------------------------------------------//

//! Generic find algorithm

/*!

Search the input using the given finder.

\param Input A string which will be searched.

\param Finder Finder object used for searching.

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c RangeT::iterator or

\c RangeT::const_iterator, depending on the constness of

the input parameter.

*/

template<typename RangeT, typename FinderT>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<RangeT>::type>

find(

RangeT& Input,

const FinderT& Finder)

{

iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

return Finder(::boost::begin(lit_input),::boost::end(lit_input));

}

// find_first -----------------------------------------------//

//! Find first algorithm

/*!

Search for the first occurrence of the substring in the input.

\param Input A string which will be searched.

\param Search A substring to be searched for.

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c RangeT::iterator or

\c RangeT::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename Range1T, typename Range2T>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<Range1T>::type>

find_first(

Range1T& Input,

const Range2T& Search)

{

return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));

}

//! Find first algorithm ( case insensitive )

/*!

Search for the first occurrence of the substring in the input.

Searching is case insensitive.

\param Input A string which will be searched.

\param Search A substring to be searched for.

\param Loc A locale used for case insensitive comparison

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c Range1T::iterator or

\c Range1T::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename Range1T, typename Range2T>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<Range1T>::type>

ifind_first(

Range1T& Input,

const Range2T& Search,

const std::locale& Loc=std::locale())

{

return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));

}

// find_last -----------------------------------------------//

//! Find last algorithm

/*!

Search for the last occurrence of the substring in the input.

\param Input A string which will be searched.

\param Search A substring to be searched for.

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c Range1T::iterator or

\c Range1T::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename Range1T, typename Range2T>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<Range1T>::type>

find_last(

Range1T& Input,

const Range2T& Search)

{

return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));

}

//! Find last algorithm ( case insensitive )

/*!

Search for the last match a string in the input.

Searching is case insensitive.

\param Input A string which will be searched.

\param Search A substring to be searched for.

\param Loc A locale used for case insensitive comparison

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c Range1T::iterator or

\c Range1T::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename Range1T, typename Range2T>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<Range1T>::type>

ifind_last(

Range1T& Input,

const Range2T& Search,

const std::locale& Loc=std::locale())

{

return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));

}

// find_nth ----------------------------------------------------------------------//

//! Find n-th algorithm

/*!

Search for the n-th (zero-indexed) occurrence of the substring in the

input.

\param Input A string which will be searched.

\param Search A substring to be searched for.

\param Nth An index (zero-indexed) of the match to be found.

For negative N, the matches are counted from the end of string.

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c Range1T::iterator or

\c Range1T::const_iterator, depending on the constness of

the input parameter.

*/

template<typename Range1T, typename Range2T>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<Range1T>::type>

find_nth(

Range1T& Input,

const Range2T& Search,

int Nth)

{

return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));

}

//! Find n-th algorithm ( case insensitive ).

/*!

Search for the n-th (zero-indexed) occurrence of the substring in the

input. Searching is case insensitive.

\param Input A string which will be searched.

\param Search A substring to be searched for.

\param Nth An index (zero-indexed) of the match to be found.

For negative N, the matches are counted from the end of string.

\param Loc A locale used for case insensitive comparison

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c Range1T::iterator or

\c Range1T::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename Range1T, typename Range2T>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<Range1T>::type>

ifind_nth(

Range1T& Input,

const Range2T& Search,

int Nth,

const std::locale& Loc=std::locale())

{

return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));

}

// find_head ----------------------------------------------------------------------//

//! Find head algorithm

/*!

Get the head of the input. Head is a prefix of the string of the

given size. If the input is shorter then required, whole input is considered

to be the head.

\param Input An input string

\param N Length of the head

For N>=0, at most N characters are extracted.

For N<0, at most size(Input)-|N| characters are extracted.

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c Range1T::iterator or

\c Range1T::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename RangeT>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<RangeT>::type>

find_head(

RangeT& Input,

int N)

{

return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));

}

// find_tail ----------------------------------------------------------------------//

//! Find tail algorithm

/*!

Get the tail of the input. Tail is a suffix of the string of the

given size. If the input is shorter then required, whole input is considered

to be the tail.

\param Input An input string

\param N Length of the tail.

For N>=0, at most N characters are extracted.

For N<0, at most size(Input)-|N| characters are extracted.

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c RangeT::iterator or

\c RangeT::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename RangeT>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<RangeT>::type>

find_tail(

RangeT& Input,

int N)

{

return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));

}

// find_token --------------------------------------------------------------------//

//! Find token algorithm

/*!

Look for a given token in the string. Token is a character that matches the

given predicate.

If the "token compress mode" is enabled, adjacent tokens are considered to be one match.

\param Input A input string.

\param Pred A unary predicate to identify a token

\param eCompress Enable/Disable compressing of adjacent tokens

\return

An \c iterator_range delimiting the match.

Returned iterator is either \c RangeT::iterator or

\c RangeT::const_iterator, depending on the constness of

the input parameter.

\note This function provides the strong exception-safety guarantee

*/

template<typename RangeT, typename PredicateT>

inline iterator_range<

BOOST_STRING_TYPENAME range_iterator<RangeT>::type>

find_token(

RangeT& Input,

PredicateT Pred,

token_compress_mode_type eCompress=token_compress_off)

{

return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));

}

} // namespace algorithm

// pull names to the boost namespace

using algorithm::find;

using algorithm::find_first;

using algorithm::ifind_first;

using algorithm::find_last;

using algorithm::ifind_last;

using algorithm::find_nth;

using algorithm::ifind_nth;

using algorithm::find_head;

using algorithm::find_tail;

using algorithm::find_token;

} // namespace boost

#endif // BOOST_STRING_FIND_HPP