|
Home | Libraries | People | FAQ | More |
boost::proto::matches — A Boolean metafunction that evaluates whether a given expression type matches a grammar.
// In header: <boost/proto/matches.hpp>
template<typename Expr, typename Grammar>
struct matches : mpl::bool_<true-or-false> {
};
proto::matches<Expr, Grammar> inherits from
mpl::true_ if
Expr::proto_grammar matches
Grammar::proto_grammar, and from
mpl::false_ otherwise.
Non-terminal expressions are matched against a grammar according to the following rules:
The wildcard pattern,
proto::_
, matches any expression.
An expression
proto::basic_expr<AT,
proto::listN
<A0,...An>
>
matches a grammar
proto::basic_expr<BT,
proto::listN
<B0,...Bn>
>
if
BT is
proto::_
or
AT, and if
Ax
matches
Bx
for each x in [0,n].
An expression
proto::basic_expr<AT,
proto::listN
<A0,...An,U0,...Um>
>
matches a grammar
proto::basic_expr<BT,
proto::listM
<B0,...Bn,proto::vararg<V>
> >
if
BT is
proto::_
or
AT, and if
Ax
matches
Bx
for each
x in [0,n] and if
Ux
matches
V for each x in
[0,m].
An expression E matches
proto::or_<B0,...Bn>
if
E matches some
Bx
for
x in [0,n].
An expression E matches
proto::and_<B0,...Bn>
if
E matches all
Bx
for
x in [0,n].
An expression E matches
proto::if_<T,U,V>
if:
boost::result_of<proto::when<proto::_,T>(E)>::type::value
is true and
E matches
U, or
boost::result_of<proto::when<proto::_,T>(E)>::type::value
is false and E matches
V.
Note: U defaults to
proto::_
and V defaults to
proto::not_<proto::_>
.
An expression E matches
proto::not_<T>
if
E does not match T.
An expression E matches
proto::switch_<C, T>
if
E matches C::case_<boost::result_of<proto::when<proto::_,T>(E)>::type>.
Note: T defaults to proto::tag_of<proto::_>()
A terminal expression can trivially match the grammar proto::_. In addition,
a terminal expression
proto::basic_expr<AT,
proto::term<A> >
matches a grammar
proto::basic_expr<BT, proto::term<B> >
if BT is proto::_
or AT and one of the following is true:
B is the wildcard pattern,
proto::_
A is B
A is B &
A is B const &
B is
proto::exact<A>
B is
proto::convertible_to<X>
and boost::is_convertible<A,X>::value is
true.
A is X[M] or
X(&)[M] and
B is
X[proto::N]
.
A is X(&)[M]
and B is
X(&)[proto::N]
.
A is X[M] or
X(&)[M] and B is
X*.
B lambda-matches
A (see below).
A type B lambda-matches
A if one of the following is true:
B is A
B is the wildcard pattern,
proto::_
B is
T<B0,...Bn>
and A is
T<A0,...An>
and for each x in [0,n],
Ax and
Bx are types such that
Ax lambda-matches
Bx