x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
predicate.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\algorithm\string\predicate.hpp
旋转
特效
属性
历史版本
// 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
#include
#include
#include
#include
#include
#include
#include
#include
#include
/*! \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
inline bool starts_with( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range
::type> lit_input(as_literal(Input)); iterator_range
::type> lit_test(as_literal(Test)); typedef BOOST_STRING_TYPENAME range_const_iterator
::type Iterator1T; typedef BOOST_STRING_TYPENAME range_const_iterator
::type Iterator2T; Iterator1T InputEnd=end(lit_input); Iterator2T TestEnd=end(lit_test); Iterator1T it=begin(lit_input); Iterator2T pit=begin(lit_test); for(; it!=InputEnd && pit!=TestEnd; ++it,++pit) { if( !(Comp(*it,*pit)) ) return false; } return pit==TestEnd; } //! 'Starts with' predicate /*! \overload */ template
inline bool starts_with( const Range1T& Input, const Range2T& Test) { return 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
inline bool istarts_with( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return 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
inline bool ends_with( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range
::type> lit_input(as_literal(Input)); iterator_range
::type> lit_test(as_literal(Test)); typedef BOOST_STRING_TYPENAME range_const_iterator
::type Iterator1T; typedef BOOST_STRING_TYPENAME boost::detail:: iterator_traits
::iterator_category category; return detail:: ends_with_iter_select( begin(lit_input), end(lit_input), begin(lit_test), end(lit_test), Comp, category()); } //! 'Ends with' predicate /*! \overload */ template
inline bool ends_with( const Range1T& Input, const Range2T& Test) { return 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
inline bool iends_with( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return 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
inline bool contains( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range
::type> lit_input(as_literal(Input)); iterator_range
::type> lit_test(as_literal(Test)); if (empty(lit_test)) { // Empty range is contained always return true; } // Use the temporary variable to make VACPP happy bool bResult=(first_finder(lit_test,Comp)(begin(lit_input), end(lit_input))); return bResult; } //! 'Contains' predicate /*! \overload */ template
inline bool contains( const Range1T& Input, const Range2T& Test) { return 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
inline bool icontains( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return 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
inline bool equals( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range
::type> lit_input(as_literal(Input)); iterator_range
::type> lit_test(as_literal(Test)); typedef BOOST_STRING_TYPENAME range_const_iterator
::type Iterator1T; typedef BOOST_STRING_TYPENAME range_const_iterator
::type Iterator2T; Iterator1T InputEnd=end(lit_input); Iterator2T TestEnd=end(lit_test); Iterator1T it=begin(lit_input); Iterator2T pit=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
inline bool equals( const Range1T& Input, const Range2T& Test) { return 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
inline bool iequals( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return 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
inline bool lexicographical_compare( const Range1T& Arg1, const Range2T& Arg2, PredicateT Pred) { iterator_range
::type> lit_arg1(as_literal(Arg1)); iterator_range
::type> lit_arg2(as_literal(Arg2)); return std::lexicographical_compare( begin(lit_arg1), end(lit_arg1), begin(lit_arg2), end(lit_arg2), Pred); } //! Lexicographical compare predicate /*! \overload */ template
inline bool lexicographical_compare( const Range1T& Arg1, const Range2T& Arg2) { return 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
inline bool ilexicographical_compare( const Range1T& Arg1, const Range2T& Arg2, const std::locale& Loc=std::locale()) { return 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
inline bool all( const RangeT& Input, PredicateT Pred) { iterator_range
::type> lit_input(as_literal(Input)); typedef BOOST_STRING_TYPENAME range_const_iterator
::type Iterator1T; Iterator1T InputEnd=end(lit_input); for( Iterator1T It=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
predicate.hpp
网页地址
文件地址
上一页
15/24
下一页
下载
( 16 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.