Contains definitions for various expression traits and utilities like
proto::tag_of<> and
proto::arity_of<>;
the functions
proto::value(),
proto::left() and
proto::right();
proto::child(),
proto::child_c(),
proto::as_expr(),
proto::as_child(),
and assorted helpers.
Boolean metafunction which tells whether a type is a callable
PolymorphicFunctionObject or not.
proto::is_callable<> is used by the
proto::when<>
transform to determine whether a function type R(A1,...An)
is a CallableTransform or an ObjectTransform.
The former are evaluated using proto::call<>
and the later with proto::make<>.
If proto::is_callable<R>::value is true,
the function type is a CallableTransform; otherwise, it is an ObjectTransform.
Unless specialized for a type
T, proto::is_callable<T>::value
is computed as follows:
If T is a template type
X<Y0,...Yn>,
where all Yx are types for
x in [0,n],
proto::is_callable<T>::value is
boost::is_same<Yn, proto::callable>::value.
If T is derived from proto::callable,
proto::is_callable<T>::value is true.
Otherwise, proto::is_callable<T>::value
is false.
mpl::bool_<true-or-false>
Boolean metafunction which tells whether a type is a
PrimitiveTransform or not.
proto::is_transform<> is used by the
proto::make<>
transform to determine whether a type R represents a
PrimitiveTransform to apply, or whether it merely represents itself.
It is also used by the
proto::call<>
transform to determine whether the function types R(),
R(A1), and R(A1, A2) should
be passed the expression, state and data parameters (as needed).
Unless specialized for a type
T, proto::is_transform<T>::value
is computed as follows:
If T is a class type that inherits directly or indirectly from
an instantiation of
proto::transform<>,
proto::is_transform<T>::value is true.
Otherwise, proto::is_transform<T>::value
is false.
mpl::bool_<true-or-false>
A Boolean metafunction that indicates whether a type requires aggregate initialization.
proto::is_aggregate<> is used by the
proto::make<> transform to determine how
to construct an object of some type T, given some initialization arguments
a0,...an.
If proto::is_aggregate<T>::value is true,
then an object of type T will be initialized as
T t = {a0,...an};.
Otherwise, it will be initialized as
T t(a0,...an).
Note: proto::expr<> and
proto::basic_expr<>are aggregates.
mpl::bool_<true-or-false>
proto::default_domain
A callable PolymorphicFunctionObject that is equivalent to the
proto::as_expr() function.
proto::callable
This(T)
proto::result_of::as_expr< typename remove_reference< T >::type, Domain >
typename proto::result_of::as_expr< T, Domain >::type
T &
The object to wrap.
Wrap an object in a Proto terminal if it isn't a Proto expression already.
proto::as_expr<Domain>(t)
typename proto::result_of::as_expr< T const, Domain >::type
T const &
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
proto::default_domain
A callable PolymorphicFunctionObject that is equivalent to the
proto::as_child() function.
proto::callable
This(T)
proto::result_of::as_child< typename remove_reference< T >::type, Domain >
typename proto::result_of::as_child< T, Domain >::type
T &
The object to wrap.
Wrap an object in a Proto terminal if it isn't a Proto expression already.
proto::as_child<Domain>(t)
typename proto::result_of::as_child< T const, Domain >::type
T const &
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
long
A callable PolymorphicFunctionObject that is equivalent to the
proto::child_c() function.
proto::callable
This(Expr)
proto::result_of::child_c< Expr, N >
typename proto::result_of::child_c< Expr &, N >::type
Expr &
The expression node.
Return the Nth child of the given expression.
proto::is_expr<Expr>::value is
true
N < Expr::proto_arity::value
proto::child_c<N>(expr)
Will not throw.
typename proto::result_of::child_c< Expr const &, N >::type
Expr const &
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
mpl::long_<0>
A callable PolymorphicFunctionObject that is equivalent to the
proto::child() function.
A callable PolymorphicFunctionObject that is equivalent to the
proto::child()
function. N is required to be an MPL Integral Constant.
proto::callable
This(Expr)
proto::result_of::child< Expr, N >
typename proto::result_of::child< Expr &, N >::type
Expr &
The expression node.
Return the Nth child of the given expression.
proto::is_expr<Expr>::value is
true
N::value < Expr::proto_arity::value
proto::child<N>(expr)
Will not throw.
typename proto::result_of::child< Expr const &, N >::type
Expr const &
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
A callable PolymorphicFunctionObject that is equivalent to the
proto::value() function.
proto::callable
This(Expr)
proto::result_of::value< Expr >
typename proto::result_of::value< Expr & >::type
Expr &
The terminal expression node.
Return the value of the given terminal expression.
proto::is_expr<Expr>::value is
true
0 == Expr::proto_arity::value
proto::value(expr)
Will not throw.
typename proto::result_of::value< Expr const & >::type
Expr const &
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
A callable PolymorphicFunctionObject that is equivalent to the
proto::left() function.
This(Expr)
proto::result_of::left< Expr >
proto::callable
typename proto::result_of::left< Expr & >::type
Expr &
The expression node.
Return the left child of the given binary expression.
proto::is_expr<Expr>::value is
true
2 == Expr::proto_arity::value
proto::left(expr)
Will not throw.
typename proto::result_of::left< Expr const & >::type
Expr const &
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
A callable PolymorphicFunctionObject that is equivalent to the
proto::right() function.
This(Expr)
proto::result_of::right< Expr >
proto::callable
typename proto::result_of::right< Expr & >::type
Expr &
The expression node.
Return the right child of the given binary expression.
proto::is_expr<Expr>::value is true
2 == Expr::proto_arity::value
proto::right(expr)
Will not throw.
typename proto::result_of::right< Expr const & >::type
Expr const &
proto::transform< terminal<T> >
A metafunction for generating terminal expression types, a grammar element for matching
terminal expressions, and
a PrimitiveTransform that returns the current expression unchanged.
proto::transform_impl< Expr, State, Data >
Expr
Expr
typename impl::expr_param
The current expression
typename impl::state_param
typename impl::data_param
proto::matches<Expr, proto::terminal<T> >::value is true.
expr
Will not throw.
proto::expr< proto::tag::terminal, proto::term< T > >
proto::basic_expr< proto::tag::terminal, proto::term< T > >
proto::transform< if_else_<T, U, V> >
A metafunction for generating ternary conditional expression types, a grammar element for
matching ternary conditional expressions, and
a PrimitiveTransform
that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<if_else_>::template impl<Expr, State, Data>
proto::expr< proto::tag::if_else_, proto::list3< T, U, V > >
proto::basic_expr< proto::tag::if_else_, proto::list3< T, U, V > >
proto::transform< unary_plus<T> >
A metafunction for generating unary plus expression types,
a grammar element for matching unary plus expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<unary_plus>::template impl<Expr, State, Data>
proto::expr< proto::tag::unary_plus, proto::list1< T > >
proto::basic_expr< proto::tag::unary_plus, proto::list1< T > >
proto::transform< negate<T> >
A metafunction for generating unary minus expression types,
a grammar element for matching unary minus expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<negate>::template impl<Expr, State, Data>
proto::expr< proto::tag::negate, proto::list1< T > >
proto::basic_expr< proto::tag::negate, proto::list1< T > >
proto::transform< dereference<T> >
A metafunction for generating defereference expression types,
a grammar element for matching dereference expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<dereference>::template impl<Expr, State, Data>
proto::expr< proto::tag::dereference, proto::list1< T > >
proto::basic_expr< proto::tag::dereference, proto::list1< T > >
proto::transform< complement<T> >
A metafunction for generating complement expression types,
a grammar element for matching complement expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<complement>::template impl<Expr, State, Data>
proto::expr< proto::tag::complement, proto::list1< T > >
proto::basic_expr< proto::tag::complement, proto::list1< T > >
proto::transform< address_of<T> >
A metafunction for generating address_of expression types,
a grammar element for matching address_of expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<address_of>::template impl<Expr, State, Data>
proto::expr< proto::tag::address_of, proto::list1< T > >
proto::basic_expr< proto::tag::address_of, proto::list1< T > >
proto::transform< logical_not<T> >
A metafunction for generating logical_not expression types,
a grammar element for matching logical_not expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<logical_not>::template impl<Expr, State, Data>
proto::expr< proto::tag::logical_not, proto::list1< T > >
proto::basic_expr< proto::tag::logical_not, proto::list1< T > >
proto::transform< pre_inc<T> >
A metafunction for generating pre-increment expression types,
a grammar element for matching pre-increment expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<pre_inc>::template impl<Expr, State, Data>
proto::expr< proto::tag::pre_inc, proto::list1< T > >
proto::basic_expr< proto::tag::pre_inc, proto::list1< T > >
proto::transform< pre_dec<T> >
A metafunction for generating pre-decrement expression types,
a grammar element for matching pre-decrement expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<pre_dec>::template impl<Expr, State, Data>
proto::expr< proto::tag::pre_dec, proto::list1< T > >
proto::basic_expr< proto::tag::pre_dec, proto::list1< T > >
proto::transform< post_inc<T> >
A metafunction for generating post-increment expression types,
a grammar element for matching post-increment expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<post_inc>::template impl<Expr, State, Data>
proto::expr< proto::tag::post_inc, proto::list1< T > >
proto::basic_expr< proto::tag::post_inc, proto::list1< T > >
proto::transform< post_dec<T> >
A metafunction for generating post-decrement expression types,
a grammar element for matching post-decrement expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<post_dec>::template impl<Expr, State, Data>
proto::expr< proto::tag::post_dec, proto::list1< T > >
proto::basic_expr< proto::tag::post_dec, proto::list1< T > >
proto::transform< shift_left<T, U> >
A metafunction for generating left-shift expression types,
a grammar element for matching left-shift expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<shift_left>::template impl<Expr, State, Data>
proto::expr< proto::tag::shift_left, proto::list2< T, U > >
proto::basic_expr< proto::tag::shift_left, proto::list2< T, U > >
proto::transform< shift_right<T, U> >
A metafunction for generating right-shift expression types,
a grammar element for matching right-shift expressions, and a
PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<shift_right>::template impl<Expr, State, Data>
proto::expr< proto::tag::shift_right, proto::list2< T, U > >
proto::basic_expr< proto::tag::shift_right, proto::list2< T, U > >
proto::transform< multiplies<T, U> >
A metafunction for generating multiplies expression types,
a grammar element for matching multiplies expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<multiplies>::template impl<Expr, State, Data>
proto::expr< proto::tag::multiplies, proto::list2< T, U > >
proto::basic_expr< proto::tag::multiplies, proto::list2< T, U > >
proto::transform< divides<T, U> >
A metafunction for generating divides expression types,
a grammar element for matching divides expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<divides>::template impl<Expr, State, Data>
proto::expr< proto::tag::divides, proto::list2< T, U > >
proto::basic_expr< proto::tag::divides, proto::list2< T, U > >
proto::transform< modulus<T, U> >
A metafunction for generating modulus expression types,
a grammar element for matching modulus expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<modulus>::template impl<Expr, State, Data>
proto::expr< proto::tag::modulus, proto::list2< T, U > >
proto::basic_expr< proto::tag::modulus, proto::list2< T, U > >
proto::transform< plus<T, U> >
A metafunction for generating binary plus expression types,
a grammar element for matching binary plus expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<plus>::template impl<Expr, State, Data>
proto::expr< proto::tag::plus, proto::list2< T, U > >
proto::basic_expr< proto::tag::plus, proto::list2< T, U > >
proto::transform< minus<T, U> >
A metafunction for generating binary minus expression types,
a grammar element for matching binary minus expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<minus>::template impl<Expr, State, Data>
proto::expr< proto::tag::minus, proto::list2< T, U > >
proto::basic_expr< proto::tag::minus, proto::list2< T, U > >
proto::transform< less<T, U> >
A metafunction for generating less expression types,
a grammar element for matching less expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<less>::template impl<Expr, State, Data>
proto::expr< proto::tag::less, proto::list2< T, U > >
proto::basic_expr< proto::tag::less, proto::list2< T, U > >
proto::transform< greater<T, U> >
A metafunction for generating greater expression types,
a grammar element for matching greater expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<greater>::template impl<Expr, State, Data>
proto::expr< proto::tag::greater, proto::list2< T, U > >
proto::basic_expr< proto::tag::greater, proto::list2< T, U > >
proto::transform< less_equal<T, U> >
A metafunction for generating less-or-equal expression types,
a grammar element for matching less-or-equal expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<less_equal>::template impl<Expr, State, Data>
proto::expr< proto::tag::less_equal, proto::list2< T, U > >
proto::basic_expr< proto::tag::less_equal, proto::list2< T, U > >
proto::transform< greater_equal<T, U> >
A metafunction for generating greater-or-equal expression types,
a grammar element for matching greater-or-equal expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<greater_equal>::template impl<Expr, State, Data>
proto::expr< proto::tag::greater_equal, proto::list2< T, U > >
proto::basic_expr< proto::tag::greater_equal, proto::list2< T, U > >
proto::transform< equal_to<T, U> >
A metafunction for generating equal-to expression types,
a grammar element for matching equal-to expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<equal_to>::template impl<Expr, State, Data>
proto::expr< proto::tag::equal_to, proto::list2< T, U > >
proto::basic_expr< proto::tag::equal_to, proto::list2< T, U > >
proto::transform< not_equal_to<T, U> >
A metafunction for generating not-equal-to expression types,
a grammar element for matching not-equal-to expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<mot_equal_to>::template impl<Expr, State, Data>
proto::expr< proto::tag::not_equal_to, proto::list2< T, U > >
proto::basic_expr< proto::tag::not_equal_to, proto::list2< T, U > >
proto::transform< logical_or<T, U> >
A metafunction for generating logical-or expression types,
a grammar element for matching logical-or expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<logical_or>::template impl<Expr, State, Data>
proto::expr< proto::tag::logical_or, proto::list2< T, U > >
proto::basic_expr< proto::tag::logical_or, proto::list2< T, U > >
proto::transform< logical_and<T, U> >
A metafunction for generating logical-and expression types,
a grammar element for matching logical-and expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<logical_and>::template impl<Expr, State, Data>
proto::expr< proto::tag::logical_and, proto::list2< T, U > >
proto::basic_expr< proto::tag::logical_and, proto::list2< T, U > >
proto::transform< bitwise_and<T, U> >
A metafunction for generating bitwise-and expression types,
a grammar element for matching bitwise-and expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<bitwise_and>::template impl<Expr, State, Data>
proto::expr< proto::tag::bitwise_and, proto::list2< T, U > >
proto::basic_expr< proto::tag::bitwise_and, proto::list2< T, U > >
proto::transform< bitwise_or<T, U> >
A metafunction for generating bitwise-or expression types,
a grammar element for matching bitwise-or expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<bitwise_or>::template impl<Expr, State, Data>
proto::expr< proto::tag::bitwise_or, proto::list2< T, U > >
proto::basic_expr< proto::tag::bitwise_or, proto::list2< T, U > >
proto::transform< bitwise_xor<T, U> >
A metafunction for generating bitwise-xor expression types,
a grammar element for matching bitwise-xor expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<bitwise_xor>::template impl<Expr, State, Data>
proto::expr< proto::tag::bitwise_xor, proto::list2< T, U > >
proto::basic_expr< proto::tag::bitwise_xor, proto::list2< T, U > >
proto::transform< comma<T, U> >
A metafunction for generating comma expression types,
a grammar element for matching comma expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<comma>::template impl<Expr, State, Data>
proto::expr< proto::tag::comma, proto::list2< T, U > >
proto::basic_expr< proto::tag::comma, proto::list2< T, U > >
proto::transform< mem_ptr<T, U> >
proto::pass_through<mem_ptr>::template impl<Expr, State, Data>
proto::expr< proto::tag::mem_ptr, proto::list2< T, U > >
proto::basic_expr< proto::tag::mem_ptr, proto::list2< T, U > >
proto::transform< assign<T, U> >
A metafunction for generating assignment expression types,
a grammar element for matching assignment expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::assign, proto::list2< T, U > >
proto::transform< shift_left_assign<T, U> >
A metafunction for generating left-shift-assign expression types,
a grammar element for matching left-shift-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<shift_left_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::shift_left_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::shift_left_assign, proto::list2< T, U > >
proto::transform< shift_right_assign<T, U> >
A metafunction for generating right-shift-assign expression types,
a grammar element for matching right-shift-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<shift_right_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::shift_right_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::shift_right_assign, proto::list2< T, U > >
proto::transform< multiplies_assign<T, U> >
A metafunction for generating multiplies-assign expression types,
a grammar element for matching multiplies-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<multiplies_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::multiplies_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::multiplies_assign, proto::list2< T, U > >
proto::transform< divides_assign<T, U> >
A metafunction for generating divides-assign expression types,
a grammar element for matching divides-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<divides_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::divides_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::divides_assign, proto::list2< T, U > >
proto::transform< modulus_assign<T, U> >
A metafunction for generating modulus-assign expression types,
a grammar element for matching modulus-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<modulus_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::modulus_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::modulus_assign, proto::list2< T, U > >
proto::transform< plus_assign<T, U> >
A metafunction for generating plus-assign expression types,
a grammar element for matching plus-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<plus_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::plus_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::plus_assign, proto::list2< T, U > >
proto::transform< minus_assign<T, U> >
A metafunction for generating minus-assign expression types,
a grammar element for matching minus-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<minus_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::minus_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::minus_assign, proto::list2< T, U > >
proto::transform< bitwise_and_assign<T, U> >
A metafunction for generating bitwise-and-assign expression types,
a grammar element for matching bitwise-and-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<bitwise_and_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::bitwise_and_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::bitwise_and_assign, proto::list2< T, U > >
proto::transform< bitwise_or_assign<T, U> >
A metafunction for generating bitwise-or-assign expression types,
a grammar element for matching bitwise-or-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<bitwise_or_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::bitwise_or_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::bitwise_or_assign, proto::list2< T, U > >
proto::transform< bitwise_xor_assign<T, U> >
A metafunction for generating bitwise-xor-assign expression types,
a grammar element for matching bitwise-xor-assign expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<bitwise_xor_assign>::template impl<Expr, State, Data>
proto::expr< proto::tag::bitwise_xor_assign, proto::list2< T, U > >
proto::basic_expr< proto::tag::bitwise_xor_assign, proto::list2< T, U > >
proto::transform< subscript<T, U> >
A metafunction for generating subscript expression types,
a grammar element for matching subscript expressions, and
a PrimitiveTransform that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<subscript>::template impl<Expr, State, Data>
proto::expr< proto::tag::subscript, proto::list2< T, U > >
proto::basic_expr< proto::tag::subscript, proto::list2< T, U > >
proto::transform< function<A...> >
A metafunction for generating function-call expression types, a grammar element for
matching function-call expressions, and
a PrimitiveTransform
that dispatches to the
proto::pass_through<>
transform.
proto::pass_through<function>::template impl<Expr, State, Data>
proto::expr< proto::tag::function, proto::listN< A... > >
proto::basic_expr< proto::tag::function, proto::listN< A... > >
proto::transform< nullary_expr<Tag, T> >
A metafunction for generating nullary expression types, a grammar element for matching
nullary expressions, and
a PrimitiveTransform that returns the current expression unchanged.
Use proto::nullary_expr<proto::_, proto::_>
as a grammar element to match any nullary expression.
proto::transform_impl< Expr, State, Data >
Expr
Expr
typename impl::expr_param
The current expression
typename impl::state_param
typename impl::data_param
proto::matches<Expr, proto::nullary_expr<Tag, T> >::value is true.
expr
Will not throw.
proto::expr< Tag, proto::term< T > >
proto::basic_expr< Tag, proto::term< T > >
proto::transform< unary_expr<Tag, T> >
A metafunction for generating unary expression types with a specified tag type,
a grammar element for matching unary expressions, and
a PrimitiveTransform
that dispatches to the
proto::pass_through<>
transform.
Use proto::unary_expr<proto::_, proto::_>
as a grammar element to match any unary expression.
proto::pass_through<unary_expr>::template impl<Expr, State, Data>
proto::expr< Tag, proto::list1< T > >
proto::basic_expr< Tag, proto::list1< T > >
proto::transform< binary_expr<Tag, T, U> >
A metafunction for generating binary expression types with a specified tag type,
a grammar element for matching binary expressions, and
a PrimitiveTransform
that dispatches to the
proto::pass_through<>
transform.
Use proto::binary_expr<proto::_, proto::_, proto::_> as a grammar element to match any binary expression.
proto::pass_through<binary_expr>::template impl<Expr, State, Data>
proto::expr< Tag, proto::list2< T, U > >
proto::basic_expr< Tag, proto::list2< T, U > >
proto::transform< nary_expr<Tag, A...> >
A metafunction for generating n-ary expression types with a specified tag type,
a grammar element for matching n-ary expressions, and
a PrimitiveTransform
that dispatches to the
proto::pass_through<>
transform.
Use proto::nary_expr<proto::_, proto::vararg<proto::_> >
as a grammar element to match any n-ary expression; that is, any non-terminal.
proto::pass_through<nary_expr>::template impl<Expr, State, Data>
proto::expr< Tag, proto::listN< A... > >
proto::basic_expr< Tag, proto::listN< A... > >
mpl::bool_<true-or-false>
A Boolean metafunction that indicates whether a given type T
is a Proto expression type.
If T is an instantiation of
proto::expr<> or
proto::basic_expr<> or is an extension
(via proto::extends<> or
BOOST_PROTO_EXTENDS()) of such an instantiation,
proto::is_expr<T>::value
is true.
Otherwise, proto::is_expr<T>::value
is false.
A metafunction that returns the tag type of a Proto expression.
typename Expr::proto_tag
A metafunction that returns the arity of a Proto expression.
Expr::proto_arity
proto::default_domain
A metafunction that computes the return type of the
proto::as_expr() function.
The proto::result_of::as_expr<> metafunction turns types
into Proto expression types, if they are not already, in a domain-specific way. It is intended
for use to compute the type of a local variable that can hold the result of the
proto::as_expr() function.
See proto::domain::as_expr<>
for a complete description of the default behavior.
typename Domain::template as_expr< T >::result_type
proto::default_domain
A metafunction that computes the return type of the
proto::as_child() function.
The proto::result_of::as_child<> metafunction turns types
into Proto expression types, if they are not already, in a domain-specific way. It is used by Proto
to compute the type of an object to store as a child in another expression node.
See proto::domain::as_child<>
for a complete description of the default behavior.
typename Domain::template as_child< T >::result_type
mpl::long_<0>
proto::result_of::child_c<Expr, N::value>
A metafunction that returns the type of the Nth
child of a Proto expression, where N is an MPL Integral Constant.
proto::result_of::child<Expr, N> is equivalent to
proto::result_of::child_c<Expr, N::value>.
A metafunction that returns the type of the value of a terminal Proto expression.
The raw type of the value as it is
stored within Expr. This may be a value or a reference.
typename Expr::proto_child0
If Expr is not a reference type, type
is computed as follows:
T const(&)[N] becomes T[N]
T[N] becomes T[N]
T(&)[N] becomes T[N]
R(&)(A...) becomes R(&)(A...)
T const & becomes T
T & becomes T
T becomes T
If Expr is a non-const reference type, type
is computed as follows:
T const(&)[N] becomes T const(&)[N]
T[N] becomes T(&)[N]
T(&)[N] becomes T(&)[N]
R(&)(A...) becomes R(&)(A...)
T const & becomes T const &
T & becomes T &
T becomes T &
If Expr is a const reference type, type
is computed as follows:
T const(&)[N] becomes T const(&)[N]
T[N] becomes T const(&)[N]
T(&)[N] becomes T(&)[N]
R(&)(A...) becomes R(&)(A...)
T const & becomes T const &
T & becomes T &
T becomes T const &
see-below
proto::result_of::child_c< Expr, 0 >
A metafunction that returns the type of the left child of a binary Proto expression.
proto::result_of::left<Expr> is equivalent to
proto::result_of::child_c<Expr, 0>.
proto::result_of::child_c< Expr, 1 >
A metafunction that returns the type of the right child of a binary Proto expression.
proto::result_of::right<Expr> is equivalent to
proto::result_of::child_c<Expr, 1>.
long
A metafunction that returns the type of the Nth
child of a Proto expression.
A metafunction that returns the type of the Nth
child of a Proto expression. N must be 0 or less than
Expr::proto_arity::value.
The raw type of the Nth child as it is stored
within Expr. This may be a value or a reference.
typename Expr::proto_child0
If Expr is not a reference type, type
is computed as follows:
T const & becomes T
T & becomes T
T becomes T
If Expr is a non-const reference type, type
is computed as follows:
T const & becomes T const &
T & becomes T &
T becomes T &
If Expr is a const reference type, type
is computed as follows:
T const & becomes T const &
T & becomes T &
T becomes T const &
see-below
typename proto::result_of::as_expr< T >::type
T &
typename proto::result_of::as_expr< T const >::type
T const &
typename proto::result_of::as_expr< T, Domain >::type
T &
typename proto::result_of::as_expr< T const, Domain >::type
T const &
A function that wraps non-Proto expression types in Proto terminals and leaves Proto
expression types alone.
The proto::as_expr() function returns Proto expression
objects that are suitable for storage in a local variable. It turns non-Proto objects
into Proto terminals. Its behavior is domain-specific. By default,
non-Proto types are wrapped by value (if possible) in a new Proto terminal expression,
and objects that are already Proto expressions are returned by value.
If Domain is not explicitly specified, it is assumed to
be proto::default_domain.
See proto::domain::as_expr<>
for a complete description of this function's default behavior.
typename Domain::template as_expr< T >()(t)
typename proto::result_of::as_child< T >::type
T &
typename proto::result_of::as_child< T const >::type
T const &
typename proto::result_of::as_child< T, Domain >::type
T &
typename proto::result_of::as_child< T const, Domain >::type
T const &
A function that wraps non-Proto objects in Proto terminals (by reference) and leaves
Proto expression types alone.
The proto::as_child() function returns Proto expression
objects that are suitable for storage as child nodes in an expression tree. It turns
non-Proto objects into Proto terminals. Its behavior is domain-specific. By default,
non-Proto types are held wrapped by reference in a new Proto terminal expression, and
objects that are already Proto expressions are simply returned by reference.
If Domain is not explicitly specified, it is assumed to
be proto::default_domain.
See proto::domain::as_child<>
for a complete description of this function's default behavior.
typename Domain::template as_child< T >()(t)
typename proto::result_of::child< Expr &, N >::type
Expr &
The Proto expression.
typename proto::result_of::child< Expr const &, N >::type
Expr const &
typename proto::result_of::child< Expr & >::type
Expr &
typename proto::result_of::child< Expr const & >::type
Expr const &
Return the Nth child of the specified Proto expression.
Return the Nth child of the specified Proto expression.
If N is not specified, as in proto::child(expr),
then N is assumed to be mpl::long_<0>.
The child is returned by reference.
proto::is_expr<Expr>::value is
true.
N is an MPL Integral Constant.
N::value < Expr::proto_arity::value
A reference to the Nth child
of expr.
Will not throw.
typename proto::result_of::child_c< Expr &, N >::type
long
Expr &
typename proto::result_of::child_c< Expr const &, N >::type
long
Expr const &
Return the Nth child of the specified
Proto expression.
Return the Nth child of the specified Proto
expression. The child is returned by reference.
proto::is_expr<Expr>::value is
true.
N < Expr::proto_arity::value
A reference to the Nth child
of expr.
Will not throw.
typename proto::result_of::value< Expr & >::type
Expr &
typename proto::result_of::value< Expr const & >::type
Expr const &
Return the value stored within the specified Proto terminal expression.
Return the the value stored within the specified Proto terminal expression. The value is
returned by reference.
0 == Expr::proto_arity::value
A reference to the terminal's value
Will not throw.
typename proto::result_of::left< Expr & >::type
Expr &
typename proto::result_of::left< Expr const & >::type
Expr const &
Return the left child of the specified binary Proto expression.
Return the left child of the specified binary Proto expression. The child is returned by reference.
proto::is_expr<Expr>::value is
true.
2 == Expr::proto_arity::value
A reference to the left child of expr.
Will not throw.
typename proto::result_of::right< Expr & >::type
Expr &
The Proto expression.
typename proto::result_of::right< Expr const & >::type
Expr const &
Return the right child of the specified binary Proto expression.
Return the right child of the specified binary Proto expression. The child is returned by reference.
proto::is_expr<Expr>::value is
true.
2 == Expr::proto_arity::value
A reference to the right child of expr.
Will not throw.