|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r53578 - in trunk: boost/proto boost/proto/transform libs/proto/doc libs/proto/doc/reference libs/proto/doc/reference/concepts libs/proto/doc/reference/transform
From: eric_at_[hidden]
Date: 2009-06-02 17:33:29
Author: eric_niebler
Date: 2009-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
New Revision: 53578
URL: http://svn.boost.org/trac/boost/changeset/53578
Log:
add lighter-weight BasicPrimitiveTransform concept, op metafunctions model that instead of PrimitiveConcept for better compile times
Added:
trunk/libs/proto/doc/reference/concepts/BasicPrimitiveTransform.xml (contents, props changed)
Text files modified:
trunk/boost/proto/proto_fwd.hpp | 7 -
trunk/boost/proto/traits.hpp | 207 ++++++++++++++++++---------------------
trunk/boost/proto/transform/impl.hpp | 118 +++++++++++-----------
trunk/libs/proto/doc/reference.xml | 1
trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml | 14 -
trunk/libs/proto/doc/reference/traits.xml | 145 +++++++++------------------
trunk/libs/proto/doc/reference/transform/when.xml | 2
7 files changed, 212 insertions(+), 282 deletions(-)
Modified: trunk/boost/proto/proto_fwd.hpp
==============================================================================
--- trunk/boost/proto/proto_fwd.hpp (original)
+++ trunk/boost/proto/proto_fwd.hpp 2009-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -697,7 +697,6 @@
#define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_;
#define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_;
- #define BOOST_PROTO_TRANSFORM() typedef void proto_is_transform_;
#define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_;
struct callable
@@ -705,11 +704,7 @@
BOOST_PROTO_CALLABLE()
};
- struct empty_base;
-
- struct transform_base;
-
- template<typename PrimitiveTransform, typename Base = transform_base>
+ template<typename PrimitiveTransform>
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-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -529,7 +529,7 @@
/// a grammar element for matching terminal expressions, and a
/// PrimitiveTransform that returns the current expression unchanged.
template<typename T>
- struct terminal : transform<terminal<T>, empty_base>
+ struct terminal
{
typedef proto::expr<proto::tag::terminal, term<T>, 0> type;
typedef type proto_base_expr;
@@ -569,14 +569,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U, typename V>
- struct if_else_ : transform<if_else_<T, U, V>, empty_base>
+ struct if_else_
{
typedef proto::expr<proto::tag::if_else_, list3<T, U, V>, 3> type;
typedef type proto_base_expr;
template<typename Expr, typename State, typename Data>
struct impl
- : pass_through<if_else_>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<if_else_, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -597,7 +597,7 @@
/// Use <tt>nullary_expr\<_, _\></tt> as a grammar element to match any
/// nullary expression.
template<typename Tag, typename T>
- struct nullary_expr : transform<nullary_expr<Tag, T>, empty_base>
+ struct nullary_expr
{
typedef proto::expr<Tag, term<T>, 0> type;
typedef type proto_base_expr;
@@ -641,14 +641,14 @@
/// Use <tt>unary_expr\<_, _\></tt> as a grammar element to match any
/// unary expression.
template<typename Tag, typename T>
- struct unary_expr : transform<unary_expr<Tag, T>, empty_base>
+ struct unary_expr
{
typedef proto::expr<Tag, list1<T>, 1> type;
typedef type proto_base_expr;
template<typename Expr, typename State, typename Data>
struct impl
- : pass_through<unary_expr>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<unary_expr, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -666,14 +666,14 @@
/// Use <tt>binary_expr\<_, _, _\></tt> as a grammar element to match any
/// binary expression.
template<typename Tag, typename T, typename U>
- struct binary_expr : transform<binary_expr<Tag, T, U>, empty_base>
+ struct binary_expr
{
typedef proto::expr<Tag, list2<T, U>, 2> type;
typedef type proto_base_expr;
template<typename Expr, typename State, typename Data>
struct impl
- : pass_through<binary_expr>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<binary_expr, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -689,14 +689,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct unary_plus : transform<unary_plus<T>, empty_base>
+ 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
- : pass_through<unary_plus>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<unary_plus, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -710,14 +710,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct negate : transform<negate<T>, empty_base>
+ 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
- : pass_through<negate>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<negate, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -731,14 +731,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct dereference : transform<dereference<T>, empty_base>
+ 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
- : pass_through<dereference>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<dereference, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -752,14 +752,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct complement : transform<complement<T>, empty_base>
+ 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
- : pass_through<complement>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<complement, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -773,14 +773,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct address_of : transform<address_of<T>, empty_base>
+ 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
- : pass_through<address_of>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<address_of, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -794,14 +794,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct logical_not : transform<logical_not<T>, empty_base>
+ 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
- : pass_through<logical_not>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<logical_not, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -815,14 +815,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct pre_inc : transform<pre_inc<T>, empty_base>
+ 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
- : pass_through<pre_inc>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<pre_inc, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -836,14 +836,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct pre_dec : transform<pre_dec<T>, empty_base>
+ 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
- : pass_through<pre_dec>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<pre_dec, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -857,14 +857,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct post_inc : transform<post_inc<T>, empty_base>
+ 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
- : pass_through<post_inc>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<post_inc, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -878,14 +878,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T>
- struct post_dec : transform<post_dec<T>, empty_base>
+ 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
- : pass_through<post_dec>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<post_dec, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -899,14 +899,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct shift_left : transform<shift_left<T, U>, empty_base>
+ 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
- : pass_through<shift_left>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<shift_left, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -922,14 +922,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct shift_right : transform<shift_right<T, U>, empty_base>
+ 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
- : pass_through<shift_right>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<shift_right, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -945,14 +945,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct multiplies : transform<multiplies<T, U>, empty_base>
+ 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
- : pass_through<multiplies>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<multiplies, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -968,14 +968,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct divides : transform<divides<T, U>, empty_base>
+ 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
- : pass_through<divides>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<divides, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -991,14 +991,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct modulus : transform<modulus<T, U>, empty_base>
+ 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
- : pass_through<modulus>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<modulus, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1014,14 +1014,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct plus : transform<plus<T, U>, empty_base>
+ 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
- : pass_through<plus>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<plus, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1037,14 +1037,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct minus : transform<minus<T, U>, empty_base>
+ 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
- : pass_through<minus>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<minus, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1060,14 +1060,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct less : transform<less<T, U>, empty_base>
+ 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
- : pass_through<less>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<less, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1083,14 +1083,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct greater : transform<greater<T, U>, empty_base>
+ 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
- : pass_through<greater>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<greater, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1106,14 +1106,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct less_equal : transform<less_equal<T, U>, empty_base>
+ 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
- : pass_through<less_equal>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<less_equal, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1129,14 +1129,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct greater_equal : transform<greater_equal<T, U>, empty_base>
+ 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
- : pass_through<greater_equal>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<greater_equal, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1152,14 +1152,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct equal_to : transform<equal_to<T, U>, empty_base>
+ 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
- : pass_through<equal_to>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<equal_to, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1175,14 +1175,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct not_equal_to : transform<not_equal_to<T, U>, empty_base>
+ 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
- : pass_through<not_equal_to>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<not_equal_to, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1198,14 +1198,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct logical_or : transform<logical_or<T, U>, empty_base>
+ 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
- : pass_through<logical_or>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<logical_or, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1221,14 +1221,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct logical_and : transform<logical_and<T, U>, empty_base>
+ 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
- : pass_through<logical_and>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<logical_and, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1244,14 +1244,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct bitwise_and : transform<bitwise_and<T, U>, empty_base>
+ 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
- : pass_through<bitwise_and>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<bitwise_and, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1267,14 +1267,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct bitwise_or : transform<bitwise_or<T, U>, empty_base>
+ 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
- : pass_through<bitwise_or>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<bitwise_or, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1290,14 +1290,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct bitwise_xor : transform<bitwise_xor<T, U>, empty_base>
+ 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
- : pass_through<bitwise_xor>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<bitwise_xor, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1313,14 +1313,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct comma : transform<comma<T, U>, empty_base>
+ 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
- : pass_through<comma>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<comma, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1332,14 +1332,14 @@
};
template<typename T, typename U>
- struct mem_ptr : transform<mem_ptr<T, U>, empty_base>
+ 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
- : pass_through<mem_ptr>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<mem_ptr, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1355,14 +1355,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct assign : transform<assign<T, U>, empty_base>
+ 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
- : pass_through<assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1378,14 +1378,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct shift_left_assign : transform<shift_left_assign<T, U>, empty_base>
+ 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
- : pass_through<shift_left_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<shift_left_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1401,14 +1401,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct shift_right_assign : transform<shift_right_assign<T, U>, empty_base>
+ 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
- : pass_through<shift_right_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<shift_right_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1424,14 +1424,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct multiplies_assign : transform<multiplies_assign<T, U>, empty_base>
+ 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
- : pass_through<multiplies_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<multiplies_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1447,14 +1447,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct divides_assign : transform<divides_assign<T, U>, empty_base>
+ 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
- : pass_through<divides_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<divides_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1470,14 +1470,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct modulus_assign : transform<modulus_assign<T, U>, empty_base>
+ 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
- : pass_through<modulus_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<modulus_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1493,14 +1493,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct plus_assign : transform<plus_assign<T, U>, empty_base>
+ 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
- : pass_through<plus_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<plus_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1516,14 +1516,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct minus_assign : transform<minus_assign<T, U>, empty_base>
+ 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
- : pass_through<minus_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<minus_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1539,14 +1539,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct bitwise_and_assign : transform<bitwise_and_assign<T, U>, empty_base>
+ 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
- : pass_through<bitwise_and_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<bitwise_and_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1562,14 +1562,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct bitwise_or_assign : transform<bitwise_or_assign<T, U>, empty_base>
+ 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
- : pass_through<bitwise_or_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<bitwise_or_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1585,14 +1585,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct bitwise_xor_assign : transform<bitwise_xor_assign<T, U>, empty_base>
+ 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
- : pass_through<bitwise_xor_assign>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<bitwise_xor_assign, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1608,14 +1608,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct subscript : transform<subscript<T, U>, empty_base>
+ 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
- : pass_through<subscript>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<subscript, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -1631,14 +1631,14 @@
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
/// transform.
template<typename T, typename U>
- struct member : transform<member<T, U>, empty_base>
+ 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
- : pass_through<member>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<member, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -2268,20 +2268,13 @@
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
>
#endif
- : 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)
- >
- , empty_base
- >
{
typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
typedef type proto_base_expr;
template<typename Expr, typename State, typename Data>
struct impl
- : pass_through<function>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<function, Expr, State, Data>
{};
/// INTERNAL ONLY
@@ -2312,21 +2305,13 @@
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
>
#endif
- : 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)
- >
- , empty_base
- >
{
typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
typedef type proto_base_expr;
template<typename Expr, typename State, typename Data>
struct impl
- : pass_through<nary_expr>::template impl<Expr, State, Data>
+ : detail::pass_through_impl<nary_expr, Expr, State, Data>
{};
/// INTERNAL ONLY
Modified: trunk/boost/proto/transform/impl.hpp
==============================================================================
--- trunk/boost/proto/transform/impl.hpp (original)
+++ trunk/boost/proto/transform/impl.hpp 2009-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -15,14 +15,63 @@
namespace boost { namespace proto
{
- struct transform_base
- {
- BOOST_PROTO_CALLABLE()
- BOOST_PROTO_TRANSFORM()
- };
-
- struct empty_base
- {};
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_BASIC_TRANSFORM(PrimitiveTransform) \
+ BOOST_PROTO_CALLABLE() \
+ typedef void proto_is_transform_; \
+ typedef PrimitiveTransform transform_type; \
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_TRANSFORM(PrimitiveTransform) \
+ BOOST_PROTO_BASIC_TRANSFORM(PrimitiveTransform) \
+ \
+ template<typename Sig> \
+ struct result \
+ { \
+ typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \
+ }; \
+ \
+ template<typename Expr> \
+ typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type \
+ operator ()(Expr &e) const \
+ { \
+ int i = 0; \
+ return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, i, i); \
+ } \
+ \
+ template<typename Expr, typename State> \
+ typename boost::proto::detail::apply_transform<transform_type(Expr &, State &)>::result_type \
+ operator ()(Expr &e, State &s) const \
+ { \
+ int i = 0; \
+ return boost::proto::detail::apply_transform<transform_type(Expr &, State &)>()(e, s, i); \
+ } \
+ \
+ template<typename Expr, typename State> \
+ typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>::result_type \
+ operator ()(Expr &e, State const &s) const \
+ { \
+ int i = 0; \
+ return boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>()(e, s, i); \
+ } \
+ \
+ template<typename Expr, typename State, typename Data> \
+ typename boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>::result_type \
+ operator ()(Expr &e, State &s, Data &d) const \
+ { \
+ return boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>()(e, s, d); \
+ } \
+ \
+ template<typename Expr, typename State, typename Data> \
+ typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>::result_type \
+ operator ()(Expr &e, State const &s, Data &d) const \
+ { \
+ return boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>()(e, s, d); \
+ } \
+ /**/
namespace detail
{
@@ -45,57 +94,10 @@
{};
}
- template<
- typename PrimitiveTransform
- , typename Base BOOST_PROTO_WHEN_BUILDING_DOCS(= transform_base)
- >
- struct transform : Base
+ template<typename PrimitiveTransform>
+ struct transform
{
- typedef PrimitiveTransform transform_type;
-
- template<typename Sig>
- struct result
- {
- typedef typename detail::apply_transform<Sig>::result_type type;
- };
-
- template<typename Expr>
- typename detail::apply_transform<PrimitiveTransform(Expr &)>::result_type
- operator ()(Expr &e) const
- {
- int i = 0;
- return detail::apply_transform<PrimitiveTransform(Expr &)>()(e, i, i);
- }
-
- template<typename Expr, typename State>
- typename detail::apply_transform<PrimitiveTransform(Expr &, State &)>::result_type
- operator ()(Expr &e, State &s) const
- {
- int i = 0;
- return detail::apply_transform<PrimitiveTransform(Expr &, State &)>()(e, s, i);
- }
-
- template<typename Expr, typename State>
- typename detail::apply_transform<PrimitiveTransform(Expr &, State const &)>::result_type
- operator ()(Expr &e, State const &s) const
- {
- int i = 0;
- return detail::apply_transform<PrimitiveTransform(Expr &, State const &)>()(e, s, i);
- }
-
- template<typename Expr, typename State, typename Data>
- typename detail::apply_transform<PrimitiveTransform(Expr &, State &, Data &)>::result_type
- operator ()(Expr &e, State &s, Data &d) const
- {
- return detail::apply_transform<PrimitiveTransform(Expr &, State &, Data &)>()(e, s, d);
- }
-
- template<typename Expr, typename State, typename Data>
- typename detail::apply_transform<PrimitiveTransform(Expr &, State const &, Data &)>::result_type
- operator ()(Expr &e, State const &s, Data &d) const
- {
- return detail::apply_transform<PrimitiveTransform(Expr &, State const &, Data &)>()(e, s, d);
- }
+ BOOST_PROTO_TRANSFORM(PrimitiveTransform)
};
template<typename Expr, typename State, typename Data>
Modified: trunk/libs/proto/doc/reference.xml
==============================================================================
--- trunk/libs/proto/doc/reference.xml (original)
+++ trunk/libs/proto/doc/reference.xml 2009-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -1040,6 +1040,7 @@
<xi:include href="reference/context/null.xml"/>
<!-- concepts -->
+ <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"/>
Added: trunk/libs/proto/doc/reference/concepts/BasicPrimitiveTransform.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/concepts/BasicPrimitiveTransform.xml 2009-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -0,0 +1,92 @@
+<?xml version="1.0" ?>
+<concept name="BasicPrimitiveTransform" category="utility">
+ <!--
+ Copyright 2008 Eric Niebler
+
+ Distributed under the Boost
+ Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ -->
+ <param name="Fn" role="basic-primitive-transform-type" />
+ <param name="Expr" role="expression-type" />
+ <param name="State" role="state-type" />
+ <param name="Data" role="data-type" />
+
+ <models-sentence>
+ The type <arg num="1" /> must be a model of <self/>.
+ </models-sentence>
+
+ <description>
+ <para>
+ A PrimitiveTransform is class type that
+ has a nested class template called impl 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.
+ </para>
+ </description>
+
+ <notation variables="fn">
+ <sample-value>
+ <type name="Fn" />
+ </sample-value>
+ </notation>
+
+ <notation variables="expr">
+ <sample-value>
+ <type name="Expr" />
+ </sample-value>
+ </notation>
+
+ <notation variables="state">
+ <sample-value>
+ <type name="State" />
+ </sample-value>
+ </notation>
+
+ <notation variables="data">
+ <sample-value>
+ <type name="Data" />
+ </sample-value>
+ </notation>
+
+ <associated-type name="result_type">
+ <get-member-type name="result_type">
+ <apply-template name="typename Fn::template impl">
+ <type name="Expr"/>
+ <type name="State"/>
+ <type name="Data"/>
+ </apply-template>
+ </get-member-type>
+ <description>
+ <simpara>The return type of the overloaded function call operator.</simpara>
+ </description>
+ </associated-type>
+
+ <valid-expression name="Monomorphic Function Call">
+ <apply-function name="typename Fn::template impl< Expr, State, Data >()">
+ <sample-value>
+ <type name="Expr" />
+ </sample-value>
+ <sample-value>
+ <type name="State" />
+ </sample-value>
+ <sample-value>
+ <type name="Data" />
+ </sample-value>
+ </apply-function>
+ <return-type>
+ <require-same-type testable="yes">
+ <type name="result_type"/>
+ </require-same-type>
+ </return-type>
+ <semantics>Applies the transform.</semantics>
+ </valid-expression>
+
+ <example-model>
+ <type name="boost::proto::terminal< int >" />
+ </example-model>
+
+</concept>
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-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -18,18 +18,14 @@
<description>
<para>
- A PrimitiveTransform is class type that
- has a nested class template called impl 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. The PrimitiveTransform is itself a
- PolymorphicFunctionObject that is implemented in
- terms of the nested impl template.
+ A PrimitiveTransform is a <conceptname>BasicPrimitiveTransform</conceptname>
+ that 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: trunk/libs/proto/doc/reference/traits.xml
==============================================================================
--- trunk/libs/proto/doc/reference/traits.xml (original)
+++ trunk/libs/proto/doc/reference/traits.xml 2009-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -547,10 +547,9 @@
<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>PrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
+ a <conceptname>BasicPrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
<struct name="impl">
<template>
<template-type-parameter name="Expr"/>
@@ -606,10 +605,9 @@
<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>PrimitiveTransform</conceptname>
+ a <conceptname>BasicPrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -635,10 +633,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -663,10 +660,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -691,10 +687,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -719,10 +714,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -747,10 +741,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -775,10 +768,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -803,10 +795,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -831,10 +822,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -859,10 +849,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -887,10 +876,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -916,10 +904,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -945,10 +932,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -974,10 +960,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1003,10 +988,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1032,10 +1016,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1061,10 +1044,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1090,10 +1072,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1119,10 +1100,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1148,10 +1128,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1177,10 +1156,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1206,10 +1184,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1235,10 +1212,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1264,10 +1240,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1293,10 +1268,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1322,10 +1296,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1351,10 +1324,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1380,10 +1352,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1409,10 +1380,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1438,10 +1408,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1467,7 +1436,6 @@
<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"/>
@@ -1491,10 +1459,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1520,10 +1487,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1549,10 +1515,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1578,10 +1543,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1607,10 +1571,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1636,10 +1599,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1665,10 +1627,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1694,10 +1655,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1723,10 +1683,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1752,10 +1711,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1781,10 +1739,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1810,10 +1767,9 @@
<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>PrimitiveTransform</conceptname> that dispatches to the
+ a <conceptname>BasicPrimitiveTransform</conceptname> that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
<struct name="impl">
@@ -1838,10 +1794,9 @@
<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>PrimitiveTransform</conceptname>
+ a <conceptname>BasicPrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -1868,10 +1823,9 @@
<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>PrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
+ a <conceptname>BasicPrimitiveTransform</conceptname> that returns the current expression unchanged. </purpose>
<description>
<para>
Use <computeroutput>proto::nullary_expr<<classname>proto::_</classname>, <classname>proto::_</classname>></computeroutput>
@@ -1932,10 +1886,9 @@
<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>PrimitiveTransform</conceptname>
+ a <conceptname>BasicPrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -1969,10 +1922,9 @@
<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>PrimitiveTransform</conceptname>
+ a <conceptname>BasicPrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
transform.</purpose>
@@ -2004,10 +1956,9 @@
<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>PrimitiveTransform</conceptname>
+ a <conceptname>BasicPrimitiveTransform</conceptname>
that dispatches to the
<computeroutput><classname alt="proto::pass_through">proto::pass_through<></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-06-02 17:33:28 EDT (Tue, 02 Jun 2009)
@@ -14,7 +14,7 @@
<struct name="when">
<template>
<template-type-parameter name="Grammar"/>
- <template-type-parameter name="PrimitiveTransform">
+ <template-type-parameter name="BasicPrimitiveTransform">
<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