x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
sub_match.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\xpressive\sub_match.hpp
旋转
特效
属性
历史版本
/////////////////////////////////////////////////////////////////////////////// /// \file sub_match.hpp /// Contains the definition of the class template sub_match\<\> /// and associated helper functions // // Copyright 2007 Eric Niebler. 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) #ifndef BOOST_XPRESSIVE_SUB_MATCH_HPP_EAN_10_04_2005 #define BOOST_XPRESSIVE_SUB_MATCH_HPP_EAN_10_04_2005 // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif #include
#include
#include
#include
#include
#include
#include
//{{AFX_DOC_COMMENT /////////////////////////////////////////////////////////////////////////////// // This is a hack to get Doxygen to show the inheritance relation between // sub_match
and std::pair
. #ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED /// INTERNAL ONLY namespace std { /// INTERNAL ONLY template
struct pair {}; } #endif //}}AFX_DOC_COMMENT namespace boost { namespace xpressive { /////////////////////////////////////////////////////////////////////////////// // sub_match // /// \brief Class template sub_match denotes the sequence of characters matched by a particular marked sub-expression. /// /// When the marked sub-expression denoted by an object of type sub_match\<\> participated in a /// regular expression match then member matched evaluates to true, and members first and second /// denote the range of characters [first,second) which formed that match. Otherwise matched is false, /// and members first and second contained undefined values. /// /// If an object of type sub_match\<\> represents sub-expression 0 - that is to say the whole match - /// then member matched is always true, unless a partial match was obtained as a result of the flag /// match_partial being passed to a regular expression algorithm, in which case member matched is /// false, and members first and second represent the character range that formed the partial match. template
struct sub_match : std::pair
{ private: /// INTERNAL ONLY /// struct dummy { int i_; }; typedef int dummy::*bool_type; public: typedef typename iterator_value
::type value_type; typedef typename iterator_difference
::type difference_type; typedef typename detail::string_type
::type string_type; typedef BidiIter iterator; sub_match() : std::pair
() , matched(false) { } sub_match(BidiIter first, BidiIter second, bool matched_ = false) : std::pair
(first, second) , matched(matched_) { } string_type str() const { return this->matched ? string_type(this->first, this->second) : string_type(); } operator string_type() const { return this->matched ? string_type(this->first, this->second) : string_type(); } difference_type length() const { return this->matched ? std::distance(this->first, this->second) : 0; } operator bool_type() const { return this->matched ? &dummy::i_ : 0; } bool operator !() const { return !this->matched; } /// \brief Performs a lexicographic string comparison /// \param str the string against which to compare /// \return the results of (*this).str().compare(str) int compare(string_type const &str) const { return this->str().compare(str); } /// \overload /// int compare(sub_match const &sub) const { return this->str().compare(sub.str()); } /// \overload /// int compare(value_type const *ptr) const { return this->str().compare(ptr); } /// \brief true if this sub-match participated in the full match. bool matched; }; /////////////////////////////////////////////////////////////////////////////// /// \brief insertion operator for sending sub-matches to ostreams /// \param sout output stream. /// \param sub sub_match object to be written to the stream. /// \return sout \<\< sub.str() template
inline std::basic_ostream
&operator << ( std::basic_ostream
&sout , sub_match
const &sub ) { typedef typename iterator_value
::type char_type; if(sub.matched) { std::ostream_iterator
iout(sout); std::copy(sub.first, sub.second, iout); } return sout; } // BUGBUG make these more efficient template
bool operator == (sub_match
const &lhs, sub_match
const &rhs) { return lhs.compare(rhs) == 0; } template
bool operator != (sub_match
const &lhs, sub_match
const &rhs) { return lhs.compare(rhs) != 0; } template
bool operator < (sub_match
const &lhs, sub_match
const &rhs) { return lhs.compare(rhs) < 0; } template
bool operator <= (sub_match
const &lhs, sub_match
const &rhs) { return lhs.compare(rhs) <= 0; } template
bool operator >= (sub_match
const &lhs, sub_match
const &rhs) { return lhs.compare(rhs) >= 0; } template
bool operator > (sub_match
const &lhs, sub_match
const &rhs) { return lhs.compare(rhs) > 0; } template
bool operator == (typename iterator_value
::type const *lhs, sub_match
const &rhs) { return lhs == rhs.str(); } template
bool operator != (typename iterator_value
::type const *lhs, sub_match
const &rhs) { return lhs != rhs.str(); } template
bool operator < (typename iterator_value
::type const *lhs, sub_match
const &rhs) { return lhs < rhs.str(); } template
bool operator > (typename iterator_value
::type const *lhs, sub_match
const &rhs) { return lhs> rhs.str(); } template
bool operator >= (typename iterator_value
::type const *lhs, sub_match
const &rhs) { return lhs >= rhs.str(); } template
bool operator <= (typename iterator_value
::type const *lhs, sub_match
const &rhs) { return lhs <= rhs.str(); } template
bool operator == (sub_match
const &lhs, typename iterator_value
::type const *rhs) { return lhs.str() == rhs; } template
bool operator != (sub_match
const &lhs, typename iterator_value
::type const *rhs) { return lhs.str() != rhs; } template
bool operator < (sub_match
const &lhs, typename iterator_value
::type const *rhs) { return lhs.str() < rhs; } template
bool operator > (sub_match
const &lhs, typename iterator_value
::type const *rhs) { return lhs.str() > rhs; } template
bool operator >= (sub_match
const &lhs, typename iterator_value
::type const *rhs) { return lhs.str() >= rhs; } template
bool operator <= (sub_match
const &lhs, typename iterator_value
::type const *rhs) { return lhs.str() <= rhs; } template
bool operator == (typename iterator_value
::type const &lhs, sub_match
const &rhs) { return lhs == rhs.str(); } template
bool operator != (typename iterator_value
::type const &lhs, sub_match
const &rhs) { return lhs != rhs.str(); } template
bool operator < (typename iterator_value
::type const &lhs, sub_match
const &rhs) { return lhs < rhs.str(); } template
bool operator > (typename iterator_value
::type const &lhs, sub_match
const &rhs) { return lhs> rhs.str(); } template
bool operator >= (typename iterator_value
::type const &lhs, sub_match
const &rhs) { return lhs >= rhs.str(); } template
bool operator <= (typename iterator_value
::type const &lhs, sub_match
const &rhs) { return lhs <= rhs.str(); } template
bool operator == (sub_match
const &lhs, typename iterator_value
::type const &rhs) { return lhs.str() == rhs; } template
bool operator != (sub_match
const &lhs, typename iterator_value
::type const &rhs) { return lhs.str() != rhs; } template
bool operator < (sub_match
const &lhs, typename iterator_value
::type const &rhs) { return lhs.str() < rhs; } template
bool operator > (sub_match
const &lhs, typename iterator_value
::type const &rhs) { return lhs.str() > rhs; } template
bool operator >= (sub_match
const &lhs, typename iterator_value
::type const &rhs) { return lhs.str() >= rhs; } template
bool operator <= (sub_match
const &lhs, typename iterator_value
::type const &rhs) { return lhs.str() <= rhs; } // Operator+ convenience function template
typename sub_match
::string_type operator + (sub_match
const &lhs, sub_match
const &rhs) { return lhs.str() + rhs.str(); } template
typename sub_match
::string_type operator + (sub_match
const &lhs, typename iterator_value
::type const &rhs) { return lhs.str() + rhs; } template
typename sub_match
::string_type operator + (typename iterator_value
::type const &lhs, sub_match
const &rhs) { return lhs + rhs.str(); } template
typename sub_match
::string_type operator + (sub_match
const &lhs, typename iterator_value
::type const *rhs) { return lhs.str() + rhs; } template
typename sub_match
::string_type operator + (typename iterator_value
::type const *lhs, sub_match
const &rhs) { return lhs + rhs.str(); } template
typename sub_match
::string_type operator + (sub_match
const &lhs, typename sub_match
::string_type const &rhs) { return lhs.str() + rhs; } template
typename sub_match
::string_type operator + (typename sub_match
::string_type const &lhs, sub_match
const &rhs) { return lhs + rhs.str(); } }} // namespace boost::xpressive #endif
sub_match.hpp
网页地址
文件地址
上一页
12/17
下一页
下载
( 11 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.