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