x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
action_matcher.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\xpressive\detail\core\matcher\action_matcher.hpp
旋转
特效
属性
历史版本
/////////////////////////////////////////////////////////////////////////////// // action_matcher.hpp // // Copyright 2007 Eric Niebler. // Copyright 2007 David Jenkins. // // 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_DETAIL_CORE_MATCHER_ACTION_MATCHER_HPP_EAN_10_04_2005 #define BOOST_XPRESSIVE_DETAIL_CORE_MATCHER_ACTION_MATCHER_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
#include
#include
#include
#include
#include
#include
#include
// for type_info_less #include
// for 'read_attr' #if BOOST_VERSION >= 103500 # include
# include
# include
# include
# include
#endif namespace boost { namespace xpressive { namespace detail { #if BOOST_VERSION >= 103500 struct DataMember : proto::mem_ptr
> {}; template
struct child_ : remove_reference
, typename proto::result_of::arg_c
::const_reference , typename proto::result_of::arg_c
::reference >::type> {}; /////////////////////////////////////////////////////////////////////////////// // mem_ptr_eval // Rewrites expressions of the form x->*foo(a) into foo(x, a) and then // evaluates them. template
::value> struct mem_ptr_eval { typedef typename child_
::type left_type; typedef typename child_
::type right_type; typedef typename proto::result_of::arg< typename proto::result_of::arg_c
::type >::type function_type; typedef fusion::transform_view< typename fusion::result_of::push_front< typename fusion::result_of::pop_front
>::type const , reference_wrapper
>::type const , proto::eval_fun
> evaluated_args; typedef typename fusion::result_of::invoke
::type result_type; result_type operator()(Expr &expr, Context &ctx) const { return fusion::invoke
( proto::arg(proto::arg_c<0>(proto::right(expr))) , evaluated_args( fusion::push_front(fusion::pop_front(proto::children_of(proto::right(expr))), boost::ref(proto::left(expr))) , proto::eval_fun
(ctx) ) ); } }; /////////////////////////////////////////////////////////////////////////////// // mem_ptr_eval // Rewrites expressions of the form x->*foo into foo(x) and then // evaluates them. template
struct mem_ptr_eval
{ typedef typename child_
::type left_type; typedef typename child_
::type right_type; typedef typename proto::result_of::arg
::type function_type; typedef typename boost::result_of< function_type(typename proto::result_of::eval
::type) >::type result_type; result_type operator()(Expr &expr, Context &ctx) const { return proto::arg(proto::right(expr))( proto::eval(proto::left(expr), ctx) ); } }; #endif struct attr_with_default_tag {}; template
struct opt; /////////////////////////////////////////////////////////////////////////////// // action_context // struct action_context { explicit action_context(action_args_type *action_args) : action_args_(action_args) {} action_args_type const &args() const { return *this->action_args_; } // eval_terminal template
struct eval_terminal : proto::default_eval
{}; template
struct eval_terminal
> { typedef Arg &result_type; result_type operator()(Expr &expr, action_context const &) const { return proto::arg(expr).get(); } }; template
struct eval_terminal
> { typedef Arg const &result_type; result_type operator()(Expr &expr, action_context const &) const { return proto::arg(expr); } }; template
struct eval_terminal
> { typedef typename action_arg
::reference result_type; result_type operator()(Expr &expr, action_context const &ctx) const { action_args_type::const_iterator where_ = ctx.args().find(&typeid(proto::arg(expr))); if(where_ == ctx.args().end()) { boost::throw_exception( regex_error( regex_constants::error_badarg , "An argument to an action was unspecified" ) ); } return proto::arg(expr).cast(where_->second); } }; // eval template
struct eval : proto::default_eval
{}; template
struct eval
: eval_terminal
::type> {}; // Evaluate attributes like a1|42 template
struct eval
{ typedef typename proto::result_of::arg< typename proto::result_of::left< typename proto::result_of::arg< Expr >::type >::type >::type temp_type; typedef typename temp_type::type result_type; result_type operator ()(Expr const &expr, action_context const &ctx) const { return proto::arg(proto::left(proto::arg(expr))).t_ ? *proto::arg(proto::left(proto::arg(expr))).t_ : proto::eval(proto::right(proto::arg(expr)), ctx); } }; #if BOOST_VERSION >= 103500 template
struct eval
: mem_ptr_eval
{}; #endif private: action_args_type *action_args_; }; /////////////////////////////////////////////////////////////////////////////// // action // template
struct action : actionable { action(Actor const &actor) : actionable() , actor_(actor) { } virtual void execute(action_args_type *action_args) const { action_context const ctx(action_args); proto::eval(this->actor_, ctx); } private: Actor actor_; }; /////////////////////////////////////////////////////////////////////////////// // subreg_transform // template
struct subreg_transform : Grammar { subreg_transform(); template
struct apply : proto::terminal
> {}; template
static typename apply
::type call(Expr const &, State const &state, Visitor &visitor) { sub_match
const &sub = state.sub_matches_[ visitor ]; return proto::as_expr(sub); } }; /////////////////////////////////////////////////////////////////////////////// // mark_transform // template
struct mark_transform : Grammar { mark_transform(); template
struct apply : proto::terminal
> {}; template
static typename apply
::type call(Expr const &expr, State const &state, Visitor &) { sub_match
const &sub = state.sub_matches_[ proto::arg(expr).mark_number_ ]; return proto::as_expr(sub); } }; /////////////////////////////////////////////////////////////////////////////// // opt // template
struct opt { typedef T type; typedef T const &reference; opt(T const *t) : t_(t) {} operator reference() const { detail::ensure(0 != this->t_, regex_constants::error_badattr, "Use of uninitialized regex attribute"); return *this->t_; } T const *t_; }; /////////////////////////////////////////////////////////////////////////////// // attr_transform // template
struct attr_transform : Grammar { attr_transform(); template
struct apply : proto::result_of::as_expr< opt
> {}; template
static typename apply
::type call(Expr const &, State const &state, Visitor &) { typedef typename Expr::proto_arg0::matcher_type::value_type::second_type attr_type; int slot = typename Expr::proto_arg0::nbr_type(); attr_type const *attr = static_cast
(state.attr_context_.attr_slots_[slot-1]); return proto::as_expr(opt
(attr)); } }; /////////////////////////////////////////////////////////////////////////////// // attr_with_default_transform // template
struct attr_with_default_transform : Grammar { attr_with_default_transform(); template
struct apply : proto::unary_expr< attr_with_default_tag , typename Grammar::template apply
::type > {}; template
static typename apply
::type call(Expr const &expr, State const &state, Visitor &visitor) { typename apply
::type that = { Grammar::call(expr, state, visitor) }; return that; } }; /////////////////////////////////////////////////////////////////////////////// // by_ref_transform // template
struct by_ref_transform : Grammar { by_ref_transform(); template
struct apply : proto::terminal
::const_reference> {}; template
static typename apply
::type call(Expr const &expr, State const &, Visitor &) { return apply
::type::make(proto::arg(expr)); } }; /////////////////////////////////////////////////////////////////////////////// // BindActionArgs // struct BindActionArgs : proto::or_< subreg_transform
> , mark_transform
> , attr_transform
> > , by_ref_transform
> , attr_with_default_transform< proto::bitwise_or< attr_transform
> > , BindActionArgs > > , proto::nary_expr
> > {}; /////////////////////////////////////////////////////////////////////////////// // action_matcher // template
struct action_matcher : quant_style
{ int sub_; Actor actor_; action_matcher(Actor const &actor, int sub) : sub_(sub) , actor_(actor) { } template
bool match(match_state
&state, Next const &next) const { // Bind the arguments typedef typename BindActionArgs::apply
, int>::type action_type; action
actor(BindActionArgs::call(this->actor_, state, this->sub_)); // Put the action in the action list actionable const **action_list_tail = state.action_list_tail_; *state.action_list_tail_ = &actor; state.action_list_tail_ = &actor.next; // Match the rest of the pattern if(next.match(state)) { return true; } BOOST_ASSERT(0 == actor.next); // remove action from list *action_list_tail = 0; state.action_list_tail_ = action_list_tail; return false; } }; }}} #endif
action_matcher.hpp
网页地址
文件地址
上一页 1/36
下一页
下载
( 15 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.