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.
475 lines
17 KiB
475 lines
17 KiB
// Boost string_algo library predicate.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_PREDICATE_HPP |
|
#define BOOST_STRING_PREDICATE_HPP |
|
|
|
#include <boost/algorithm/string/config.hpp> |
|
#include <boost/range/begin.hpp> |
|
#include <boost/range/end.hpp> |
|
#include <boost/range/iterator.hpp> |
|
#include <boost/range/const_iterator.hpp> |
|
#include <boost/range/as_literal.hpp> |
|
#include <boost/range/iterator_range.hpp> |
|
|
|
#include <boost/algorithm/string/compare.hpp> |
|
#include <boost/algorithm/string/find.hpp> |
|
#include <boost/algorithm/string/detail/predicate.hpp> |
|
|
|
/*! \file boost/algorithm/string/predicate.hpp |
|
Defines string-related predicates. |
|
The predicates determine whether a substring is contained in the input string |
|
under various conditions: a string starts with the substring, ends with the |
|
substring, simply contains the substring or if both strings are equal. |
|
Additionaly the algorithm \c all() checks all elements of a container to satisfy a |
|
condition. |
|
|
|
All predicates provide the strong exception guarantee. |
|
*/ |
|
|
|
namespace boost { |
|
namespace algorithm { |
|
|
|
// starts_with predicate -----------------------------------------------// |
|
|
|
//! 'Starts with' predicate |
|
/*! |
|
This predicate holds when the test string is a prefix of the Input. |
|
In other words, if the input starts with the test. |
|
When the optional predicate is specified, it is used for character-wise |
|
comparison. |
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Comp An element comparison predicate |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T, typename PredicateT> |
|
inline bool starts_with( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
PredicateT Comp) |
|
{ |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); |
|
|
|
typedef BOOST_STRING_TYPENAME |
|
range_const_iterator<Range1T>::type Iterator1T; |
|
typedef BOOST_STRING_TYPENAME |
|
range_const_iterator<Range2T>::type Iterator2T; |
|
|
|
Iterator1T InputEnd=::boost::end(lit_input); |
|
Iterator2T TestEnd=::boost::end(lit_test); |
|
|
|
Iterator1T it=::boost::begin(lit_input); |
|
Iterator2T pit=::boost::begin(lit_test); |
|
for(; |
|
it!=InputEnd && pit!=TestEnd; |
|
++it,++pit) |
|
{ |
|
if( !(Comp(*it,*pit)) ) |
|
return false; |
|
} |
|
|
|
return pit==TestEnd; |
|
} |
|
|
|
//! 'Starts with' predicate |
|
/*! |
|
\overload |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool starts_with( |
|
const Range1T& Input, |
|
const Range2T& Test) |
|
{ |
|
return ::boost::algorithm::starts_with(Input, Test, is_equal()); |
|
} |
|
|
|
//! 'Starts with' predicate ( case insensitive ) |
|
/*! |
|
This predicate holds when the test string is a prefix of the Input. |
|
In other words, if the input starts with the test. |
|
Elements are compared case insensitively. |
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Loc A locale used for case insensitive comparison |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool istarts_with( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
const std::locale& Loc=std::locale()) |
|
{ |
|
return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc)); |
|
} |
|
|
|
|
|
// ends_with predicate -----------------------------------------------// |
|
|
|
//! 'Ends with' predicate |
|
/*! |
|
This predicate holds when the test string is a suffix of the Input. |
|
In other words, if the input ends with the test. |
|
When the optional predicate is specified, it is used for character-wise |
|
comparison. |
|
|
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Comp An element comparison predicate |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T, typename PredicateT> |
|
inline bool ends_with( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
PredicateT Comp) |
|
{ |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); |
|
|
|
typedef BOOST_STRING_TYPENAME |
|
range_const_iterator<Range1T>::type Iterator1T; |
|
typedef BOOST_STRING_TYPENAME boost::detail:: |
|
iterator_traits<Iterator1T>::iterator_category category; |
|
|
|
return detail:: |
|
ends_with_iter_select( |
|
::boost::begin(lit_input), |
|
::boost::end(lit_input), |
|
::boost::begin(lit_test), |
|
::boost::end(lit_test), |
|
Comp, |
|
category()); |
|
} |
|
|
|
|
|
//! 'Ends with' predicate |
|
/*! |
|
\overload |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool ends_with( |
|
const Range1T& Input, |
|
const Range2T& Test) |
|
{ |
|
return ::boost::algorithm::ends_with(Input, Test, is_equal()); |
|
} |
|
|
|
//! 'Ends with' predicate ( case insensitive ) |
|
/*! |
|
This predicate holds when the test container is a suffix of the Input. |
|
In other words, if the input ends with the test. |
|
Elements are compared case insensitively. |
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Loc A locale used for case insensitive comparison |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool iends_with( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
const std::locale& Loc=std::locale()) |
|
{ |
|
return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc)); |
|
} |
|
|
|
// contains predicate -----------------------------------------------// |
|
|
|
//! 'Contains' predicate |
|
/*! |
|
This predicate holds when the test container is contained in the Input. |
|
When the optional predicate is specified, it is used for character-wise |
|
comparison. |
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Comp An element comparison predicate |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T, typename PredicateT> |
|
inline bool contains( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
PredicateT Comp) |
|
{ |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); |
|
|
|
if (::boost::empty(lit_test)) |
|
{ |
|
// Empty range is contained always |
|
return true; |
|
} |
|
|
|
// Use the temporary variable to make VACPP happy |
|
bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input))); |
|
return bResult; |
|
} |
|
|
|
//! 'Contains' predicate |
|
/*! |
|
\overload |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool contains( |
|
const Range1T& Input, |
|
const Range2T& Test) |
|
{ |
|
return ::boost::algorithm::contains(Input, Test, is_equal()); |
|
} |
|
|
|
//! 'Contains' predicate ( case insensitive ) |
|
/*! |
|
This predicate holds when the test container is contained in the Input. |
|
Elements are compared case insensitively. |
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Loc A locale used for case insensitive comparison |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool icontains( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
const std::locale& Loc=std::locale()) |
|
{ |
|
return ::boost::algorithm::contains(Input, Test, is_iequal(Loc)); |
|
} |
|
|
|
// equals predicate -----------------------------------------------// |
|
|
|
//! 'Equals' predicate |
|
/*! |
|
This predicate holds when the test container is equal to the |
|
input container i.e. all elements in both containers are same. |
|
When the optional predicate is specified, it is used for character-wise |
|
comparison. |
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Comp An element comparison predicate |
|
\return The result of the test |
|
|
|
\note This is a two-way version of \c std::equal algorithm |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T, typename PredicateT> |
|
inline bool equals( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
PredicateT Comp) |
|
{ |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); |
|
|
|
typedef BOOST_STRING_TYPENAME |
|
range_const_iterator<Range1T>::type Iterator1T; |
|
typedef BOOST_STRING_TYPENAME |
|
range_const_iterator<Range2T>::type Iterator2T; |
|
|
|
Iterator1T InputEnd=::boost::end(lit_input); |
|
Iterator2T TestEnd=::boost::end(lit_test); |
|
|
|
Iterator1T it=::boost::begin(lit_input); |
|
Iterator2T pit=::boost::begin(lit_test); |
|
for(; |
|
it!=InputEnd && pit!=TestEnd; |
|
++it,++pit) |
|
{ |
|
if( !(Comp(*it,*pit)) ) |
|
return false; |
|
} |
|
|
|
return (pit==TestEnd) && (it==InputEnd); |
|
} |
|
|
|
//! 'Equals' predicate |
|
/*! |
|
\overload |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool equals( |
|
const Range1T& Input, |
|
const Range2T& Test) |
|
{ |
|
return ::boost::algorithm::equals(Input, Test, is_equal()); |
|
} |
|
|
|
//! 'Equals' predicate ( case insensitive ) |
|
/*! |
|
This predicate holds when the test container is equal to the |
|
input container i.e. all elements in both containers are same. |
|
Elements are compared case insensitively. |
|
|
|
\param Input An input sequence |
|
\param Test A test sequence |
|
\param Loc A locale used for case insensitive comparison |
|
\return The result of the test |
|
|
|
\note This is a two-way version of \c std::equal algorithm |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool iequals( |
|
const Range1T& Input, |
|
const Range2T& Test, |
|
const std::locale& Loc=std::locale()) |
|
{ |
|
return ::boost::algorithm::equals(Input, Test, is_iequal(Loc)); |
|
} |
|
|
|
// lexicographical_compare predicate -----------------------------// |
|
|
|
//! Lexicographical compare predicate |
|
/*! |
|
This predicate is an overload of std::lexicographical_compare |
|
for range arguments |
|
|
|
It check whether the first argument is lexicographically less |
|
then the second one. |
|
|
|
If the optional predicate is specified, it is used for character-wise |
|
comparison |
|
|
|
\param Arg1 First argument |
|
\param Arg2 Second argument |
|
\param Pred Comparison predicate |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T, typename PredicateT> |
|
inline bool lexicographical_compare( |
|
const Range1T& Arg1, |
|
const Range2T& Arg2, |
|
PredicateT Pred) |
|
{ |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1)); |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2)); |
|
|
|
return std::lexicographical_compare( |
|
::boost::begin(lit_arg1), |
|
::boost::end(lit_arg1), |
|
::boost::begin(lit_arg2), |
|
::boost::end(lit_arg2), |
|
Pred); |
|
} |
|
|
|
//! Lexicographical compare predicate |
|
/*! |
|
\overload |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool lexicographical_compare( |
|
const Range1T& Arg1, |
|
const Range2T& Arg2) |
|
{ |
|
return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less()); |
|
} |
|
|
|
//! Lexicographical compare predicate (case-insensitive) |
|
/*! |
|
This predicate is an overload of std::lexicographical_compare |
|
for range arguments. |
|
It check whether the first argument is lexicographically less |
|
then the second one. |
|
Elements are compared case insensitively |
|
|
|
|
|
\param Arg1 First argument |
|
\param Arg2 Second argument |
|
\param Loc A locale used for case insensitive comparison |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename Range1T, typename Range2T> |
|
inline bool ilexicographical_compare( |
|
const Range1T& Arg1, |
|
const Range2T& Arg2, |
|
const std::locale& Loc=std::locale()) |
|
{ |
|
return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc)); |
|
} |
|
|
|
|
|
// all predicate -----------------------------------------------// |
|
|
|
//! 'All' predicate |
|
/*! |
|
This predicate holds it all its elements satisfy a given |
|
condition, represented by the predicate. |
|
|
|
\param Input An input sequence |
|
\param Pred A predicate |
|
\return The result of the test |
|
|
|
\note This function provides the strong exception-safety guarantee |
|
*/ |
|
template<typename RangeT, typename PredicateT> |
|
inline bool all( |
|
const RangeT& Input, |
|
PredicateT Pred) |
|
{ |
|
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); |
|
|
|
typedef BOOST_STRING_TYPENAME |
|
range_const_iterator<RangeT>::type Iterator1T; |
|
|
|
Iterator1T InputEnd=::boost::end(lit_input); |
|
for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It) |
|
{ |
|
if (!Pred(*It)) |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
} // namespace algorithm |
|
|
|
// pull names to the boost namespace |
|
using algorithm::starts_with; |
|
using algorithm::istarts_with; |
|
using algorithm::ends_with; |
|
using algorithm::iends_with; |
|
using algorithm::contains; |
|
using algorithm::icontains; |
|
using algorithm::equals; |
|
using algorithm::iequals; |
|
using algorithm::all; |
|
using algorithm::lexicographical_compare; |
|
using algorithm::ilexicographical_compare; |
|
|
|
} // namespace boost |
|
|
|
|
|
#endif // BOOST_STRING_PREDICATE_HPP
|
|
|