|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r54872 - in branches/release: . boost/proto boost/proto/transform boost/xpressive libs/proto/doc libs/proto/doc/reference libs/proto/doc/reference/concepts libs/proto/doc/reference/transform
From: eric_at_[hidden]
Date: 2009-07-10 17:13:24
Author: eric_niebler
Date: 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
New Revision: 54872
URL: http://svn.boost.org/trac/boost/changeset/54872
Log:
Merged revisions 54559,54610,54853,54871 via svnmerge from
https://svn.boost.org/svn/boost/trunk
........
r54559 | eric_niebler | 2009-07-01 00:21:54 -0700 (Wed, 01 Jul 2009) | 1 line
eliminate use of deprecated proto macros in proto's and xpressive's public interface
........
r54610 | eric_niebler | 2009-07-03 09:58:55 -0700 (Fri, 03 Jul 2009) | 1 line
fix slicing problem of unary operators
........
r54853 | eric_niebler | 2009-07-09 21:44:23 -0700 (Thu, 09 Jul 2009) | 1 line
revert the BasicPrimitiveTransform changes as leading to weird inconsistencies
........
r54871 | eric_niebler | 2009-07-10 12:45:01 -0700 (Fri, 10 Jul 2009) | 1 line
fix oops
........
Properties modified:
branches/release/ (props changed)
Text files modified:
branches/release/boost/proto/operators.hpp | 53 +
branches/release/boost/proto/proto_fwd.hpp | 2
branches/release/boost/proto/traits.hpp | 1065 +++------------------------------------
branches/release/boost/proto/transform/call.hpp | 6
branches/release/boost/proto/transform/impl.hpp | 18
branches/release/boost/xpressive/regex_actions.hpp | 128 ++--
branches/release/libs/proto/doc/reference.xml | 2
branches/release/libs/proto/doc/reference/concepts/PrimitiveTransform.xml | 16
branches/release/libs/proto/doc/reference/traits.xml | 145 +++-
branches/release/libs/proto/doc/reference/transform/when.xml | 2
10 files changed, 319 insertions(+), 1118 deletions(-)
Modified: branches/release/boost/proto/operators.hpp
==============================================================================
--- branches/release/boost/proto/operators.hpp (original)
+++ branches/release/boost/proto/operators.hpp 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -28,7 +28,7 @@
{
namespace detail
{
- template<typename Domain, typename Expr>
+ template<typename Domain, typename Expr, typename EnableIf = void>
struct generate_if
: lazy_enable_if_c<
matches<Expr, typename Domain::proto_grammar>::value
@@ -38,7 +38,7 @@
// Optimization, generate fewer templates...
template<typename Expr>
- struct generate_if<proto::default_domain, Expr>
+ struct generate_if<proto::default_domain, Expr, void>
{
typedef Expr type;
};
@@ -224,22 +224,24 @@
template<typename Arg> \
typename detail::generate_if< \
typename Arg::proto_domain \
- , proto::expr<TAG, list1<typename Arg::proto_derived_expr &>, 1> \
+ , proto::expr<TAG, list1<Arg &>, 1> \
+ , typename Arg::proto_is_expr_ \
>::type const \
operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \
{ \
- typedef proto::expr<TAG, list1<typename Arg::proto_derived_expr &>, 1> that_type; \
+ typedef proto::expr<TAG, list1<Arg &>, 1> that_type; \
that_type that = {arg}; \
return typename Arg::proto_domain()(that); \
} \
template<typename Arg> \
typename detail::generate_if< \
typename Arg::proto_domain \
- , proto::expr<TAG, list1<typename Arg::proto_derived_expr const &>, 1> \
+ , proto::expr<TAG, list1<Arg const &>, 1> \
+ , typename Arg::proto_is_expr_ \
>::type const \
operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \
{ \
- typedef proto::expr<TAG, list1<typename Arg::proto_derived_expr const &>, 1> that_type; \
+ typedef proto::expr<TAG, list1<Arg const &>, 1> that_type; \
that_type that = {arg}; \
return typename Arg::proto_domain()(that); \
} \
@@ -319,13 +321,12 @@
/// if_else
///
- BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
- 3
- , if_else
- , deduce_domain
- , (tag::if_else_)
- , BOOST_PP_SEQ_NIL
- )
+ template<typename A0, typename A1, typename A2>
+ typename functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>::result_type const
+ if_else(A0 const &a0, A1 const &a1, A2 const &a2)
+ {
+ return functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>()(a0, a1, a2);
+ }
BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
@@ -337,59 +338,59 @@
#define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \
template<typename Arg> \
typename boost::proto::detail::enable_unary<DOMAIN, TRAIT<Arg>, Arg \
- , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Arg &>::type \
+ , typename boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Arg &>::result_type \
>::type const \
operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \
{ \
- return boost::proto::make_expr<TAG, DOMAIN>(boost::ref(arg)); \
+ return boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Arg &>()(arg); \
} \
template<typename Arg> \
typename boost::proto::detail::enable_unary<DOMAIN, TRAIT<Arg>, Arg \
- , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Arg const &>::type \
+ , typename boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Arg const &>::result_type \
>::type const \
operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \
{ \
- return boost::proto::make_expr<TAG, DOMAIN>(boost::ref(arg)); \
+ return boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Arg const &>()(arg); \
} \
/**/
#define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \
template<typename Left, typename Right> \
typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left, TRAIT<Right>, Right \
- , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left &, Right &>::type \
+ , typename boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left &, Right &>::result_type\
>::type const \
operator OP(Left &left, Right &right) \
{ \
- return boost::proto::make_expr<TAG, DOMAIN>(boost::ref(left), boost::ref(right)); \
+ return boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left &, Right &>()(left, right);\
} \
template<typename Left, typename Right> \
typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left, TRAIT<Right>, Right \
- , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left &, Right const &>::type \
+ , typename boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left &, Right const &>::result_type\
>::type const \
operator OP(Left &left, Right const &right) \
{ \
- return boost::proto::make_expr<TAG, DOMAIN>(boost::ref(left), boost::ref(right)); \
+ return boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left &, Right const &>()(left, right);\
} \
template<typename Left, typename Right> \
typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left, TRAIT<Right>, Right \
- , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left const &, Right &>::type \
+ , typename boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left const &, Right &>::result_type\
>::type const \
operator OP(Left const &left, Right &right) \
{ \
- return boost::proto::make_expr<TAG, DOMAIN>(boost::ref(left), boost::ref(right)); \
+ return boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left const &, Right &>()(left, right);\
} \
template<typename Left, typename Right> \
typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left, TRAIT<Right>, Right \
- , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left const &, Right const &>::type\
+ , typename boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left const &, Right const &>::result_type\
>::type const \
operator OP(Left const &left, Right const &right) \
{ \
- return boost::proto::make_expr<TAG, DOMAIN>(boost::ref(left), boost::ref(right)); \
+ return boost::proto::functional::make_expr<TAG, DOMAIN>::impl<Left const &, Right const &>()(left, right);\
} \
/**/
#define BOOST_PROTO_DEFINE_OPERATORS(TRAIT, DOMAIN) \
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, boost::proto::tag::unary_plus, TRAIT, DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, boost::proto::tag::unary_plus, TRAIT, DOMAIN, 0) \
BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, boost::proto::tag::negate, TRAIT, DOMAIN, 0) \
BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, boost::proto::tag::dereference, TRAIT, DOMAIN, 0) \
BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, boost::proto::tag::complement, TRAIT, DOMAIN, 0) \
Modified: branches/release/boost/proto/proto_fwd.hpp
==============================================================================
--- branches/release/boost/proto/proto_fwd.hpp (original)
+++ branches/release/boost/proto/proto_fwd.hpp 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -706,7 +706,7 @@
BOOST_PROTO_CALLABLE()
};
- template<typename PrimitiveTransform>
+ template<typename PrimitiveTransform, typename X = void>
struct transform;
template<typename Grammar, typename Fun = Grammar>
Modified: branches/release/boost/proto/traits.hpp
==============================================================================
--- branches/release/boost/proto/traits.hpp (original)
+++ branches/release/boost/proto/traits.hpp 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -530,6 +530,7 @@
/// PrimitiveTransform that returns the current expression unchanged.
template<typename T>
struct terminal
+ : proto::transform<terminal<T>, int>
{
typedef proto::expr<proto::tag::terminal, term<T>, 0> type;
typedef type proto_base_expr;
@@ -570,6 +571,7 @@
/// transform.
template<typename T, typename U, typename V>
struct if_else_
+ : proto::transform<if_else_<T, U, V>, int>
{
typedef proto::expr<proto::tag::if_else_, list3<T, U, V>, 3> type;
typedef type proto_base_expr;
@@ -598,6 +600,7 @@
/// nullary expression.
template<typename Tag, typename T>
struct nullary_expr
+ : proto::transform<nullary_expr<Tag, T>, int>
{
typedef proto::expr<Tag, term<T>, 0> type;
typedef type proto_base_expr;
@@ -642,6 +645,7 @@
/// unary expression.
template<typename Tag, typename T>
struct unary_expr
+ : proto::transform<unary_expr<Tag, T>, int>
{
typedef proto::expr<Tag, list1<T>, 1> type;
typedef type proto_base_expr;
@@ -667,6 +671,7 @@
/// binary expression.
template<typename Tag, typename T, typename U>
struct binary_expr
+ : proto::transform<binary_expr<Tag, T, U>, int>
{
typedef proto::expr<Tag, list2<T, U>, 2> type;
typedef type proto_base_expr;
@@ -684,970 +689,89 @@
typedef U proto_child1;
};
- /// \brief A metafunction for generating unary plus expression types,
- /// a grammar element for matching unary plus expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct unary_plus
- {
- typedef proto::expr<proto::tag::unary_plus, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<unary_plus, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::unary_plus proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating unary minus expression types,
- /// a grammar element for matching unary minus expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct negate
- {
- typedef proto::expr<proto::tag::negate, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<negate, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::negate proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating defereference expression types,
- /// a grammar element for matching dereference expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct dereference
- {
- typedef proto::expr<proto::tag::dereference, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<dereference, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::dereference proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating complement expression types,
- /// a grammar element for matching complement expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct complement
- {
- typedef proto::expr<proto::tag::complement, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<complement, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::complement proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating address_of expression types,
- /// a grammar element for matching address_of expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct address_of
- {
- typedef proto::expr<proto::tag::address_of, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<address_of, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::address_of proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating logical_not expression types,
- /// a grammar element for matching logical_not expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct logical_not
- {
- typedef proto::expr<proto::tag::logical_not, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<logical_not, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::logical_not proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating pre-increment expression types,
- /// a grammar element for matching pre-increment expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct pre_inc
- {
- typedef proto::expr<proto::tag::pre_inc, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<pre_inc, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::pre_inc proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating pre-decrement expression types,
- /// a grammar element for matching pre-decrement expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct pre_dec
- {
- typedef proto::expr<proto::tag::pre_dec, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<pre_dec, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::pre_dec proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating post-increment expression types,
- /// a grammar element for matching post-increment expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct post_inc
- {
- typedef proto::expr<proto::tag::post_inc, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<post_inc, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::post_inc proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating post-decrement expression types,
- /// a grammar element for matching post-decrement expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T>
- struct post_dec
- {
- typedef proto::expr<proto::tag::post_dec, list1<T>, 1> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<post_dec, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::post_dec proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- };
-
- /// \brief A metafunction for generating left-shift expression types,
- /// a grammar element for matching left-shift expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct shift_left
- {
- typedef proto::expr<proto::tag::shift_left, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<shift_left, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::shift_left proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating right-shift expression types,
- /// a grammar element for matching right-shift expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct shift_right
- {
- typedef proto::expr<proto::tag::shift_right, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<shift_right, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::shift_right proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating multiplies expression types,
- /// a grammar element for matching multiplies expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct multiplies
- {
- typedef proto::expr<proto::tag::multiplies, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<multiplies, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::multiplies proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating divides expression types,
- /// a grammar element for matching divides expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct divides
- {
- typedef proto::expr<proto::tag::divides, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<divides, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::divides proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating modulus expression types,
- /// a grammar element for matching modulus expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct modulus
- {
- typedef proto::expr<proto::tag::modulus, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<modulus, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::modulus proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating binary plus expression types,
- /// a grammar element for matching binary plus expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct plus
- {
- typedef proto::expr<proto::tag::plus, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<plus, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::plus proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating binary minus expression types,
- /// a grammar element for matching binary minus expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct minus
- {
- typedef proto::expr<proto::tag::minus, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<minus, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::minus proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating less expression types,
- /// a grammar element for matching less expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct less
- {
- typedef proto::expr<proto::tag::less, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<less, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::less proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating greater expression types,
- /// a grammar element for matching greater expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct greater
- {
- typedef proto::expr<proto::tag::greater, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<greater, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::greater proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct less_equal
- {
- typedef proto::expr<proto::tag::less_equal, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<less_equal, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::less_equal proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct greater_equal
- {
- typedef proto::expr<proto::tag::greater_equal, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<greater_equal, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::greater_equal proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating equal-to expression types,
- /// a grammar element for matching equal-to expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct equal_to
- {
- typedef proto::expr<proto::tag::equal_to, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<equal_to, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::equal_to proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct not_equal_to
- {
- typedef proto::expr<proto::tag::not_equal_to, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<not_equal_to, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::not_equal_to proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating logical-or expression types,
- /// a grammar element for matching logical-or expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct logical_or
- {
- typedef proto::expr<proto::tag::logical_or, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<logical_or, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::logical_or proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating logical-and expression types,
- /// a grammar element for matching logical-and expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct logical_and
- {
- typedef proto::expr<proto::tag::logical_and, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<logical_and, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::logical_and proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating bitwise-and expression types,
- /// a grammar element for matching bitwise-and expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct bitwise_and
- {
- typedef proto::expr<proto::tag::bitwise_and, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<bitwise_and, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::bitwise_and proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating bitwise-or expression types,
- /// a grammar element for matching bitwise-or expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct bitwise_or
- {
- typedef proto::expr<proto::tag::bitwise_or, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<bitwise_or, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::bitwise_or proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating bitwise-xor expression types,
- /// a grammar element for matching bitwise-xor expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct bitwise_xor
- {
- typedef proto::expr<proto::tag::bitwise_xor, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<bitwise_xor, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::bitwise_xor proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating comma expression types,
- /// a grammar element for matching comma expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct comma
- {
- typedef proto::expr<proto::tag::comma, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<comma, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::comma proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- template<typename T, typename U>
- struct mem_ptr
- {
- typedef proto::expr<proto::tag::mem_ptr, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<mem_ptr, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::mem_ptr proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating assignment expression types,
- /// a grammar element for matching assignment expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct assign
- {
- typedef proto::expr<proto::tag::assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct shift_left_assign
- {
- typedef proto::expr<proto::tag::shift_left_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<shift_left_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::shift_left_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct shift_right_assign
- {
- typedef proto::expr<proto::tag::shift_right_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<shift_right_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::shift_right_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating multiplies-assign expression types,
- /// a grammar element for matching multiplies-assign expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct multiplies_assign
- {
- typedef proto::expr<proto::tag::multiplies_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<multiplies_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::multiplies_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating divides-assign expression types,
- /// a grammar element for matching divides-assign expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct divides_assign
- {
- typedef proto::expr<proto::tag::divides_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<divides_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::divides_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating modulus-assign expression types,
- /// a grammar element for matching modulus-assign expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct modulus_assign
- {
- typedef proto::expr<proto::tag::modulus_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<modulus_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::modulus_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating plus-assign expression types,
- /// a grammar element for matching plus-assign expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct plus_assign
- {
- typedef proto::expr<proto::tag::plus_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<plus_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::plus_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating minus-assign expression types,
- /// a grammar element for matching minus-assign expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct minus_assign
- {
- typedef proto::expr<proto::tag::minus_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<minus_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::minus_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct bitwise_and_assign
- {
- typedef proto::expr<proto::tag::bitwise_and_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<bitwise_and_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::bitwise_and_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct bitwise_or_assign
- {
- typedef proto::expr<proto::tag::bitwise_or_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<bitwise_or_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::bitwise_or_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief 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 <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct bitwise_xor_assign
- {
- typedef proto::expr<proto::tag::bitwise_xor_assign, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<bitwise_xor_assign, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::bitwise_xor_assign proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating subscript expression types,
- /// a grammar element for matching subscript expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct subscript
- {
- typedef proto::expr<proto::tag::subscript, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<subscript, Expr, State, Data>
- {};
-
- /// INTERNAL ONLY
- typedef proto::tag::subscript proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
-
- /// \brief A metafunction for generating virtual data member expression
- /// types, a grammar element for matching member expressions, and a
- /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
- /// transform.
- template<typename T, typename U>
- struct member
- {
- typedef expr<tag::member, list2<T, U>, 2> type;
- typedef type proto_base_expr;
-
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::pass_through_impl<member, Expr, State, Data>
- {};
+ #define BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(Op) \
+ template<typename T> \
+ struct Op \
+ : proto::transform<Op<T>, int> \
+ { \
+ typedef proto::expr<proto::tag::Op, list1<T>, 1> type; \
+ typedef type proto_base_expr; \
+ \
+ template<typename Expr, typename State, typename Data> \
+ struct impl \
+ : detail::pass_through_impl<Op, Expr, State, Data> \
+ {}; \
+ \
+ typedef proto::tag::Op proto_tag; \
+ typedef T proto_child0; \
+ }; \
+ /**/
+
+ #define BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(Op) \
+ template<typename T, typename U> \
+ struct Op \
+ : proto::transform<Op<T, U>, int> \
+ { \
+ typedef proto::expr<proto::tag::Op, list2<T, U>, 2> type; \
+ typedef type proto_base_expr; \
+ \
+ template<typename Expr, typename State, typename Data> \
+ struct impl \
+ : detail::pass_through_impl<Op, Expr, State, Data> \
+ {}; \
+ \
+ typedef proto::tag::Op proto_tag; \
+ typedef T proto_child0; \
+ typedef U proto_child1; \
+ }; \
+ /**/
+
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(unary_plus)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(negate)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(dereference)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(complement)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(logical_not)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(pre_inc)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(pre_dec)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(post_inc)
+ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(post_dec)
+
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_left)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_right)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(multiplies)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(divides)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(modulus)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(plus)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(minus)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(less)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(greater)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(less_equal)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(greater_equal)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(equal_to)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(not_equal_to)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(logical_or)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(logical_and)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_or)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_and)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_xor)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(comma)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(mem_ptr)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_left_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_right_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(multiplies_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(divides_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(modulus_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(plus_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(minus_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_or_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_and_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_xor_assign)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(subscript)
+ BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(member)
- /// INTERNAL ONLY
- typedef proto::tag::member proto_tag;
- /// INTERNAL ONLY
- typedef T proto_child0;
- /// INTERNAL ONLY
- typedef U proto_child1;
- };
+ #undef BOOST_PROTO_DEFINE_UNARY_METAFUNCTION
+ #undef BOOST_PROTO_DEFINE_BINARY_METAFUNCTION
} // namespace op
@@ -2268,6 +1392,13 @@
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
>
#endif
+ : proto::transform<
+ function<
+ BOOST_PP_ENUM_PARAMS(N, A)
+ BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
+ >
+ , int
+ >
{
typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
typedef type proto_base_expr;
@@ -2305,6 +1436,14 @@
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
>
#endif
+ : proto::transform<
+ nary_expr<
+ Tag
+ BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+ BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
+ >
+ , int
+ >
{
typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
typedef type proto_base_expr;
Modified: branches/release/boost/proto/transform/call.hpp
==============================================================================
--- branches/release/boost/proto/transform/call.hpp (original)
+++ branches/release/boost/proto/transform/call.hpp 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -79,9 +79,9 @@
/// {};
/// \endcode
template<typename PrimitiveTransform>
- struct call : PrimitiveTransform
- {
- };
+ struct call
+ : PrimitiveTransform
+ {};
/// \brief Either call the PolymorphicFunctionObject with 0
/// arguments, or invoke the PrimitiveTransform with 3
Modified: branches/release/boost/proto/transform/impl.hpp
==============================================================================
--- branches/release/boost/proto/transform/impl.hpp (original)
+++ branches/release/boost/proto/transform/impl.hpp 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -17,16 +17,10 @@
{
/// INTERNAL ONLY
///
- #define BOOST_PROTO_BASIC_TRANSFORM(PrimitiveTransform) \
+ #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \
BOOST_PROTO_CALLABLE() \
- typedef void proto_is_transform_; \
+ typedef X proto_is_transform_; \
typedef PrimitiveTransform transform_type; \
- /**/
-
- /// INTERNAL ONLY
- ///
- #define BOOST_PROTO_TRANSFORM(PrimitiveTransform) \
- BOOST_PROTO_BASIC_TRANSFORM(PrimitiveTransform) \
\
template<typename Sig> \
struct result \
@@ -73,6 +67,10 @@
} \
/**/
+ #define BOOST_PROTO_TRANSFORM(PrimitiveTransform) \
+ BOOST_PROTO_TRANSFORM_(PrimitiveTransform, void) \
+ /**/
+
namespace detail
{
template<typename Sig>
@@ -94,10 +92,10 @@
{};
}
- template<typename PrimitiveTransform>
+ template<typename PrimitiveTransform, typename X>
struct transform
{
- BOOST_PROTO_TRANSFORM(PrimitiveTransform)
+ BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X)
};
template<typename Expr, typename State, typename Data>
Modified: branches/release/boost/xpressive/regex_actions.hpp
==============================================================================
--- branches/release/boost/xpressive/regex_actions.hpp (original)
+++ branches/release/boost/xpressive/regex_actions.hpp 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -15,6 +15,7 @@
#endif
#include <boost/config.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/ref.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
@@ -96,29 +97,35 @@
struct BindArg : proto::callable
{
- typedef int result_type;
+ template<typename Sig>
+ struct result;
+
+ template<typename This, typename MatchResults, typename Expr>
+ struct result<This(MatchResults, Expr)>
+ {
+ typedef Expr type;
+ };
- template<typename Data, typename Expr>
- int operator ()(Data &data, Expr const &expr) const
+ template<typename MatchResults, typename Expr>
+ Expr const & operator ()(MatchResults &what, Expr const &expr) const
{
- data.let(expr);
- return 0;
+ what.let(expr);
+ return expr;
}
};
struct let_tag
{};
+ // let(_a = b, _c = d)
struct BindArgs
- : proto::when<
- // let(_a = b, _c = d)
- proto::function<
- proto::terminal<let_tag>
- , proto::vararg<proto::assign<proto::_, proto::_> >
- >
- , proto::function<
- proto::_state // no-op
- , proto::vararg<proto::call<BindArg(proto::_data, proto::_)> >
+ : proto::function<
+ proto::terminal<let_tag>
+ , proto::vararg<
+ proto::when<
+ proto::assign<proto::_, proto::_>
+ , proto::call<BindArg(proto::_data, proto::_)>
+ >
>
>
{};
@@ -137,11 +144,7 @@
template<typename Args, typename BidiIter>
void bind_args(let_<Args> const &args, match_results<BidiIter> &what)
{
- BindArgs::impl<let_<Args> const &, int, match_results<BidiIter> &>()(
- args
- , 0
- , what
- );
+ BindArgs()(args, 0, what);
}
template<typename BidiIter>
@@ -191,6 +194,8 @@
private:
match_results<BidiIter> const &what_;
};
+
+ typedef boost::proto::functional::make_expr<proto::tag::function, proto::default_domain> make_function;
}
namespace op
@@ -745,43 +750,39 @@
/// as (a.k.a., lexical_cast)
///
- BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
- 1
- , as
- , boost::proto::default_domain
- , (boost::proto::tag::function)
- , ((op::as)(typename))
- )
+ template<typename X2_0, typename A0>
+ typename detail::make_function::impl<op::as<X2_0> const, A0 const &>::result_type const
+ as(A0 const &a0)
+ {
+ return detail::make_function::impl<op::as<X2_0> const, A0 const &>()((op::as<X2_0>()), a0);
+ }
/// static_cast_
///
- BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
- 1
- , static_cast_
- , boost::proto::default_domain
- , (boost::proto::tag::function)
- , ((op::static_cast_)(typename))
- )
+ template<typename X2_0, typename A0>
+ typename detail::make_function::impl<op::static_cast_<X2_0> const, A0 const &>::result_type const
+ static_cast_(A0 const &a0)
+ {
+ return detail::make_function::impl<op::static_cast_<X2_0> const, A0 const &>()((op::static_cast_<X2_0>()), a0);
+ }
/// dynamic_cast_
///
- BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
- 1
- , dynamic_cast_
- , boost::proto::default_domain
- , (boost::proto::tag::function)
- , ((op::dynamic_cast_)(typename))
- )
+ template<typename X2_0, typename A0>
+ typename detail::make_function::impl<op::dynamic_cast_<X2_0> const, A0 const &>::result_type const
+ dynamic_cast_(A0 const &a0)
+ {
+ return detail::make_function::impl<op::dynamic_cast_<X2_0> const, A0 const &>()((op::dynamic_cast_<X2_0>()), a0);
+ }
/// const_cast_
///
- BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
- 1
- , const_cast_
- , boost::proto::default_domain
- , (boost::proto::tag::function)
- , ((op::const_cast_)(typename))
- )
+ template<typename X2_0, typename A0>
+ typename detail::make_function::impl<op::const_cast_<X2_0> const, A0 const &>::result_type const
+ const_cast_(A0 const &a0)
+ {
+ return detail::make_function::impl<op::const_cast_<X2_0> const, A0 const &>()((op::const_cast_<X2_0>()), a0);
+ }
/// val()
///
@@ -829,21 +830,28 @@
/// Usage: construct\<Type\>(arg1, arg2)
///
- BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(
- construct
- , boost::proto::default_domain
- , (boost::proto::tag::function)
- , ((op::construct)(typename))
- )
-
/// Usage: throw_\<Exception\>(arg1, arg2)
///
- BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(
- throw_
- , boost::proto::default_domain
- , (boost::proto::tag::function)
- , ((op::throw_)(typename))
- )
+ #define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A_const_ref, A_const_ref_a, a)\
+ \
+ template<typename X2_0 BOOST_PP_COMMA_IF(N) typename_A(N)>\
+ typename detail::make_function::impl<op::construct<X2_0> const BOOST_PP_COMMA_IF(N) A_const_ref(N)>::result_type const\
+ construct(A_const_ref_a(N))\
+ {\
+ return detail::make_function::impl<op::construct<X2_0> const BOOST_PP_COMMA_IF(N) A_const_ref(N)>()((op::construct<X2_0>()) BOOST_PP_COMMA_IF(N) a(N));\
+ }\
+ \
+ template<typename X2_0 BOOST_PP_COMMA_IF(N) typename_A(N)>\
+ typename detail::make_function::impl<op::throw_<X2_0> const BOOST_PP_COMMA_IF(N) A_const_ref(N)>::result_type const\
+ throw_(A_const_ref_a(N))\
+ {\
+ return detail::make_function::impl<op::throw_<X2_0> const BOOST_PP_COMMA_IF(N) A_const_ref(N)>()((op::throw_<X2_0>()) BOOST_PP_COMMA_IF(N) a(N));\
+ }\
+ /**/
+
+ #define BOOST_PROTO_LOCAL_a BOOST_PROTO_a
+ #define BOOST_PROTO_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY))
+ #include BOOST_PROTO_LOCAL_ITERATE()
namespace detail
{
Modified: branches/release/libs/proto/doc/reference.xml
==============================================================================
--- branches/release/libs/proto/doc/reference.xml (original)
+++ branches/release/libs/proto/doc/reference.xml 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -1040,7 +1040,7 @@
<xi:include href="reference/context/null.xml"/>
<!-- concepts -->
- <xi:include href="reference/concepts/BasicPrimitiveTransform.xml"/>
+ <!--<xi:include href="reference/concepts/BasicPrimitiveTransform.xml"/>-->
<xi:include href="reference/concepts/CallableTransform.xml"/>
<xi:include href="reference/concepts/ObjectTransform.xml"/>
<xi:include href="reference/concepts/PrimitiveTransform.xml"/>
Modified: branches/release/libs/proto/doc/reference/concepts/PrimitiveTransform.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/concepts/PrimitiveTransform.xml (original)
+++ branches/release/libs/proto/doc/reference/concepts/PrimitiveTransform.xml 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -18,14 +18,20 @@
<description>
<para>
- A PrimitiveTransform is a <conceptname>BasicPrimitiveTransform</conceptname>
- that is also a <conceptname>PolymorphicFunctionObject</conceptname>
- implemented in terms of the nested <computeroutput>impl<></computeroutput> template.
+ A PrimitiveTransform is a class type that
+ has a nested class template called
+ <computeroutput>impl<></computeroutput> that takes
+ three template parameters representing an expression
+ type, a state type and a data type. Specializations
+ of the nested impl template are ternary monomorphic
+ function objects that accept expression, state, and
+ data parameters. A PrimitiveTransform is also a
+ <conceptname>PolymorphicFunctionObject</conceptname>
+ implemented in terms of the nested
+ <computeroutput>impl<></computeroutput> template.
</para>
</description>
- <refines const="no" concept="BasicPrimitiveTransform"/>
-
<notation variables="fn">
<sample-value>
<type name="Fn" />
Modified: branches/release/libs/proto/doc/reference/traits.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/traits.xml (original)
+++ branches/release/libs/proto/doc/reference/traits.xml 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -547,9 +547,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< terminal<T> ></inherit>
<purpose>A metafunction for generating terminal expression types, a grammar element for matching
terminal expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
+ a <conceptname>PrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
<struct name="impl">
<template>
<template-type-parameter name="Expr"/>
@@ -605,9 +606,10 @@
<template-type-parameter name="U"/>
<template-type-parameter name="V"/>
</template>
+ <inherit><classname>proto::transform</classname>< if_else_<T, U, V> ></inherit>
<purpose>A metafunction for generating ternary conditional expression types, a grammar element for
matching ternary conditional expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname>
+ a <conceptname>PrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -633,9 +635,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< unary_plus<T> ></inherit>
<purpose>A metafunction for generating unary plus expression types,
a grammar element for matching unary plus expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -660,9 +663,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< negate<T> ></inherit>
<purpose>A metafunction for generating unary minus expression types,
a grammar element for matching unary minus expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -687,9 +691,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< dereference<T> ></inherit>
<purpose>A metafunction for generating defereference expression types,
a grammar element for matching dereference expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -714,9 +719,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< complement<T> ></inherit>
<purpose>A metafunction for generating complement expression types,
a grammar element for matching complement expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -741,9 +747,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< address_of<T> ></inherit>
<purpose>A metafunction for generating address_of expression types,
a grammar element for matching address_of expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -768,9 +775,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< logical_not<T> ></inherit>
<purpose>A metafunction for generating logical_not expression types,
a grammar element for matching logical_not expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -795,9 +803,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< pre_inc<T> ></inherit>
<purpose>A metafunction for generating pre-increment expression types,
a grammar element for matching pre-increment expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -822,9 +831,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< pre_dec<T> ></inherit>
<purpose>A metafunction for generating pre-decrement expression types,
a grammar element for matching pre-decrement expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -849,9 +859,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< post_inc<T> ></inherit>
<purpose>A metafunction for generating post-increment expression types,
a grammar element for matching post-increment expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -876,9 +887,10 @@
<template>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< post_dec<T> ></inherit>
<purpose>A metafunction for generating post-decrement expression types,
a grammar element for matching post-decrement expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -904,9 +916,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< shift_left<T, U> ></inherit>
<purpose>A metafunction for generating left-shift expression types,
a grammar element for matching left-shift expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -932,9 +945,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< shift_right<T, U> ></inherit>
<purpose>A metafunction for generating right-shift expression types,
a grammar element for matching right-shift expressions, and a
- <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -960,9 +974,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< multiplies<T, U> ></inherit>
<purpose>A metafunction for generating multiplies expression types,
a grammar element for matching multiplies expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -988,9 +1003,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< divides<T, U> ></inherit>
<purpose>A metafunction for generating divides expression types,
a grammar element for matching divides expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1016,9 +1032,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< modulus<T, U> ></inherit>
<purpose>A metafunction for generating modulus expression types,
a grammar element for matching modulus expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1044,9 +1061,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< plus<T, U> ></inherit>
<purpose>A metafunction for generating binary plus expression types,
a grammar element for matching binary plus expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1072,9 +1090,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< minus<T, U> ></inherit>
<purpose>A metafunction for generating binary minus expression types,
a grammar element for matching binary minus expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1100,9 +1119,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< less<T, U> ></inherit>
<purpose>A metafunction for generating less expression types,
a grammar element for matching less expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1128,9 +1148,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< greater<T, U> ></inherit>
<purpose>A metafunction for generating greater expression types,
a grammar element for matching greater expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1156,9 +1177,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< less_equal<T, U> ></inherit>
<purpose>A metafunction for generating less-or-equal expression types,
a grammar element for matching less-or-equal expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1184,9 +1206,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< greater_equal<T, U> ></inherit>
<purpose>A metafunction for generating greater-or-equal expression types,
a grammar element for matching greater-or-equal expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1212,9 +1235,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< equal_to<T, U> ></inherit>
<purpose>A metafunction for generating equal-to expression types,
a grammar element for matching equal-to expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1240,9 +1264,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< not_equal_to<T, U> ></inherit>
<purpose>A metafunction for generating not-equal-to expression types,
a grammar element for matching not-equal-to expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1268,9 +1293,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< logical_or<T, U> ></inherit>
<purpose>A metafunction for generating logical-or expression types,
a grammar element for matching logical-or expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1296,9 +1322,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< logical_and<T, U> ></inherit>
<purpose>A metafunction for generating logical-and expression types,
a grammar element for matching logical-and expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1324,9 +1351,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< bitwise_and<T, U> ></inherit>
<purpose>A metafunction for generating bitwise-and expression types,
a grammar element for matching bitwise-and expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1352,9 +1380,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< bitwise_or<T, U> ></inherit>
<purpose>A metafunction for generating bitwise-or expression types,
a grammar element for matching bitwise-or expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1380,9 +1409,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< bitwise_xor<T, U> ></inherit>
<purpose>A metafunction for generating bitwise-xor expression types,
a grammar element for matching bitwise-xor expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1408,9 +1438,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< comma<T, U> ></inherit>
<purpose>A metafunction for generating comma expression types,
a grammar element for matching comma expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1436,6 +1467,7 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< mem_ptr<T, U> ></inherit>
<struct name="impl">
<template>
<template-type-parameter name="Expr"/>
@@ -1459,9 +1491,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< assign<T, U> ></inherit>
<purpose>A metafunction for generating assignment expression types,
a grammar element for matching assignment expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1487,9 +1520,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< shift_left_assign<T, U> ></inherit>
<purpose>A metafunction for generating left-shift-assign expression types,
a grammar element for matching left-shift-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1515,9 +1549,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< shift_right_assign<T, U> ></inherit>
<purpose>A metafunction for generating right-shift-assign expression types,
a grammar element for matching right-shift-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1543,9 +1578,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< multiplies_assign<T, U> ></inherit>
<purpose>A metafunction for generating multiplies-assign expression types,
a grammar element for matching multiplies-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1571,9 +1607,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< divides_assign<T, U> ></inherit>
<purpose>A metafunction for generating divides-assign expression types,
a grammar element for matching divides-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1599,9 +1636,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< modulus_assign<T, U> ></inherit>
<purpose>A metafunction for generating modulus-assign expression types,
a grammar element for matching modulus-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1627,9 +1665,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< plus_assign<T, U> ></inherit>
<purpose>A metafunction for generating plus-assign expression types,
a grammar element for matching plus-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1655,9 +1694,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< minus_assign<T, U> ></inherit>
<purpose>A metafunction for generating minus-assign expression types,
a grammar element for matching minus-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1683,9 +1723,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< bitwise_and_assign<T, U> ></inherit>
<purpose>A metafunction for generating bitwise-and-assign expression types,
a grammar element for matching bitwise-and-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1711,9 +1752,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< bitwise_or_assign<T, U> ></inherit>
<purpose>A metafunction for generating bitwise-or-assign expression types,
a grammar element for matching bitwise-or-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1739,9 +1781,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< bitwise_xor_assign<T, U> ></inherit>
<purpose>A metafunction for generating bitwise-xor-assign expression types,
a grammar element for matching bitwise-xor-assign expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1767,9 +1810,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< subscript<T, U> ></inherit>
<purpose>A metafunction for generating subscript expression types,
a grammar element for matching subscript expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>PrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1794,9 +1838,10 @@
<template>
<template-type-parameter name="A" pack="1"/>
</template>
+ <inherit><classname>proto::transform</classname>< function<A...> ></inherit>
<purpose>A metafunction for generating function-call expression types, a grammar element for
matching function-call expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname>
+ a <conceptname>PrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -1823,9 +1868,10 @@
<template-type-parameter name="Tag"/>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< nullary_expr<Tag, T> ></inherit>
<purpose>A metafunction for generating nullary expression types, a grammar element for matching
nullary expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
+ a <conceptname>PrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
<description>
<para>
Use <computeroutput>proto::nullary_expr<<classname>proto::_</classname>, <classname>proto::_</classname>></computeroutput>
@@ -1886,9 +1932,10 @@
<template-type-parameter name="Tag"/>
<template-type-parameter name="T"/>
</template>
+ <inherit><classname>proto::transform</classname>< unary_expr<Tag, T> ></inherit>
<purpose>A metafunction for generating unary expression types with a specified tag type,
a grammar element for matching unary expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname>
+ a <conceptname>PrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -1922,9 +1969,10 @@
<template-type-parameter name="T"/>
<template-type-parameter name="U"/>
</template>
+ <inherit><classname>proto::transform</classname>< binary_expr<Tag, T, U> ></inherit>
<purpose>A metafunction for generating binary expression types with a specified tag type,
a grammar element for matching binary expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname>
+ a <conceptname>PrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -1956,9 +2004,10 @@
<template-type-parameter name="Tag"/>
<template-type-parameter name="A" pack="1"/>
</template>
+ <inherit><classname>proto::transform</classname>< nary_expr<Tag, A...> ></inherit>
<purpose>A metafunction for generating n-ary expression types with a specified tag type,
a grammar element for matching n-ary expressions, and
- a <conceptname>BasicPrimitiveTransform</conceptname>
+ a <conceptname>PrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
Modified: branches/release/libs/proto/doc/reference/transform/when.xml
==============================================================================
--- branches/release/libs/proto/doc/reference/transform/when.xml (original)
+++ branches/release/libs/proto/doc/reference/transform/when.xml 2009-07-10 17:13:22 EDT (Fri, 10 Jul 2009)
@@ -14,7 +14,7 @@
<struct name="when">
<template>
<template-type-parameter name="Grammar"/>
- <template-type-parameter name="BasicPrimitiveTransform">
+ <template-type-parameter name="PrimitiveTransform">
<default>Grammar</default>
</template-type-parameter>
</template>
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk