Struct template matches
boost::proto::matches — A Boolean metafunction that evaluates whether a given expression type matches a grammar.
Synopsis
template<typename Expr, typename Grammar>
struct matches : mpl::bool_<true-or-false > {
};
Description
proto::matches<Expr, Grammar> inherits from
mpl::true_ if
Expr::proto_base_expr matches
Grammar::proto_base_expr , 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::expr<AT,
proto::listN
<A0,...An>
>
matches a grammar
proto::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::expr<AT,
proto::listN
<A0,...An,U0,...Um>
>
matches a grammar
proto::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:
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>
if
E matches C::case_<E::proto_tag> .
A terminal expression
proto::expr<proto::tag::terminal,
proto::term<A> >
matches a grammar
proto::expr<BT, proto::term<B> >
if BT is
proto::_
or
proto::tag::terminal
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
|