Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r54853 - in trunk: 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 00:44:26


Author: eric_niebler
Date: 2009-07-10 00:44:23 EDT (Fri, 10 Jul 2009)
New Revision: 54853
URL: http://svn.boost.org/trac/boost/changeset/54853

Log:
revert the BasicPrimitiveTransform changes as leading to weird inconsistencies
Text files modified:
   trunk/boost/proto/proto_fwd.hpp | 2
   trunk/boost/proto/traits.hpp | 1065 +++------------------------------------
   trunk/boost/proto/transform/call.hpp | 6
   trunk/boost/proto/transform/impl.hpp | 18
   trunk/boost/proto/transform/when.hpp | 2
   trunk/boost/xpressive/regex_actions.hpp | 40
   trunk/libs/proto/doc/reference.xml | 2
   trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml | 16
   trunk/libs/proto/doc/reference/traits.xml | 145 +++-
   trunk/libs/proto/doc/reference/transform/when.xml | 2
   10 files changed, 246 insertions(+), 1052 deletions(-)

Modified: trunk/boost/proto/proto_fwd.hpp
==============================================================================
--- trunk/boost/proto/proto_fwd.hpp (original)
+++ trunk/boost/proto/proto_fwd.hpp 2009-07-10 00:44:23 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: trunk/boost/proto/traits.hpp
==============================================================================
--- trunk/boost/proto/traits.hpp (original)
+++ trunk/boost/proto/traits.hpp 2009-07-10 00:44:23 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: trunk/boost/proto/transform/call.hpp
==============================================================================
--- trunk/boost/proto/transform/call.hpp (original)
+++ trunk/boost/proto/transform/call.hpp 2009-07-10 00:44:23 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: trunk/boost/proto/transform/impl.hpp
==============================================================================
--- trunk/boost/proto/transform/impl.hpp (original)
+++ trunk/boost/proto/transform/impl.hpp 2009-07-10 00:44:23 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: trunk/boost/proto/transform/when.hpp
==============================================================================
--- trunk/boost/proto/transform/when.hpp (original)
+++ trunk/boost/proto/transform/when.hpp 2009-07-10 00:44:23 EDT (Fri, 10 Jul 2009)
@@ -55,7 +55,7 @@
         /// <tt>T()(e,s,v)</tt>.
         template<typename Grammar, typename PrimitiveTransform BOOST_PROTO_WHEN_BUILDING_DOCS(= Grammar)>
         struct when
- : PrimitiveTransform
+ : PrimitiveTransform::transform_type
         {
             typedef typename Grammar::proto_base_expr proto_base_expr;
         };

Modified: trunk/boost/xpressive/regex_actions.hpp
==============================================================================
--- trunk/boost/xpressive/regex_actions.hpp (original)
+++ trunk/boost/xpressive/regex_actions.hpp 2009-07-10 00:44:23 EDT (Fri, 10 Jul 2009)
@@ -97,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::_)>
+ >
>
>
         {};
@@ -138,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>

Modified: trunk/libs/proto/doc/reference.xml
==============================================================================
--- trunk/libs/proto/doc/reference.xml (original)
+++ trunk/libs/proto/doc/reference.xml 2009-07-10 00:44:23 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: trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml
==============================================================================
--- trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml (original)
+++ trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml 2009-07-10 00:44:23 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&lt;&gt;</computeroutput> template.
+ A PrimitiveTransform is a class type that
+ has a nested class template called
+ <computeroutput>impl&lt;&gt;</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&lt;&gt;</computeroutput> template.
     </para>
   </description>
 
- <refines const="no" concept="BasicPrimitiveTransform"/>
-
   <notation variables="fn">
     <sample-value>
       <type name="Fn" />

Modified: trunk/libs/proto/doc/reference/traits.xml
==============================================================================
--- trunk/libs/proto/doc/reference/traits.xml (original)
+++ trunk/libs/proto/doc/reference/traits.xml 2009-07-10 00:44:23 EDT (Fri, 10 Jul 2009)
@@ -547,9 +547,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; terminal&lt;T&gt; &gt;</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>&lt; if_else_&lt;T, U, V&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
@@ -633,9 +635,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; unary_plus&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -660,9 +663,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; negate&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -687,9 +691,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; dereference&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -714,9 +719,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; complement&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -741,9 +747,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; address_of&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -768,9 +775,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; logical_not&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -795,9 +803,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; pre_inc&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -822,9 +831,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; pre_dec&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -849,9 +859,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; post_inc&lt;T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
         <struct name="impl">
@@ -876,9 +887,10 @@
         <template>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; post_dec&lt;T&gt; &gt;</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&lt;&gt;</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>&lt; shift_left&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; shift_right&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; multiplies&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; divides&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; modulus&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; plus&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; minus&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; less&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; greater&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; less_equal&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; greater_equal&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; equal_to&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; not_equal_to&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; logical_or&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; logical_and&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; bitwise_and&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; bitwise_or&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; bitwise_xor&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; comma&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; mem_ptr&lt;T, U&gt; &gt;</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>&lt; assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; shift_left_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; shift_right_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; multiplies_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; divides_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; modulus_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; plus_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; minus_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; bitwise_and_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; bitwise_or_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; bitwise_xor_assign&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; subscript&lt;T, U&gt; &gt;</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&lt;&gt;</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>&lt; function&lt;A...&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
@@ -1823,9 +1868,10 @@
           <template-type-parameter name="Tag"/>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; nullary_expr&lt;Tag, T&gt; &gt;</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&lt;<classname>proto::_</classname>, <classname>proto::_</classname>&gt;</computeroutput>
@@ -1886,9 +1932,10 @@
           <template-type-parameter name="Tag"/>
           <template-type-parameter name="T"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; unary_expr&lt;Tag, T&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>
@@ -1922,9 +1969,10 @@
           <template-type-parameter name="T"/>
           <template-type-parameter name="U"/>
         </template>
+ <inherit><classname>proto::transform</classname>&lt; binary_expr&lt;Tag, T, U&gt; &gt;</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&lt;&gt;</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>&lt; nary_expr&lt;Tag, A...&gt; &gt;</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&lt;&gt;</classname></computeroutput>
           transform.</purpose>

Modified: trunk/libs/proto/doc/reference/transform/when.xml
==============================================================================
--- trunk/libs/proto/doc/reference/transform/when.xml (original)
+++ trunk/libs/proto/doc/reference/transform/when.xml 2009-07-10 00:44:23 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