You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
334 lines
13 KiB
334 lines
13 KiB
// 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.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 occurence 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 if 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, 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 if 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, 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 An 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
|
|
|