476 lines
17 KiB
Plaintext
476 lines
17 KiB
Plaintext
// 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_core.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
|