| // 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 |