Subject: [Boost-commit] svn:boost r49530 - in trunk/libs/proto/doc: . concepts reference reference/concepts reference/context reference/transform
From: eric_at_[hidden]
Date: 2008-11-02 07:21:03
Author: eric_niebler
Date: 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
New Revision: 49530
URL: http://svn.boost.org/trac/boost/changeset/49530
Log:
improved reference section
Added:
trunk/libs/proto/doc/reference/
trunk/libs/proto/doc/reference.xml (contents, props changed)
trunk/libs/proto/doc/reference/args.xml (contents, props changed)
trunk/libs/proto/doc/reference/concepts/
trunk/libs/proto/doc/reference/concepts/CallableTransform.xml (contents, props changed)
trunk/libs/proto/doc/reference/concepts/ObjectTransform.xml (contents, props changed)
trunk/libs/proto/doc/reference/concepts/PolymorphicFunctionObject.xml (contents, props changed)
trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml (contents, props changed)
trunk/libs/proto/doc/reference/concepts/Transform.xml (contents, props changed)
trunk/libs/proto/doc/reference/context/
trunk/libs/proto/doc/reference/context/callable.xml (contents, props changed)
trunk/libs/proto/doc/reference/context/default.xml (contents, props changed)
trunk/libs/proto/doc/reference/context/null.xml (contents, props changed)
trunk/libs/proto/doc/reference/core.xml (contents, props changed)
trunk/libs/proto/doc/reference/debug.xml (contents, props changed)
trunk/libs/proto/doc/reference/deep_copy.xml (contents, props changed)
trunk/libs/proto/doc/reference/domain.xml (contents, props changed)
trunk/libs/proto/doc/reference/eval.xml (contents, props changed)
trunk/libs/proto/doc/reference/expr.xml (contents, props changed)
trunk/libs/proto/doc/reference/extends.xml (contents, props changed)
trunk/libs/proto/doc/reference/fusion.xml (contents, props changed)
trunk/libs/proto/doc/reference/generate.xml (contents, props changed)
trunk/libs/proto/doc/reference/literal.xml (contents, props changed)
trunk/libs/proto/doc/reference/make_expr.xml (contents, props changed)
trunk/libs/proto/doc/reference/matches.xml (contents, props changed)
trunk/libs/proto/doc/reference/operators.xml (contents, props changed)
trunk/libs/proto/doc/reference/proto.xml (contents, props changed)
trunk/libs/proto/doc/reference/proto_fwd.xml (contents, props changed)
trunk/libs/proto/doc/reference/tags.xml (contents, props changed)
trunk/libs/proto/doc/reference/traits.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/
trunk/libs/proto/doc/reference/transform/arg.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/call.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/default.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/fold.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/fold_tree.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/impl.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/lazy.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/make.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/pass_through.xml (contents, props changed)
trunk/libs/proto/doc/reference/transform/when.xml (contents, props changed)
Removed:
trunk/libs/proto/doc/concepts/
trunk/libs/proto/doc/transforms_old.qbk
trunk/libs/proto/doc/wave.sh
Text files modified:
trunk/libs/proto/doc/Jamfile.v2 | 57 ----------------------------------------
trunk/libs/proto/doc/intermediate_form.qbk | 2
trunk/libs/proto/doc/proto.qbk | 40 ++++++++++++++--------------
trunk/libs/proto/doc/protodoc.xml | 55 ++++++++++----------------------------
4 files changed, 36 insertions(+), 118 deletions(-)
Modified: trunk/libs/proto/doc/Jamfile.v2
==============================================================================
--- trunk/libs/proto/doc/Jamfile.v2 (original)
+++ trunk/libs/proto/doc/Jamfile.v2 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -3,63 +3,8 @@
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
import path ;
-import doxygen ;
import quickbook ;
-wave-command = [ path.native $(BOOST_ROOT)/dist/bin/wave ] ;
-
-# Generate reference section using Doxygen
-doxygen protodoc
- :
- ../../../boost/proto/args.hpp
- ../../../boost/proto/context.hpp
- ../../../boost/proto/core.hpp
- ../../../boost/proto/debug.hpp
- ../../../boost/proto/deep_copy.hpp
- ../../../boost/proto/domain.hpp
- ../../../boost/proto/eval.hpp
- ../../../boost/proto/expr.hpp
- ../../../boost/proto/extends.hpp
- ../../../boost/proto/fusion.hpp
- ../../../boost/proto/generate.hpp
- ../../../boost/proto/literal.hpp
- ../../../boost/proto/make_expr.hpp
- ../../../boost/proto/matches.hpp
- ../../../boost/proto/operators.hpp
- ../../../boost/proto/proto.hpp
- ../../../boost/proto/proto_fwd.hpp
-# ../../../boost/proto/proto_typeof.hpp
- ../../../boost/proto/tags.hpp
- ../../../boost/proto/traits.hpp
- ../../../boost/proto/transform.hpp
- ../../../boost/proto/context/callable.hpp
- ../../../boost/proto/context/default.hpp
- ../../../boost/proto/context/null.hpp
- ../../../boost/proto/transform/arg.hpp
- ../../../boost/proto/transform/call.hpp
- ../../../boost/proto/transform/default.hpp
- ../../../boost/proto/transform/fold.hpp
- ../../../boost/proto/transform/fold_tree.hpp
- ../../../boost/proto/transform/impl.hpp
- ../../../boost/proto/transform/lazy.hpp
- ../../../boost/proto/transform/make.hpp
- ../../../boost/proto/transform/pass_through.hpp
- ../../../boost/proto/transform/when.hpp
- :
- <doxygen:param>EXTRACT_ALL=YES
- <doxygen:param>HIDE_UNDOC_MEMBERS=NO
- # Use Boost.Wave to preprocess Proto's source
-# <doxygen:param>INPUT_FILTER=./wave.sh
- <doxygen:param>"INPUT_FILTER=\"$(wave-command) -S ../../.. \\
- -S $(BOOST_ROOT) \\
- -S \\\"C:\\Program Files\\Microsoft Visual Studio .NET 2003\\vc7\\include\\\" \\
- -D _WIN32 \\
- -D BOOST_PROTO_BUILDING_DOCS \\
- -p 1 \""
- # This ensures that Wave is actually built before we try to execute it
- <dependency>$(BOOST_ROOT)/tools/wave/build release
- ;
-
xml proto
:
proto.qbk
@@ -106,6 +51,4 @@
# default png graphics are awful in PDF form,
# better use SVG's instead:
# <format>pdf:<xsl:param>admon.graphics.extension=".svg"
-
-# <dependency>protodoc
;
Modified: trunk/libs/proto/doc/intermediate_form.qbk
==============================================================================
--- trunk/libs/proto/doc/intermediate_form.qbk (original)
+++ trunk/libs/proto/doc/intermediate_form.qbk 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -1084,7 +1084,7 @@
[pre
group ::= '(' expression ')'
factor ::= double | '_1' | '_2' | group
-term ::= factor (('*' factor) | ('/' factor))*
+term ::= factor (('\*' factor) | ('/' factor))\*
expression ::= term (('+' term) | ('-' term))*
]
Modified: trunk/libs/proto/doc/proto.qbk
==============================================================================
--- trunk/libs/proto/doc/proto.qbk (original)
+++ trunk/libs/proto/doc/proto.qbk 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -46,7 +46,7 @@
[def _typeof_
[@../../libs/typeof/index.html Boost.Typeof]]
[def _expr_
- [classref boost::proto::expr<Tag,Args,1> `proto::expr<>`]]
+ [classref boost::proto::expr `proto::expr<>`]]
[def _deep_copy_
[funcref boost::proto::deep_copy `proto::deep_copy()`]]
[def _domain_
@@ -62,25 +62,25 @@
[def _unpack_expr_
[funcref boost::proto::unpack_expr `proto::unpack_expr()`]]
[def _matches_
- [classref boost::proto::result_of::matches `proto::matches<>`]]
+ [classref boost::proto::matches `proto::matches<>`]]
[def _or_
- [classref boost::proto::control::or_ `proto::or_<>`]]
+ [classref boost::proto::or_ `proto::or_<>`]]
[def _and_
- [classref boost::proto::control::and_ `proto::and_<>`]]
+ [classref boost::proto::and_ `proto::and_<>`]]
[def _if_
- [classref boost::proto::control::if_ `proto::if_<>`]]
+ [classref boost::proto::if_ `proto::if_<>`]]
[def _not_
- [classref boost::proto::control::not_ `proto::not_<>`]]
+ [classref boost::proto::not_ `proto::not_<>`]]
[def _switch_
- [classref boost::proto::control::switch_ `proto::switch_<>`]]
+ [classref boost::proto::switch_ `proto::switch_<>`]]
[def _exact_
- [classref boost::proto::control::exact `proto::exact<>`]]
+ [classref boost::proto::exact `proto::exact<>`]]
[def _convertible_to_
- [classref boost::proto::control::convertible_to `proto::convertible_to<>`]]
+ [classref boost::proto::convertible_to `proto::convertible_to<>`]]
[def _is_expr_
- [classref boost::proto::result_of::is_expr `proto::is_expr<>`]]
+ [classref boost::proto::is_expr `proto::is_expr<>`]]
[def _tag_of_
- [classref boost::proto::result_of::tag_of `proto::tag_of<>`]]
+ [classref boost::proto::tag_of `proto::tag_of<>`]]
[def _child_
[funcref boost::proto::child `proto::child()`]]
[def _child_c_
@@ -94,23 +94,23 @@
[def _value_
[funcref boost::proto::value `proto::value()`]]
[def _terminal_
- [classref boost::proto::op::terminal `proto::terminal<>`]]
+ [classref boost::proto::terminal `proto::terminal<>`]]
[def _unary_plus_
- [classref boost::proto::op::unary_plus `proto::unary_plus<>`]]
+ [classref boost::proto::unary_plus `proto::unary_plus<>`]]
[def _plus_
- [classref boost::proto::op::plus `proto::plus<>`]]
+ [classref boost::proto::plus `proto::plus<>`]]
[def _unary_expr_
- [classref boost::proto::op::unary_expr `proto::unary_expr<>`]]
+ [classref boost::proto::unary_expr `proto::unary_expr<>`]]
[def _binary_expr_
- [classref boost::proto::op::binary_expr `proto::binary_expr<>`]]
+ [classref boost::proto::binary_expr `proto::binary_expr<>`]]
[def _nary_expr_
- [classref boost::proto::op::nary_expr `proto::nary_expr<>`]]
+ [classref boost::proto::nary_expr `proto::nary_expr<>`]]
[def _literal_
- [classref boost::proto::utility::literal `proto::literal<>`]]
+ [classref boost::proto::literal `proto::literal<>`]]
[def _lit_
[funcref boost::proto::lit `proto::lit()`]]
[def _vararg_
- [classref boost::proto::control::vararg `proto::vararg<>`]]
+ [classref boost::proto::vararg `proto::vararg<>`]]
[def _default_context_
[classref boost::proto::context::default_context `proto::default_context`]]
[def _callable_context_
@@ -207,7 +207,7 @@
[endsect]
-[xinclude proto.xml]
+[xinclude reference.xml]
[/=================]
[section Appendices]
Modified: trunk/libs/proto/doc/protodoc.xml
==============================================================================
--- trunk/libs/proto/doc/protodoc.xml (original)
+++ trunk/libs/proto/doc/protodoc.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -1242,32 +1242,7 @@
-</para></description><returns><para>literal<T &>(t) </para></returns><throws><simpara>Will not throw.</simpara></throws><notes><para>The returned value holds the argument by reference. </para></notes></overloaded-function></namespace></namespace></header><header name="boost/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child nodes, respectively. </para><namespace name="boost"><namespace name="proto"><struct name="_make_expr"><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Domain"><default>deduce_domain</default></template-type-parameter>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>TODO document me. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><method-group name="public member functions"><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
- <template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
- <template-type-parameter name="A0"/>
- <template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
- <template-type-parameter name="A0"/>
- <template-type-parameter name="A1"/>
- <template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
- <template-type-parameter name="A0"/>
- <template-type-parameter name="A1"/>
- <template-type-parameter name="A2"/>
- <template-type-parameter name="A3"/>
- </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter><parameter name="a3"><paramtype>A3 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
- <template-type-parameter name="A0"/>
- <template-type-parameter name="A1"/>
- <template-type-parameter name="A2"/>
- <template-type-parameter name="A3"/>
- <template-type-parameter name="A4"/>
- </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter><parameter name="a3"><paramtype>A3 &</paramtype></parameter><parameter name="a4"><paramtype>A4 &</paramtype></parameter></method></method-group></struct><namespace name="functional"><struct name="make_expr"><template>
+</para></description><returns><para>literal<T &>(t) </para></returns><throws><simpara>Will not throw.</simpara></throws><notes><para>The returned value holds the argument by reference. </para></notes></overloaded-function></namespace></namespace></header><header name="boost/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child nodes, respectively. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="make_expr"><template>
<template-type-parameter name="Tag"/>
<template-type-parameter name="Domain"><default>deduce_domain</default></template-type-parameter>
</template><purpose>A callable function object equivalent to the <computeroutput>proto::make_expr()</computeroutput> function. </purpose><description><para>In all cases, <computeroutput>functional::make_expr<Tag, Domain>()(a0, ... aN)</computeroutput> is equivalent to <computeroutput>proto::make_expr<Tag, Domain>(a0, ... aN)</computeroutput>.</para><para><computeroutput>functional::make_expr<Tag>()(a0, ... aN)</computeroutput> is equivalent to <computeroutput>proto::make_expr<Tag>(a0, ... aN)</computeroutput>. </para></description><struct-specialization name="result"><template>
@@ -1295,22 +1270,22 @@
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
<template-type-parameter name="A4"/>
- </template><specialization><template-arg>This(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0, A1, A2, A3, A4 >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0 const >::type const</type><template>
+ </template><specialization><template-arg>This(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0, A1, A2, A3, A4 >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><typedef name="is_poly_function_base_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0 const >::type</type><template>
<template-type-parameter name="A0"/>
</template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>Construct an expression node with tag type <computeroutput>Tag</computeroutput> and in the domain <computeroutput>Domain</computeroutput>.</para><para>
-</para></description><returns><para><computeroutput>proto::make_expr<Tag, Domain>(a0,...aN)</computeroutput> </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1 >::type const</type><template>
+</para></description><returns><para><computeroutput>proto::make_expr<Tag, Domain>(a0,...aN)</computeroutput> </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1 >::type</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>const A0 &</paramtype></parameter><parameter name="a1"><paramtype>const A1 &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>const A0 &</paramtype></parameter><parameter name="a1"><paramtype>const A1 &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1, const A2 >::type</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>const A0 &</paramtype></parameter><parameter name="a1"><paramtype>const A1 &</paramtype></parameter><parameter name="a2"><paramtype>const A2 &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1, const A2, const A3 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>const A0 &</paramtype></parameter><parameter name="a1"><paramtype>const A1 &</paramtype></parameter><parameter name="a2"><paramtype>const A2 &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1, const A2, const A3 >::type</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
<template-type-parameter name="A3"/>
- </template><parameter name="a0"><paramtype>const A0 &</paramtype></parameter><parameter name="a1"><paramtype>const A1 &</paramtype></parameter><parameter name="a2"><paramtype>const A2 &</paramtype></parameter><parameter name="a3"><paramtype>const A3 &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1, const A2, const A3, const A4 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>const A0 &</paramtype></parameter><parameter name="a1"><paramtype>const A1 &</paramtype></parameter><parameter name="a2"><paramtype>const A2 &</paramtype></parameter><parameter name="a3"><paramtype>const A3 &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1, const A2, const A3, const A4 >::type</type><template>
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
@@ -1324,7 +1299,7 @@
</template></struct><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="Sequence"/>
- </template><specialization><template-arg>This(Sequence)</template-arg></specialization><typedef name="type"><type><classname>result_of::unpack_expr</classname>< Tag, Domain, typename remove_reference< Sequence >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::unpack_expr</classname>< Tag, Domain, Sequence const >::type const</type><template>
+ </template><specialization><template-arg>This(Sequence)</template-arg></specialization><typedef name="type"><type><classname>result_of::unpack_expr</classname>< Tag, Domain, typename remove_reference< Sequence >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::unpack_expr</classname>< Tag, Domain, Sequence const >::type</type><template>
<template-type-parameter name="Sequence"/>
</template><parameter name="sequence"><paramtype>Sequence const &</paramtype><description><para>A Fusion Random Access Sequence </para></description></parameter><description><para>Construct an expression node with tag type <computeroutput>Tag</computeroutput> and in the domain <computeroutput>Domain</computeroutput>.</para><para>
@@ -2016,7 +1991,7 @@
<template-type-parameter name="A0"/>
<template-type-parameter name="A1"/>
<template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>if_else </para></description></function></namespace></namespace></header><header name="boost/proto/proto.hpp"><para>Includes all of Proto. </para></header><header name="boost/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><struct name="callable"><typedef name="proto_is_callable_"><type>void</type></typedef></struct><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="exops"/><namespace name="functional"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef name="make_unary_plus"><type><classnam
e>make_expr</classname>< <classname>tag::unary_plus</classname> ></type></typedef><typedef name="make_negate"><type><classname>make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="make_dereference"><type><classname>make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="make_complement"><type><classname>make_expr</classname>< <classname>tag::complement</classname> ></type></typedef><typedef name="make_address_of"><type><classname>make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="make_logical_not"><type><classname>make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="make_pre_inc"><type><classname>make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="make_pre_dec"><type><classname>make_expr</classname>< <classname>tag::pre_dec</classname> ></type></typedef><typed
ef name="make_post_inc"><type><classname>make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="make_post_dec"><type><classname>make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="make_shift_left"><type><classname>make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="make_shift_right"><type><classname>make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="make_multiplies"><type><classname>make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="make_divides"><type><classname>make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="make_modulus"><type><classname>make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="make_plus"><type><classname>make_expr</classname>< <classname>tag::plus</classname>
></type></typedef><typedef name="make_minus"><type><classname>make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="make_less"><type><classname>make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="make_greater"><type><classname>make_expr</classname>< <classname>tag::greater</classname> ></type></typedef><typedef name="make_less_equal"><type><classname>make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="make_greater_equal"><type><classname>make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="make_equal_to"><type><classname>make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="make_not_equal_to"><type><classname>make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="make_logical_or"><type><classname>make_expr</classname>< <cla
ssname>tag::logical_or</classname> ></type></typedef><typedef name="make_logical_and"><type><classname>make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="make_bitwise_and"><type><classname>make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="make_bitwise_or"><type><classname>make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="make_bitwise_xor"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="make_comma"><type><classname>make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="make_mem_ptr"><type><classname>make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="make_assign"><type><classname>make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="make_shift_left_assign"><
type><classname>make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="make_shift_right_assign"><type><classname>make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="make_multiplies_assign"><type><classname>make_expr</classname>< <classname>tag::multiplies_assign</classname> ></type></typedef><typedef name="make_divides_assign"><type><classname>make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="make_modulus_assign"><type><classname>make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="make_plus_assign"><type><classname>make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="make_minus_assign"><type><classname>make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="make_bitwise_and_assign"><type><class
name>make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="make_bitwise_or_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="make_bitwise_xor_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor_assign</classname> ></type></typedef><typedef name="make_subscript"><type><classname>make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="make_if_else"><type><classname>make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="make_function"><type><classname>make_expr</classname>< <classname>tag::function</classname> ></type></typedef></namespace><namespace name="op"/><namespace name="result_of"/><namespace name="tag"/><namespace name="utility"/><typedef name="ignore"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="_flatten"><type><classna
me>functional::flatten</classname></type></typedef><typedef name="_pop_front"><type><classname>functional::pop_front</classname></type></typedef><typedef name="_reverse"><type><classname>functional::reverse</classname></type></typedef><typedef name="_eval"><type><classname>functional::eval</classname></type></typedef><typedef name="_deep_copy"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_make_terminal"><type><classname>_make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef name="_make_unary_plus"><type><classname>_make_expr</classname>< <classname>tag::unary_plus</classname> ></type></typedef><typedef name="_make_negate"><type><classname>_make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="_make_dereference"><type><classname>_make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="_make_complement"><type><classname>_make_expr</classname>
< <classname>tag::complement</classname> ></type></typedef><typedef name="_make_address_of"><type><classname>_make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="_make_logical_not"><type><classname>_make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="_make_pre_inc"><type><classname>_make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="_make_pre_dec"><type><classname>_make_expr</classname>< <classname>tag::pre_dec</classname> ></type></typedef><typedef name="_make_post_inc"><type><classname>_make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="_make_post_dec"><type><classname>_make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="_make_shift_left"><type><classname>_make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="_m
ake_shift_right"><type><classname>_make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="_make_multiplies"><type><classname>_make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="_make_divides"><type><classname>_make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="_make_modulus"><type><classname>_make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="_make_plus"><type><classname>_make_expr</classname>< <classname>tag::plus</classname> ></type></typedef><typedef name="_make_minus"><type><classname>_make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="_make_less"><type><classname>_make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="_make_greater"><type><classname>_make_expr</classname>< <classname>tag::greater</classname> ></type></ty
pedef><typedef name="_make_less_equal"><type><classname>_make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="_make_greater_equal"><type><classname>_make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="_make_equal_to"><type><classname>_make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="_make_not_equal_to"><type><classname>_make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="_make_logical_or"><type><classname>_make_expr</classname>< <classname>tag::logical_or</classname> ></type></typedef><typedef name="_make_logical_and"><type><classname>_make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="_make_bitwise_and"><type><classname>_make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="_make_bitwise_or"><type><classnam
e>_make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="_make_bitwise_xor"><type><classname>_make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="_make_comma"><type><classname>_make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="_make_mem_ptr"><type><classname>_make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="_make_assign"><type><classname>_make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="_make_shift_left_assign"><type><classname>_make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="_make_shift_right_assign"><type><classname>_make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="_make_multiplies_assign"><type><classname>_make_expr</classname>< <classname>tag::mult
iplies_assign</classname> ></type></typedef><typedef name="_make_divides_assign"><type><classname>_make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="_make_modulus_assign"><type><classname>_make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="_make_plus_assign"><type><classname>_make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="_make_minus_assign"><type><classname>_make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>_make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>_make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="_make_bitwise_xor_assign"><type><classname>_make_expr</classname>< <classname>tag::b
itwise_xor_assign</classname> ></type></typedef><typedef name="_make_subscript"><type><classname>_make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="_make_if_else"><type><classname>_make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="_make_function"><type><classname>_make_expr</classname>< <classname>tag::function</classname> ></type></typedef><typedef name="_child0"><type><classname>_child_c</classname>< 0 ></type></typedef><typedef name="_child1"><type><classname>_child_c</classname>< 1 ></type></typedef><typedef name="_child"><type><classname>_child0</classname></type></typedef><typedef name="_left"><type><classname>_child0</classname></type></typedef><typedef name="_right"><type><classname>_child1</classname></type></typedef><typedef name="_child2"><type><classname>_child_c</classname>< 2 ></type></typedef><typedef name="_child3"><type><classname>_child_c</classname>< 3 ></type
></typedef></namespace></namespace></header><header name="boost/proto/tags.hpp"><para>Contains the tags for all the overloadable operators in C++ </para><namespace name="boost"><namespace name="proto"><namespace name="tag"><struct name="terminal"><purpose>Tag type for terminals; aka, leaves in the expression tree. </purpose></struct><struct name="unary_plus"><purpose>Tag type for the unary + operator. </purpose></struct><struct name="negate"><purpose>Tag type for the unary - operator. </purpose></struct><struct name="dereference"><purpose>Tag type for the unary * operator. </purpose></struct><struct name="complement"><purpose>Tag type for the unary ~ operator. </purpose></struct><struct name="address_of"><purpose>Tag type for the unary & operator. </purpose></struct><struct name="logical_not"><purpose>Tag type for the unary ! operator. </purpose></struct><struct name="pre_inc"><purpose>Tag type for the unary prefix ++ operator. </purpose></struct><struct name="pre_dec"><purpose>Tag type for the unary pre
fix -- operator. </purpose></struct><struct name="post_inc"><purpose>Tag type for the unary postfix ++ operator. </purpose></struct><struct name="post_dec"><purpose>Tag type for the unary postfix -- operator. </purpose></struct><struct name="shift_left"><purpose>Tag type for the binary << operator. </purpose></struct><struct name="shift_right"><purpose>Tag type for the binary >> operator. </purpose></struct><struct name="multiplies"><purpose>Tag type for the binary * operator. </purpose></struct><struct name="divides"><purpose>Tag type for the binary / operator. </purpose></struct><struct name="modulus"><purpose>Tag type for the binary % operator. </purpose></struct><struct name="plus"><purpose>Tag type for the binary + operator. </purpose></struct><struct name="minus"><purpose>Tag type for the binary - operator. </purpose></struct><struct name="less"><purpose>Tag type for the binary < operator. </purpose></struct><struct name="greater"><purpose>Tag type for the binary > operator. </purpose
></struct><struct name="less_equal"><purpose>Tag type for the binary <= operator. </purpose></struct><struct name="greater_equal"><purpose>Tag type for the binary >= operator. </purpose></struct><struct name="equal_to"><purpose>Tag type for the binary == operator. </purpose></struct><struct name="not_equal_to"><purpose>Tag type for the binary != operator. </purpose></struct><struct name="logical_or"><purpose>Tag type for the binary || operator. </purpose></struct><struct name="logical_and"><purpose>Tag type for the binary && operator. </purpose></struct><struct name="bitwise_and"><purpose>Tag type for the binary & operator. </purpose></struct><struct name="bitwise_or"><purpose>Tag type for the binary | operator. </purpose></struct><struct name="bitwise_xor"><purpose>Tag type for the binary ^ operator. </purpose></struct><struct name="comma"><purpose>Tag type for the binary , operator. </purpose></struct><struct name="mem_ptr"><purpose>Tag type for the binary ->* operator. </purpose></str
uct><struct name="assign"><purpose>Tag type for the binary = operator. </purpose></struct><struct name="shift_left_assign"><purpose>Tag type for the binary <<= operator. </purpose></struct><struct name="shift_right_assign"><purpose>Tag type for the binary >>= operator. </purpose></struct><struct name="multiplies_assign"><purpose>Tag type for the binary *= operator. </purpose></struct><struct name="divides_assign"><purpose>Tag type for the binary /= operator. </purpose></struct><struct name="modulus_assign"><purpose>Tag type for the binary = operator. </purpose></struct><struct name="plus_assign"><purpose>Tag type for the binary += operator. </purpose></struct><struct name="minus_assign"><purpose>Tag type for the binary -= operator. </purpose></struct><struct name="bitwise_and_assign"><purpose>Tag type for the binary &= operator. </purpose></struct><struct name="bitwise_or_assign"><purpose>Tag type for the binary |= operator. </purpose></struct><struct name="bitwise_xor_assign"><purpose>Tag ty
pe for the binary ^= operator. </purpose></struct><struct name="subscript"><purpose>Tag type for the binary subscript operator. </purpose></struct><struct name="member"><purpose>Tag type for the binary virtual data members. </purpose></struct><struct name="if_else_"><purpose>Tag type for the ternary ?: conditional operator. </purpose></struct><struct name="function"><purpose>Tag type for the n-ary function call operator. </purpose></struct></namespace></namespace></namespace></header><header name="boost/proto/traits.hpp"><para>Contains definitions for child<>, child_c<>, left<>, right<>, tag_of<>, and the helper functions child(), child_c(), value(), left() and right(). </para><namespace name="boost"><namespace name="proto"><struct name="is_callable"><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>if_else </para></description></function></namespace></namespace></header><header name="boost/proto/proto.hpp"><para>Includes all of Proto. </para></header><header name="boost/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><struct name="callable"><typedef name="proto_is_callable_"><type>void</type></typedef></struct><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="exops"/><namespace name="functional"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef name="make_unary_plus"><type><classnam
e>make_expr</classname>< <classname>tag::unary_plus</classname> ></type></typedef><typedef name="make_negate"><type><classname>make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="make_dereference"><type><classname>make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="make_complement"><type><classname>make_expr</classname>< <classname>tag::complement</classname> ></type></typedef><typedef name="make_address_of"><type><classname>make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="make_logical_not"><type><classname>make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="make_pre_inc"><type><classname>make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="make_pre_dec"><type><classname>make_expr</classname>< <classname>tag::pre_dec</classname> ></type></typedef><typed
ef name="make_post_inc"><type><classname>make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="make_post_dec"><type><classname>make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="make_shift_left"><type><classname>make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="make_shift_right"><type><classname>make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="make_multiplies"><type><classname>make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="make_divides"><type><classname>make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="make_modulus"><type><classname>make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="make_plus"><type><classname>make_expr</classname>< <classname>tag::plus</classname>
></type></typedef><typedef name="make_minus"><type><classname>make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="make_less"><type><classname>make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="make_greater"><type><classname>make_expr</classname>< <classname>tag::greater</classname> ></type></typedef><typedef name="make_less_equal"><type><classname>make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="make_greater_equal"><type><classname>make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="make_equal_to"><type><classname>make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="make_not_equal_to"><type><classname>make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="make_logical_or"><type><classname>make_expr</classname>< <cla
ssname>tag::logical_or</classname> ></type></typedef><typedef name="make_logical_and"><type><classname>make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="make_bitwise_and"><type><classname>make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="make_bitwise_or"><type><classname>make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="make_bitwise_xor"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="make_comma"><type><classname>make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="make_mem_ptr"><type><classname>make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="make_assign"><type><classname>make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="make_shift_left_assign"><
type><classname>make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="make_shift_right_assign"><type><classname>make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="make_multiplies_assign"><type><classname>make_expr</classname>< <classname>tag::multiplies_assign</classname> ></type></typedef><typedef name="make_divides_assign"><type><classname>make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="make_modulus_assign"><type><classname>make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="make_plus_assign"><type><classname>make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="make_minus_assign"><type><classname>make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="make_bitwise_and_assign"><type><class
name>make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="make_bitwise_or_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="make_bitwise_xor_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor_assign</classname> ></type></typedef><typedef name="make_subscript"><type><classname>make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="make_if_else"><type><classname>make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="make_function"><type><classname>make_expr</classname>< <classname>tag::function</classname> ></type></typedef></namespace><namespace name="op"/><namespace name="result_of"/><namespace name="tag"/><namespace name="utility"/><typedef name="ignore"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="_flatten"><type><classna
me>functional::flatten</classname></type></typedef><typedef name="_pop_front"><type><classname>functional::pop_front</classname></type></typedef><typedef name="_reverse"><type><classname>functional::reverse</classname></type></typedef><typedef name="_eval"><type><classname>functional::eval</classname></type></typedef><typedef name="_deep_copy"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_make_terminal"><type><classname>functional::make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef name="_make_unary_plus"><type><classname>functional::make_expr</classname>< <classname>tag::unary_plus</classname> ></type></typedef><typedef name="_make_negate"><type><classname>functional::make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="_make_dereference"><type><classname>functional::make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="_make_complem
ent"><type><classname>functional::make_expr</classname>< <classname>tag::complement</classname> ></type></typedef><typedef name="_make_address_of"><type><classname>functional::make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="_make_logical_not"><type><classname>functional::make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="_make_pre_inc"><type><classname>functional::make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="_make_pre_dec"><type><classname>functional::make_expr</classname>< <classname>tag::pre_dec</classname> ></type></typedef><typedef name="_make_post_inc"><type><classname>functional::make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="_make_post_dec"><type><classname>functional::make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="_make_shift_left">
<type><classname>functional::make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="_make_shift_right"><type><classname>functional::make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="_make_multiplies"><type><classname>functional::make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="_make_divides"><type><classname>functional::make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="_make_modulus"><type><classname>functional::make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="_make_plus"><type><classname>functional::make_expr</classname>< <classname>tag::plus</classname> ></type></typedef><typedef name="_make_minus"><type><classname>functional::make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="_make_less"><type><classname>function
al::make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="_make_greater"><type><classname>functional::make_expr</classname>< <classname>tag::greater</classname> ></type></typedef><typedef name="_make_less_equal"><type><classname>functional::make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="_make_greater_equal"><type><classname>functional::make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="_make_equal_to"><type><classname>functional::make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="_make_not_equal_to"><type><classname>functional::make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="_make_logical_or"><type><classname>functional::make_expr</classname>< <classname>tag::logical_or</classname> ></type></typedef><typedef name="_make_logical_and"><type><classname>
functional::make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="_make_bitwise_and"><type><classname>functional::make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="_make_bitwise_or"><type><classname>functional::make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="_make_bitwise_xor"><type><classname>functional::make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="_make_comma"><type><classname>functional::make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="_make_mem_ptr"><type><classname>functional::make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="_make_assign"><type><classname>functional::make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="_make_shift_left_assign"><type><classname
>functional::make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="_make_shift_right_assign"><type><classname>functional::make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="_make_multiplies_assign"><type><classname>functional::make_expr</classname>< <classname>tag::multiplies_assign</classname> ></type></typedef><typedef name="_make_divides_assign"><type><classname>functional::make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="_make_modulus_assign"><type><classname>functional::make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="_make_plus_assign"><type><classname>functional::make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="_make_minus_assign"><type><classname>functional::make_expr</classname>< <classname>tag::minus_assign</classname
> ></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>functional::make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>functional::make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="_make_bitwise_xor_assign"><type><classname>functional::make_expr</classname>< <classname>tag::bitwise_xor_assign</classname> ></type></typedef><typedef name="_make_subscript"><type><classname>functional::make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="_make_if_else"><type><classname>functional::make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="_make_function"><type><classname>functional::make_expr</classname>< <classname>tag::function</classname> ></type></typedef><typedef name="_child0"><type><classname>_child_c</classname>< 0 ></typ
e></typedef><typedef name="_child1"><type><classname>_child_c</classname>< 1 ></type></typedef><typedef name="_child"><type><classname>_child0</classname></type></typedef><typedef name="_left"><type><classname>_child0</classname></type></typedef><typedef name="_right"><type><classname>_child1</classname></type></typedef><typedef name="_child2"><type><classname>_child_c</classname>< 2 ></type></typedef><typedef name="_child3"><type><classname>_child_c</classname>< 3 ></type></typedef></namespace></namespace></header><header name="boost/proto/tags.hpp"><para>Contains the tags for all the overloadable operators in C++ </para><namespace name="boost"><namespace name="proto"><namespace name="tag"><struct name="terminal"><purpose>Tag type for terminals; aka, leaves in the expression tree. </purpose></struct><struct name="unary_plus"><purpose>Tag type for the unary + operator. </purpose></struct><struct name="negate"><purpose>Tag type for the unary - operator. </purpose></struct><struct name="deref
erence"><purpose>Tag type for the unary * operator. </purpose></struct><struct name="complement"><purpose>Tag type for the unary ~ operator. </purpose></struct><struct name="address_of"><purpose>Tag type for the unary & operator. </purpose></struct><struct name="logical_not"><purpose>Tag type for the unary ! operator. </purpose></struct><struct name="pre_inc"><purpose>Tag type for the unary prefix ++ operator. </purpose></struct><struct name="pre_dec"><purpose>Tag type for the unary prefix -- operator. </purpose></struct><struct name="post_inc"><purpose>Tag type for the unary postfix ++ operator. </purpose></struct><struct name="post_dec"><purpose>Tag type for the unary postfix -- operator. </purpose></struct><struct name="shift_left"><purpose>Tag type for the binary << operator. </purpose></struct><struct name="shift_right"><purpose>Tag type for the binary >> operator. </purpose></struct><struct name="multiplies"><purpose>Tag type for the binary * operator. </purpose></struct><struct name="d
ivides"><purpose>Tag type for the binary / operator. </purpose></struct><struct name="modulus"><purpose>Tag type for the binary % operator. </purpose></struct><struct name="plus"><purpose>Tag type for the binary + operator. </purpose></struct><struct name="minus"><purpose>Tag type for the binary - operator. </purpose></struct><struct name="less"><purpose>Tag type for the binary < operator. </purpose></struct><struct name="greater"><purpose>Tag type for the binary > operator. </purpose></struct><struct name="less_equal"><purpose>Tag type for the binary <= operator. </purpose></struct><struct name="greater_equal"><purpose>Tag type for the binary >= operator. </purpose></struct><struct name="equal_to"><purpose>Tag type for the binary == operator. </purpose></struct><struct name="not_equal_to"><purpose>Tag type for the binary != operator. </purpose></struct><struct name="logical_or"><purpose>Tag type for the binary || operator. </purpose></struct><struct name="logical_and"><purpose>Tag type for the b
inary && operator. </purpose></struct><struct name="bitwise_and"><purpose>Tag type for the binary & operator. </purpose></struct><struct name="bitwise_or"><purpose>Tag type for the binary | operator. </purpose></struct><struct name="bitwise_xor"><purpose>Tag type for the binary ^ operator. </purpose></struct><struct name="comma"><purpose>Tag type for the binary , operator. </purpose></struct><struct name="mem_ptr"><purpose>Tag type for the binary ->* operator. </purpose></struct><struct name="assign"><purpose>Tag type for the binary = operator. </purpose></struct><struct name="shift_left_assign"><purpose>Tag type for the binary <<= operator. </purpose></struct><struct name="shift_right_assign"><purpose>Tag type for the binary >>= operator. </purpose></struct><struct name="multiplies_assign"><purpose>Tag type for the binary *= operator. </purpose></struct><struct name="divides_assign"><purpose>Tag type for the binary /= operator. </purpose></struct><struct name="modulus_assign"><pur
pose>Tag type for the binary = operator. </purpose></struct><struct name="plus_assign"><purpose>Tag type for the binary += operator. </purpose></struct><struct name="minus_assign"><purpose>Tag type for the binary -= operator. </purpose></struct><struct name="bitwise_and_assign"><purpose>Tag type for the binary &= operator. </purpose></struct><struct name="bitwise_or_assign"><purpose>Tag type for the binary |= operator. </purpose></struct><struct name="bitwise_xor_assign"><purpose>Tag type for the binary ^= operator. </purpose></struct><struct name="subscript"><purpose>Tag type for the binary subscript operator. </purpose></struct><struct name="member"><purpose>Tag type for the binary virtual data members. </purpose></struct><struct name="if_else_"><purpose>Tag type for the ternary ?: conditional operator. </purpose></struct><struct name="function"><purpose>Tag type for the n-ary function call operator. </purpose></struct></namespace></namespace></namespace></header><header name="boost/proto/traits.hpp"><
para>Contains definitions for child<>, child_c<>, left<>, right<>, tag_of<>, and the helper functions child(), child_c(), value(), left() and right(). </para><namespace name="boost"><namespace name="proto"><struct name="is_callable"><template>
<template-type-parameter name="T"/>
</template><purpose>Boolean metafunction which detects whether a type is a callable function object type or not. </purpose><description><para><computeroutput>is_callable<></computeroutput> is used by the <computeroutput>when<></computeroutput> transform to determine whether a function type <computeroutput>R(A1,A2,...AN)</computeroutput> is a callable transform or an object transform. (The former are evaluated using <computeroutput>call<></computeroutput> and the later with <computeroutput>make<></computeroutput>.) If <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput>, the function type is a callable transform; otherwise, it is an object transform.</para><para>Unless specialized for a type <computeroutput>T</computeroutput>, <computeroutput>is_callable<T>::value</computeroutput> is computed as follows:</para><para><itemizedlist>
<listitem><para>If <computeroutput>T</computeroutput> is a template type <computeroutput>X<Y0,Y1,...YN></computeroutput>, where all <computeroutput>Yx</computeroutput> are types for <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>, <computeroutput>is_callable<T>::value</computeroutput> is <computeroutput>is_same<YN, proto::callable>::value</computeroutput>. </para></listitem>
@@ -2867,12 +2842,12 @@
</template><specialization><template-arg>This(T &)</template-arg></specialization><inherit access="public">boost::proto::_byval::result< This(T)></inherit></struct-specialization><struct-specialization name="result"><template>
<template-type-parameter name="This"/>
<template-type-parameter name="T"/>
- </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="type"><type>T</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>T const &</type><template>
+ </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="type"><type>T</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>T</type><template>
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>T const &</paramtype><description><para>The object to unref </para></description></parameter><description><para>
-</para></description><returns><para><computeroutput>t</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type>T &</type><template>
+</para></description><returns><para><computeroutput>t</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type>T</type><template>
<template-type-parameter name="T"/>
</template><parameter name="t"><paramtype>boost::reference_wrapper< T > const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct></namespace></namespace></header><header name="boost/proto/transform/call.hpp"><para>Contains definition of the call<> transform. </para><namespace name="boost"><namespace name="proto"><struct name="call"><template>
<template-type-parameter name="PrimitiveTransform"/>
@@ -2917,7 +2892,7 @@
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
<template-nontype-parameter name="B"><type>bool</type></template-nontype-parameter>
- </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
+ </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="mono_fun"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< mono_fun(a0)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
@@ -2935,7 +2910,7 @@
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
<template-nontype-parameter name="B"><type>bool</type></template-nontype-parameter>
- </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
+ </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="mono_fun"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< mono_fun(a0, a1)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization
name="impl2"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
@@ -2954,7 +2929,7 @@
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
<template-nontype-parameter name="B"><type>bool</type></template-nontype-parameter>
- </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< <classname>_</classname>, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>t
ypename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
+ </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< <classname>_</classname>, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="mono_fun"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< mono_fun(a0, a1, a2)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_pa
ram</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
@@ -2968,7 +2943,7 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
- </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< <classname>_</classname>, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a3"><type><classname>when</classname>< <classname>_</classname>, A3 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2, a3)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typen
ame impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
+ </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< <classname>_</classname>, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a3"><type><classname>when</classname>< <classname>_</classname>, A3 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="mono_fun"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< mono_fun(a0, a1, a2, a3)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><
type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
</para></description></method></method-group></struct></struct-specialization><struct-specialization name="call"><template>
<template-type-parameter name="Fun"/>
<template-type-parameter name="A0"/>
@@ -2980,7 +2955,7 @@
<template-type-parameter name="Expr"/>
<template-type-parameter name="State"/>
<template-type-parameter name="Data"/>
- </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< <classname>_</classname>, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a3"><type><classname>when</classname>< <classname>_</classname>, A3 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a4"><type><classname>when</classname>< <classname>_</classname>, A4 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2, a3, a4)>::
type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
+ </template><inherit access="public">boost::proto::transform_impl< Expr, State, Data ></inherit><typedef name="a0"><type><classname>when</classname>< <classname>_</classname>, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< <classname>_</classname>, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< <classname>_</classname>, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a3"><type><classname>when</classname>< <classname>_</classname>, A3 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a4"><type><classname>when</classname>< <classname>_</classname>, A4 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="mono_fun"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"
><type>boost::result_of< mono_fun(a0, a1, a2, a3, a4)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
</para></description></method></method-group></struct></struct-specialization></namespace></namespace></header><header name="boost/proto/transform/fold.hpp"><para>Contains definition of the fold<> and reverse_fold<> transforms. </para><namespace name="boost"><namespace name="proto"><struct name="fold"><template>
<template-type-parameter name="Sequence"/>
<template-type-parameter name="State0"/>
Added: trunk/libs/proto/doc/reference.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="utf-8"?>
+<library-reference xmlns:xi="http://www.w3.org/2001/XInclude">
+
+ <!-- classes -->
+ <!--<section id="proto.reference.classes">
+ <title>Classes</title>
+ <itemizedlist>
+ <listitem>
+ <classname alt="boost::proto::deduce_domain">proto::deduce_domain</classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::default_domain">proto::default_domain</classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::domain">proto::domain<></classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::domain_of">proto::domain_of<></classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::expr">proto::expr<></classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::is_domain">proto::is_domain<></classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::term">proto::term<></classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::listN">proto::list1<>, proto::list2<>, ...</classname>
+ </listitem>
+ <listitem>
+ <classname alt="boost::proto::functional::display_expr">proto::functional::display_expr</classname>
+ </listitem>
+ </itemizedlist>
+ </section>-->
+
+ <!-- headers -->
+ <xi:include href="reference/args.xml"/>
+ <xi:include href="reference/core.xml"/>
+ <xi:include href="reference/debug.xml"/>
+ <xi:include href="reference/deep_copy.xml"/>
+ <xi:include href="reference/domain.xml"/>
+ <xi:include href="reference/eval.xml"/>
+ <xi:include href="reference/expr.xml"/>
+ <xi:include href="reference/extends.xml"/>
+ <xi:include href="reference/fusion.xml"/>
+ <xi:include href="reference/generate.xml"/>
+ <xi:include href="reference/literal.xml"/>
+ <xi:include href="reference/make_expr.xml"/>
+ <xi:include href="reference/matches.xml"/>
+ <xi:include href="reference/operators.xml"/>
+ <xi:include href="reference/proto.xml"/>
+ <xi:include href="reference/proto_fwd.xml"/>
+ <xi:include href="reference/tags.xml"/>
+ <xi:include href="reference/traits.xml"/>
+ <xi:include href="reference/transform/arg.xml"/>
+ <xi:include href="reference/transform/call.xml"/>
+ <xi:include href="reference/transform/default.xml"/>
+ <xi:include href="reference/transform/fold.xml"/>
+ <xi:include href="reference/transform/fold_tree.xml"/>
+ <xi:include href="reference/transform/impl.xml"/>
+ <xi:include href="reference/transform/lazy.xml"/>
+ <xi:include href="reference/transform/make.xml"/>
+ <xi:include href="reference/transform/pass_through.xml"/>
+ <xi:include href="reference/transform/when.xml"/>
+ <xi:include href="reference/context/callable.xml"/>
+ <xi:include href="reference/context/default.xml"/>
+ <xi:include href="reference/context/null.xml"/>
+
+ <!-- concepts -->
+ <xi:include href="reference/concepts/CallableTransform.xml"/>
+ <xi:include href="reference/concepts/ObjectTransform.xml"/>
+ <xi:include href="reference/concepts/PrimitiveTransform.xml"/>
+ <xi:include href="reference/concepts/Transform.xml"/>
+ <xi:include href="reference/concepts/PolymorphicFunctionObject.xml"/>
+
+</library-reference>
Added: trunk/libs/proto/doc/reference/args.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/args.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/args.hpp">
+ <para>
+ Contains definitions of the <computeroutput>
+ <classname alt="boost::proto::term">proto::term<></classname></computeroutput> and <computeroutput>
+ <classname alt="boost::proto::listN">proto::list<replaceable>N</replaceable><></classname>
+ </computeroutput> class templates.</para>
+
+ <namespace name="boost">
+ <namespace name="proto">
+
+ <!-- proto::term<> -->
+ <struct name="term">
+ <template>
+ <template-type-parameter name="Arg0"/>
+ </template>
+ <purpose>A type sequence, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname alt="proto::expr">proto::expr<></classname></computeroutput> class template.</purpose>
+ <description>
+ <para>
+ A type sequence, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname alt="proto::expr">proto::expr<></classname></computeroutput> class template. The
+ types in the sequence correspond to the children of a node in an expression tree.
+ </para>
+ </description>
+ <data-member name="arity" specifiers="static">
+ <purpose><computeroutput>= 0;</computeroutput></purpose>
+ <type>const long</type>
+ </data-member>
+ <typedef name="child0">
+ <type>Arg0</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::list1<>, proto::list2<> ... -->
+ <struct name="listN">
+ <template>
+ <template-type-parameter name="Arg" pack="1"/>
+ </template>
+ <purpose>A type sequence, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname alt="proto::expr">proto::expr<></classname></computeroutput> class template.</purpose>
+ <description>
+ <para>
+ A type sequence, for use as the 2<superscript>nd</superscript> parameter to the <computeroutput>
+ <classname alt="proto::expr">proto::expr<></classname></computeroutput> class template. The
+ types in the sequence correspond to the children of a node in an expression tree.
+ </para>
+ </description>
+ <data-member name="arity" specifiers="static">
+ <purpose><computeroutput>= N;</computeroutput></purpose>
+ <type>const long</type>
+ </data-member>
+ <typedef name="childM">
+ <purpose>For each <replaceable>M</replaceable> in <replaceable>[0,N)</replaceable></purpose>
+ <type>Arg<replaceable>M</replaceable></type>
+ </typedef>
+ </struct>
+
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/concepts/CallableTransform.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/concepts/CallableTransform.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,93 @@
+<?xml version="1.0" ?>
+<concept name="CallableTransform" 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="polymorphic-function-object-type" />
+ <param name="Tn" role="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 <conceptname name="PolymorphicFunctionObject"/>.
+ The type <arg num="2" /> must be a model of <conceptname name="Transform"/>.
+ </models-sentence>
+
+ <description>
+ <para>
+ A CallableTransform is a function type or a function
+ pointer type where the return type Fn is a
+ PolymorphicFunctionObject and the arguments are
+ Transforms. is_callable< Fn >::value
+ must be true. The CallableTransform, when applied,
+ has the effect of invoking the polymorphic function
+ object Fn, passing as arguments the result(s)
+ of applying transform(s) Tn.
+ </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="type">
+ <apply-template name="boost::result_of">
+ <type name="Fn(Transform<Tn, Expr, State, Data>::result_type...)"/>
+ </apply-template>
+ </get-member-type>
+ <description>
+ <simpara>The result of applying the CallableTransform.</simpara>
+ </description>
+ </associated-type>
+
+ <valid-expression name="Apply Transform">
+ <apply-function name="when< _, Fn(Tn...)>()">
+ <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::_child(boost::proto::_left)" />
+ </example-model>
+
+</concept>
Added: trunk/libs/proto/doc/reference/concepts/ObjectTransform.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/concepts/ObjectTransform.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,94 @@
+<?xml version="1.0" ?>
+<concept name="ObjectTransform" 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="Obj" role="object-type" />
+ <param name="Tn" role="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 <conceptname name="Regular"/>, or
+ else it is a template specialization representing a lamda expression that,
+ subsequent to type substitution, is a type that models <conceptname name="Regular"/>.
+ The type <arg num="2" /> must be a model of <conceptname name="Transform"/>.
+ </models-sentence>
+
+ <description>
+ <para>
+ An ObjectTransform is a function type or a function
+ pointer type where the return type Obj is a
+ an object type and the arguments are
+ Transforms. is_callable< Obj >::value
+ must be false. The ObjectTransform, when applied,
+ has the effect of constructing an object of type
+ Obj' (see below), passing as construction parameters
+ the result(s) of applying transform(s) Tn.
+ </para>
+ <para>
+ The type Obj may be a template specialization representing
+ a compile-time lambda expression. For instance, if Obj is
+ std::pair< proto::_value, int >, the result type of the
+ ObjectTransform is computed by replacing the type proto::_value
+ with the result of applying the proto::_value transform. For
+ given types Obj, Expr, State and Data, we can say that the
+ type Obj' represents the type Obj after all nested transforms
+ have been replaced with the results of applying the transforms
+ with Expr, State and Data as transform arguments.
+ </para>
+ <para>
+ If the type Obj is not a template specialization representing
+ a compile-time lambda expression, then the result type Obj' is
+ the same as Obj.
+ </para>
+ </description>
+
+ <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>
+
+ <valid-expression name="Apply Transform">
+ <apply-function name="when< _, Obj(Tn...)>()">
+ <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="Obj'"/>
+ </require-same-type>
+ </return-type>
+ <semantics>Applies the transform.</semantics>
+ </valid-expression>
+
+ <example-model>
+ <type name="std::pair< boost::proto::_value, int >(boost::proto::_value, int())" />
+ </example-model>
+
+</concept>
Added: trunk/libs/proto/doc/reference/concepts/PolymorphicFunctionObject.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/concepts/PolymorphicFunctionObject.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,66 @@
+<?xml version="1.0" ?>
+<concept name="PolymorphicFunctionObject" 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="polymorphic-function-object-type" />
+
+ <models-sentence>
+ The type <arg num="1" /> must be a model of <self/>.
+ </models-sentence>
+
+ <description>
+ <para>
+ A type that can be called and that follows the TR1 ResultOf
+ protocol for return type calculation.
+ </para>
+ </description>
+
+ <notation variables="fn">
+ <sample-value>
+ <type name="Fn" />
+ </sample-value>
+ </notation>
+
+ <notation variables="a0,...an">
+ <sample-value>
+ <type name="A0,...An" />
+ </sample-value>
+ </notation>
+
+ <associated-type name="result_type">
+ <get-member-type name="type">
+ <apply-template name="result_of">
+ <apply-function name="Fn">
+ <type name="A0,...An" />
+ </apply-function>
+ </apply-template>
+ </get-member-type>
+ <description>
+ <simpara>The result of calling the Polymorphic Function Object.</simpara>
+ </description>
+ </associated-type>
+
+ <valid-expression name="Function Call">
+ <apply-function name="fn">
+ <sample-value>
+ <type name="A0,...An" />
+ </sample-value>
+ </apply-function>
+ <return-type>
+ <require-same-type testable="yes">
+ <type name="result_type"/>
+ </require-same-type>
+ </return-type>
+ <semantics>Calls the function object.</semantics>
+ </valid-expression>
+
+ <example-model>
+ <type name="std::plus<int>" />
+ </example-model>
+
+</concept>
Added: trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/concepts/PrimitiveTransform.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,145 @@
+<?xml version="1.0" ?>
+<concept name="PrimitiveTransform" 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="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. The PrimitiveTransform is itself a
+ PolymorphicFunctionObject that is implemented in
+ terms of the nested impl template.
+ </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="Polymorphic Function Call 1">
+ <apply-function name="fn">
+ <sample-value>
+ <type name="Expr" />
+ </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>
+
+ <valid-expression name="Polymorphic Function Call 2">
+ <apply-function name="fn">
+ <sample-value>
+ <type name="Expr" />
+ </sample-value>
+ <sample-value>
+ <type name="State" />
+ </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>
+
+ <valid-expression name="Polymorphic Function Call 3">
+ <apply-function name="fn">
+ <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>
+
+ <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::_child_c< 0 >" />
+ </example-model>
+
+</concept>
Added: trunk/libs/proto/doc/reference/concepts/Transform.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/concepts/Transform.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,79 @@
+<?xml version="1.0" ?>
+<concept name="Transform" 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="Tn" role="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 Transform is a PrimitiveTransform, a CallableTransform
+ or an ObjectTransform.
+ </para>
+ </description>
+
+ <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="type">
+ <apply-template name="boost::result_of">
+ <type name="when< _, Tn >(Expr, State, Data)"/>
+ </apply-template>
+ </get-member-type>
+ <description>
+ <simpara>The result of applying the Transform.</simpara>
+ </description>
+ </associated-type>
+
+ <valid-expression name="Apply Transform">
+ <apply-function name="when< _, Tn >()">
+ <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::_child(boost::proto::_left)" />
+ </example-model>
+
+</concept>
Added: trunk/libs/proto/doc/reference/context/callable.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/context/callable.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/context/callable.hpp">
+ <para>Definintion of <computeroutput><classname alt="boost::proto::context::callable_context">proto::context::callable_context<></classname></computeroutput>,
+ an evaluation context for <computeroutput><functionname alt="boost::proto::eval">proto::eval()</functionname></computeroutput>
+ that fans out each node and calls the derived context type with the expressions constituents. If the derived context
+ doesn't have an overload that handles this node, fall back to some other context. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="context">
+ <struct name="callable_eval">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <purpose>A BinaryFunction that accepts a Proto expression and a callable context and calls
+ the context with the expression tag and children as arguments, effectively fanning the
+ expression out. </purpose>
+ <description>
+ <para>
+ <computeroutput>proto::context::callable_eval<></computeroutput> requires that
+ <computeroutput>Context</computeroutput> is a <conceptname>PolymorphicFunctionObject</conceptname>
+ that can be invoked with <computeroutput>Expr</computeroutput>'s tag and children as
+ expressions, as follows:
+ <programlisting>context(typename Expr::proto_tag(), <functionname>proto::child_c</functionname><0>(expr), ... <functionname>proto::child_c</functionname><N>(expr))</programlisting>
+ </para>
+ </description>
+ <typedef name="result_type">
+ <type>typename boost::result_of<
+ Context(
+ typename Expr::proto_tag,
+ typename proto::result_of::child_c<0>::type,
+ ...
+ typename proto::result_of::child_c<N>::type,
+ )>::type
+ </type>
+ </typedef>
+
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The current expression </para>
+ </description>
+ </parameter>
+ <parameter name="context">
+ <paramtype>Context &</paramtype>
+ <description>
+ <para>The callable evaluation context </para>
+ </description>
+ </parameter>
+ <returns>
+ <para>
+ <computeroutput>
+ context(typename Expr::proto_tag(),
+ <functionname>proto::child_c</functionname><0>(expr),...
+ <functionname>proto::child_c</functionname><N>(expr))
+ </computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="callable_context">
+ <template>
+ <template-type-parameter name="Context"/>
+ <template-type-parameter name="DefaultCtx">
+ <default><classname>proto::context::default_context</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>An evaluation context adaptor that makes authoring a context a simple matter of
+ writing function overloads, rather then writing template specializations.</purpose>
+ <description>
+ <para>
+ <computeroutput>proto::callable_context<></computeroutput> is a base class that
+ implements the context protocol by passing fanned-out expression nodes to the derived
+ context, making it easy to customize the handling of expression types by writing function
+ overloads. Only those expression types needing special handling require explicit handling.
+ All others are dispatched to a user-specified default context,
+ <computeroutput>DefaultCtx</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>proto::callable_context<></computeroutput> is defined simply as:
+ </para>
+ <para>
+ <programlisting>template<typename Context, typename DefaultCtx = default_context>
+struct callable_context {
+ template<typename Expr, typename ThisContext = Context>
+ struct eval :
+ mpl::if_<
+ is_expr_handled_<Expr, Context>, // For exposition
+ <classname>proto::context::callable_eval</classname><Expr, ThisContext>,
+ typename DefaultCtx::template eval<Expr, Context>
+ >::type
+ {};
+};</programlisting>
+ </para>
+ <para>
+ The Boolean metafunction <computeroutput>is_expr_handled_<></computeroutput> uses
+ metaprogramming tricks to determine whether <computeroutput>Context</computeroutput> has
+ an overloaded function call operator that accepts the fanned-out constituents of an
+ expression of type <computeroutput>Expr</computeroutput>. If so, the handling of the
+ expression is dispatched to
+ <computeroutput><classname>proto::context::callable_eval<></classname></computeroutput>.
+ If not, it is dispatched to the user-specified <computeroutput>DefaultCtx</computeroutput>.
+ </para>
+ <para>
+ <emphasis role="bold">Example:</emphasis>
+ </para>
+ <para>
+ <programlisting>// An evaluation context that increments all
+// integer terminals in-place.
+struct increment_ints :
+ <classname>proto::context::callable_context</classname><
+ increment_ints const // derived context
+ <classname>proto::context::null_context</classname> const // fall-back context
+ >
+{
+ typedef void result_type;
+
+ // Handle int terminals here:
+ void operator()(proto::tag::terminal, int &i) const
+ {
+ ++i;
+ }
+};</programlisting>
+ </para>
+ <para>
+ With <computeroutput>increment_ints</computeroutput>, we can do the following:
+ </para>
+ <para>
+ <programlisting><classname>proto::literal</classname><int> i = 0, j = 10;
+proto::eval( i - j * 3.14, increment_ints() );
+
+assert( i.get() == 1 && j.get() == 11 );</programlisting>
+ </para>
+ </description>
+ <struct name="eval">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="ThisContext">
+ <default>Context</default>
+ </template-type-parameter>
+ </template>
+ <description>
+ <para>
+ A BinaryFunction that accepts an <computeroutput>Expr</computeroutput> and a
+ <computeroutput>Context</computeroutput>, and either fans out the expression and passes
+ it to the context, or else hands off the expression to <computeroutput>DefaultCtx</computeroutput>.
+ </para>
+ <para>
+ If <computeroutput>Context</computeroutput> is a <conceptname>PolymorphicFunctionObject</conceptname>
+ such that it can be invoked with the tag and children of <computeroutput>Expr</computeroutput>, as
+ <computeroutput>ctx(typename Expr::proto_tag(), child_c<0>(expr),... child_c<N>(expr))</computeroutput>,
+ then <computeroutput>eval<Expr, ThisContext></computeroutput> inherits from
+ <computeroutput><classname>proto::context::callable_eval</classname><Expr, ThisContext></computeroutput>.
+ Otherwise, <computeroutput>eval<Expr, ThisContext></computeroutput> inherits from
+ <computeroutput>DefaultCtx::eval<Expr, Context></computeroutput>.
+ </para>
+ </description>
+ <inherit><type><replaceable>see-below</replaceable></type></inherit>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/context/default.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/context/default.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,213 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/context/default.hpp">
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="context">
+ <struct name="default_eval">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <purpose>
+ A BinaryFunction that accepts a Proto expression and a context, evaluates
+ each child expression with the context, and combines the result using the
+ standard C++ meaning for the operator represented by the current expression
+ node.
+ </purpose>
+ <description>
+ <para>
+ Let <computeroutput><computeroutput>OP</computeroutput></computeroutput> be the C++ operator
+ corresponding to <computeroutput>Expr::proto_tag</computeroutput>. (For example, if
+ <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::plus</classname></computeroutput>, let <computeroutput>
+ <computeroutput>OP</computeroutput></computeroutput> be <computeroutput>+</computeroutput>.)
+ </para>
+ <para>
+ The behavior of this class is specified in terms of the C++0x <computeroutput>decltype</computeroutput>
+ keyword. In systems where this keyword is not available, Proto uses the Boost.Typeof library to
+ approximate the behavior.
+ </para>
+ </description>
+ <typedef name="Tag">
+ <purpose>For exposition only</purpose>
+ <type>typename Expr::tag_type</type>
+ </typedef>
+ <data-member name="s_expr">
+ <purpose>For exposition only</purpose>
+ <type>static Expr &</type>
+ </data-member>
+ <data-member name="s_context">
+ <purpose>For exposition only</purpose>
+ <type>static Context &</type>
+ </data-member>
+ <typedef name="result_type">
+ <type><emphasis>see-below</emphasis></type>
+ <description>
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary prefix operator,
+ then the result type is
+ <programlisting>decltype(
+ OP <functionname>proto::eval</functionname>(<functionname>proto::child</functionname>(s_expr), s_context)
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary postfix operator,
+ then the result type is
+ <programlisting>decltype(
+ <functionname>proto::eval</functionname>(<functionname>proto::child</functionname>(s_expr), s_context) OP
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a binary infix operator,
+ then the result type is
+ <programlisting>decltype(
+ <functionname>proto::eval</functionname>(<functionname>proto::left</functionname>(s_expr), s_context) OP
+ <functionname>proto::eval</functionname>(<functionname>proto::right</functionname>(s_expr), s_context)
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::subscript</classname>
+ </computeroutput>,
+ then the result type is
+ <programlisting>decltype(
+ <functionname>proto::eval</functionname>(<functionname>proto::left</functionname>(s_expr), s_context) [
+ <functionname>proto::eval</functionname>(<functionname>proto::right</functionname>(s_expr), s_context) ]
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::if_else_</classname>
+ </computeroutput>,
+ then the result type is
+ <programlisting>decltype(
+ <functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><0>(s_expr), s_context) ?
+ <functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><1>(s_expr), s_context) :
+ <functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><2>(s_expr), s_context)
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::function</classname>
+ </computeroutput>,
+ then the result type is
+ <programlisting>decltype(
+ <functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><0>(s_expr), s_context) (
+ <functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><1>(s_expr), s_context),
+ ...
+ <functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><N>(s_expr), s_context) )
+)</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </description>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The current expression </para>
+ </description>
+ </parameter>
+ <parameter name="context">
+ <paramtype>Context &</paramtype>
+ <description>
+ <para>The evaluation context </para>
+ </description>
+ </parameter>
+ <description>
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary prefix operator,
+ then return
+ <programlisting>OP <functionname>proto::eval</functionname>(<functionname>proto::child</functionname>(expr), context)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary postfix operator,
+ then return
+ <programlisting><functionname>proto::eval</functionname>(<functionname>proto::child</functionname>(expr), context) OP</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a binary infix operator,
+ then return
+ <programlisting><functionname>proto::eval</functionname>(<functionname>proto::left</functionname>(expr), context) OP
+<functionname>proto::eval</functionname>(<functionname>proto::right</functionname>(expr), context)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::subscript</classname>
+ </computeroutput>,
+ then return
+ <programlisting><functionname>proto::eval</functionname>(<functionname>proto::left</functionname>(expr), context) [
+<functionname>proto::eval</functionname>(<functionname>proto::right</functionname>(expr), context) ]</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::if_else_</classname>
+ </computeroutput>,
+ then return
+ <programlisting><functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><0>(expr), context) ?
+<functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><1>(expr), context) :
+<functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><2>(expr), context)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::function</classname>
+ </computeroutput>,
+ then return
+ <programlisting><functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><0>(expr), context) (
+<functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><1>(expr), context),
+...
+<functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><N>(expr), context) )</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="default_context">
+ <purpose>An evaluation context that gives the operators their normal C++ semantics.</purpose>
+ <description>
+ <para>An evaluation context that gives the operators their normal C++ semantics.</para>
+ </description>
+ <struct name="eval">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="ThisContext">
+ <default>default_context const</default>
+ </template-type-parameter>
+ </template>
+ <inherit><classname>proto::context::default_eval</classname>< Expr, ThisContext ></inherit>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/context/null.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/context/null.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/context/null.hpp">
+ <para>Definintion of
+ <computeroutput><classname alt="boost::proto::context::null_context">proto::context::null_context<></classname></computeroutput>,
+ an evaluation context for <functionname alt="boost::proto::eval">proto::eval()</functionname> that simply evaluates
+ each child expression, doesn't combine the results at all, and returns void. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="context">
+ <struct name="null_eval">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <typedef name="result_type">
+ <type>void</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>void</type>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ <parameter name="context">
+ <paramtype>Context &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ For <computeroutput>N</computeroutput> in <computeroutput>[0,Expr arity)</computeroutput>,
+ evaluate:
+ <programlisting><functionname>proto::eval</functionname>(<functionname>proto::child_c</functionname><N>(expr), context)</programlisting>
+ </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="null_context">
+ <purpose>An evaluation context for <functionname alt="proto::eval">proto::eval()</functionname> that simply evaluates
+ each child expression, doesn't combine the results at all, and returns void.</purpose>
+ <struct name="eval">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="ThisContext">
+ <default>null_context const</default>
+ </template-type-parameter>
+ </template>
+ <inherit><classname>proto::context::null_eval</classname>< Expr, ThisContext ></inherit>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/core.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/core.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/core.hpp">
+ <para>Includes all of Proto, except the contexts, transforms, debug utilities and Boost.Typeof registrations.</para>
+</header>
Added: trunk/libs/proto/doc/reference/debug.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/debug.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/debug.hpp">
+ <para>Utilities for debugging Proto expression trees </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="functional">
+
+ <!-- proto::functional::display_expr -->
+ <struct name="display_expr">
+ <purpose>Pretty-print a Proto expression tree. </purpose>
+ <description>
+ <para>
+ A <conceptname>PolymorphicFunctionObject</conceptname> which accepts a Proto expression tree and pretty-prints it to an <computeroutput>ostream</computeroutput> for debugging purposes.
+ </para>
+ </description>
+
+ <typedef name="result_type">
+ <type>void</type>
+ </typedef>
+
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>void</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </method>
+ </method-group>
+
+ <constructor>
+ <parameter name="sout"><paramtype>std::ostream &</paramtype><default>std::cout</default>
+ <description>
+ <para>
+ The <computeroutput>ostream</computeroutput> to which the expression tree will be written.
+ </para>
+ </description>
+ </parameter>
+ <parameter name="depth">
+ <paramtype>int</paramtype>
+ <default>0</default>
+ <description>
+ <para>
+ The starting indentation depth for this node. Children nodes will be displayed at a starting depth of <computeroutput>depth+4</computeroutput>.
+ </para>
+ </description>
+ </parameter>
+ </constructor>
+ </struct>
+
+ </namespace>
+
+ <!-- proto::display_expr -->
+ <overloaded-function name="display_expr">
+
+ <signature>
+ <type>void</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ <description>
+ <para>The Proto expression tree to pretty-print </para>
+ </description>
+ </parameter>
+ <parameter name="sout">
+ <paramtype>std::ostream &</paramtype>
+ <description>
+ <para>
+ The <computeroutput>ostream</computeroutput> to which the output should be written. If not specified, defaults to <computeroutput>std::cout</computeroutput>.
+ </para>
+ </description>
+ </parameter>
+ </signature>
+
+ <signature>
+ <type>void</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Pretty-print a Proto expression tree. </purpose>
+ <notes>
+ <para>
+ Equivalent to <computeroutput><classname alt="boost::proto::functional::display_expr">proto::functional::display_expr</classname>(0, sout)(expr)</computeroutput>.
+ </para>
+ </notes>
+ </overloaded-function>
+
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/deep_copy.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/deep_copy.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/deep_copy.hpp">
+ <para>Replace all nodes stored by reference by nodes stored by value.</para>
+ <namespace name="boost">
+ <namespace name="proto">
+
+ <namespace name="result_of">
+ <!-- proto::result_of::deep_copy -->
+ <struct name="deep_copy">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <purpose>A metafunction for calculating the return type of <computeroutput>
+ <functionname alt="proto::deep_copy">proto::deep_copy()</functionname></computeroutput>.</purpose>
+ <description>
+ <para>
+ A metafunction for calculating the return type of <computeroutput>
+ <functionname alt="proto::deep_copy">proto::deep_copy()</functionname></computeroutput>. The type
+ parameter <computeroutput>Expr</computeroutput> should be the type of a Proto expression tree.
+ It should not be a reference type, nor should it be cv-qualified.
+ </para>
+ </description>
+ <typedef name="type">
+ <type><emphasis>unspecified</emphasis></type>
+ </typedef>
+ </struct>
+ </namespace>
+
+ <namespace name="functional">
+ <!-- proto::functional::deep_copy -->
+ <struct name="deep_copy">
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <purpose>A <conceptname>PolymorphicFunctionObject</conceptname> type for deep-copying Proto
+ expression trees.</purpose>
+ <description>
+ <para>
+ A <conceptname>PolymorphicFunctionObject</conceptname> type for deep-copying Proto expression trees.
+ When a tree is deep-copied, all internal nodes and terminals held by reference are instead held by value.
+ The only exception is function references, which continue to be held by reference.
+ </para>
+ </description>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type><classname>result_of::deep_copy</classname><Expr></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type><classname>result_of::deep_copy</classname><Expr>::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ <purpose>Deep-copies a Proto expression tree, turning all nodes and terminals held by
+ reference into ones held by value.</purpose>
+ </method>
+ </method-group>
+ </struct>
+ </namespace>
+
+ <!-- proto::deep_copy() -->
+ <function name="deep_copy">
+ <type>typename <classname>proto::result_of::deep_copy</classname><Expr>::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ <purpose>A function for deep-copying Proto expression trees. </purpose>
+ <description>
+ <para>
+ A function for deep-copying Proto expression trees. When a tree is deep-copied, all internal
+ nodes and terminals held by reference are instead held by value.</para>
+ </description>
+ <notes>
+ <para>
+ Terminals of reference-to-function type are left unchanged.
+ </para>
+ <para>
+ Equivalent to <computeroutput><classname>proto::functional::deep_copy</classname>()(expr)
+ </computeroutput>.
+ </para>
+ </notes>
+ </function>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/domain.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/domain.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,121 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/domain.hpp">
+ <para>
+ Contains definition of <computeroutput><classname alt="boost::proto::domain">proto::domain<></classname>
+ </computeroutput> class template and helpers for defining domains with a generator and a grammar for controlling
+ operator overloading.
+ </para>
+ <namespace name="boost">
+ <namespace name="proto">
+
+ <!-- proto::domain<> -->
+ <struct name="domain">
+ <template>
+ <template-type-parameter name="Generator">
+ <default><classname>proto::default_generator</classname></default>
+ </template-type-parameter>
+ <template-type-parameter name="Grammar">
+ <default><classname>proto::_</classname></default>
+ </template-type-parameter>
+ </template>
+ <inherit><type>Generator</type></inherit>
+ <purpose>For use in defining domain tags to be used with <computeroutput>
+ <classname alt="proto::extends">proto::extends<></classname></computeroutput>. A
+ <emphasis>domain</emphasis> associates an expression type with a <emphasis>generator</emphasis>,
+ and optionally a <emphasis>grammar</emphasis>.
+ </purpose>
+ <description>
+ <para>
+ The Generator determines how new expressions in the domain are constructed. Typically, a generator
+ wraps all new expressions in a wrapper that imparts domain-specific behaviors to expressions within
+ its domain. (See <computeroutput><classname alt="proto::extends">proto::extends<></classname></computeroutput>.)
+ </para>
+ <para>
+ The Grammar determines whether a given expression is valid within the domain, and automatically
+ disables any operator overloads which would cause an invalid expression to be created. By default,
+ the Grammar parameter defaults to the wildcard, <computeroutput><classname>proto::_</classname>
+ </computeroutput>, which makes all expressions valid within the domain.
+ </para>
+ <para>
+ Example: <programlisting> template<typename Expr>
+ struct MyExpr;
+
+ struct MyGrammar
+ : <classname>proto::or_</classname>< <classname>proto::terminal</classname><_>, <classname>proto::plus</classname><MyGrammar, MyGrammar> >
+ {};
+
+ // Define MyDomain, in which all expressions are
+ // wrapped in MyExpr<> and only expressions that
+ // conform to MyGrammar are allowed.
+ struct MyDomain
+ : <classname>proto::domain</classname><<classname>proto::generator</classname><MyExpr>, MyGrammar>
+ {};
+
+ // Use MyDomain to define MyExpr
+ template<typename Expr>
+ struct MyExpr
+ : <classname>proto::extends</classname><Expr, MyExpr<Expr>, MyDomain>
+ {
+ // ...
+ };
+ </programlisting>
+ </para>
+ </description>
+ <typedef name="proto_grammar">
+ <type>Grammar</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::default_domain -->
+ <struct name="default_domain">
+ <inherit><classname>proto::domain</classname><></inherit>
+ <purpose>The domain expressions have by default, if <computeroutput>
+ <classname alt="proto::extends">proto::extends<></classname></computeroutput> has not been used
+ to associate a domain with an expression.</purpose>
+ </struct>
+
+ <!-- proto::deduce_domain -->
+ <struct name="deduce_domain">
+ <purpose>A pseudo-domain for use in functions and metafunctions that require a domain parameter.
+ It indicates that the domain of the parent node should be inferred from the domains of the child nodes.</purpose>
+ </struct>
+
+ <!-- proto::is_domain -->
+ <struct name="is_domain">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <inherit>
+ <type>mpl::bool_< <replaceable>true-or-false</replaceable> ></type>
+ </inherit>
+ <description>
+ <para>
+ A metafunction that returns <computeroutput>mpl::true_</computeroutput> if the type
+ <computeroutput>T</computeroutput> is the type of a Proto domain;
+ <computeroutput>mpl::false_</computeroutput> otherwise. If <computeroutput>T</computeroutput>
+ inherits from <computeroutput><classname alt="proto::domain">proto::domain<></classname></computeroutput>,
+ <computeroutput>is_domain<T></computeroutput> is <computeroutput>mpl::true_</computeroutput>.
+ </para>
+ </description>
+ </struct>
+
+ <!-- proto::domain_of -->
+ <struct name="domain_of">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <description>
+ <para>
+ A metafunction that returns the domain of a given type. If <computeroutput>T</computeroutput> is a Proto
+ expression type, it returns that expression's associated domain. If not, it returns
+ <computeroutput><classname>proto::default_domain</classname></computeroutput>.
+ </para>
+ </description>
+ <typedef name="type">
+ <type><replaceable>domain-of-T</replaceable></type>
+ </typedef>
+ </struct>
+
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/eval.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/eval.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/eval.hpp">
+ <para>Contains the <functionname alt="boost::proto::eval">proto::eval()</functionname> expression evaluator.</para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="functional">
+ <!-- proto::functional::eval-->
+ <struct name="eval">
+ <purpose>A <conceptname>PolymorphicFunctionObject</conceptname> type for evaluating a given Proto
+ expression with a given context.</purpose>
+ <inherit>
+ <type>proto::callable</type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr, Context)</template-arg>
+ </specialization>
+ <inherit>
+ <type>
+ <classname>proto::result_of::eval</classname><
+ typename remove_reference< Expr >::type,
+ typename remove_reference< Context >::type
+ ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::eval</classname>< Expr, Context >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The Proto expression to evaluate.</para>
+ </description>
+ </parameter>
+ <parameter name="context">
+ <paramtype>Context &</paramtype>
+ <description>
+ <para>The context in which the expression should be evaluated. </para>
+ </description>
+ </parameter>
+ <purpose>Evaluate a given Proto expression with a given context. </purpose>
+ <returns>
+ <para>
+ <computeroutput>typename Context::template eval<Expr>()(expr, context)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::eval</classname>< Expr, Context >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ <parameter name="context">
+ <paramtype>Context const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from the above
+ function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+ </namespace>
+ <namespace name="result_of">
+ <!-- proto::result_of::eval -->
+ <struct name="eval">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <purpose>A metafunction for calculating the return type of <computeroutput>
+ <functionname alt="proto::eval">proto::eval()</functionname></computeroutput> given a
+ certain <computeroutput>Expr</computeroutput> and <computeroutput>Context</computeroutput> types.</purpose>
+ <typedef name="type">
+ <type>typename Context::template eval< Expr >::result_type</type>
+ </typedef>
+ </struct>
+ </namespace>
+ <!-- proto::eval() -->
+ <overloaded-function name="eval">
+ <signature>
+ <type>typename <classname>proto::result_of::eval</classname>< Expr, Context >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The Proto expression to evaluate.</para>
+ </description>
+ </parameter>
+ <parameter name="context">
+ <paramtype>Context &</paramtype>
+ <description>
+ <para>The context in which the expression should be evaluated.</para>
+ </description>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::eval</classname>< Expr, Context >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ <parameter name="context">
+ <paramtype>Context const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Evaluate a given Proto expression with a given context. </purpose>
+ <returns>
+ <para>
+ <computeroutput>typename Context::template eval<Expr>()(expr, context)</computeroutput>
+ </para>
+ </returns>
+ </overloaded-function>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/expr.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/expr.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,329 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/expr.hpp">
+ <namespace name="boost">
+ <namespace name="proto">
+
+ <!-- boost::proto::expr -->
+
+ <struct name="expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Args"/>
+ <template-nontype-parameter name="Arity">
+ <type>long</type>
+ <default>Args::arity</default>
+ </template-nontype-parameter>
+ </template>
+
+ <purpose>Representation of a node in an expression tree.</purpose>
+
+ <description>
+ <para>
+ <computeroutput>proto::expr<></computeroutput> is a node in an expression
+ template tree. It is a container for its child sub-trees. It also serves as the
+ terminal nodes of the tree.
+ </para>
+ <para>
+ <computeroutput>Tag</computeroutput> is type that represents the operation
+ encoded by this expression. It is typically one of the structs in the
+ <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't
+ have to be. If <computeroutput>Arity</computeroutput> is 0 then this
+ <computeroutput>expr<></computeroutput> type represents a leaf in the
+ expression tree.
+ </para>
+ <para>
+ <computeroutput>Args</computeroutput> is a list of types representing
+ the children of this expression. It is an instantiation of one of
+ <computeroutput>proto::list1<></computeroutput>,
+ <computeroutput>proto::list2<></computeroutput>, etc. The child types
+ must all themselves be either <computeroutput>expr<></computeroutput>
+ or <computeroutput>proto::expr<>&</computeroutput>, unless
+ <computeroutput>Arity</computeroutput> is 0, in which case
+ <computeroutput>Args</computeroutput> must be
+ <computeroutput>proto::term<T></computeroutput>, where
+ <computeroutput>T</computeroutput> can be any type.
+ </para>
+ <para>
+ <computeroutput>proto::expr<></computeroutput> is a valid Fusion
+ random-access sequence, where the elements of the sequence are the child
+ expressions.
+ </para>
+ </description>
+
+ <!-- typedefs -->
+
+ <typedef name="proto_tag">
+ <type>Tag</type>
+ </typedef>
+
+ <typedef name="proto_args">
+ <type>Args</type>
+ </typedef>
+
+ <typedef name="proto_arity">
+ <type>mpl::long_< Arity ></type>
+ </typedef>
+
+ <typedef name="proto_domain">
+ <type><classname>default_domain</classname></type>
+ </typedef>
+
+ <typedef name="proto_base_expr">
+ <type>expr</type>
+ </typedef>
+
+ <typedef name="proto_derived_expr">
+ <type>expr</type>
+ </typedef>
+
+ <typedef name="proto_childN">
+ <type>typename Args::child<replaceable>N</replaceable></type>
+ <purpose>For each <replaceable>N</replaceable> in <replaceable>[0,max(Arity,1))</replaceable>.</purpose>
+ </typedef>
+
+ <struct name="result">
+ <template>
+ <template-type-parameter name="Signature"/>
+ </template>
+ <description>
+ <para>
+ Encodes the return type of <computeroutput>expr<>::operator()</computeroutput>.
+ Makes <computeroutput>expr<></computeroutput> a TR1-style function object type
+ usable with <computeroutput>boost::result_of<></computeroutput>
+ </para>
+ </description>
+ <typedef name="type">
+ <type><replaceable>unspecified</replaceable></type>
+ </typedef>
+ </struct>
+
+ <method-group name="public static functions">
+
+ <!-- make -->
+ <method name="make">
+ <type>static expr const</type>
+ <template>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <requires>
+ <para>
+ The number of supplied arguments must be <computeroutput>Arity</computeroutput>.
+ </para>
+ </requires>
+ <returns>
+ <para>
+ A new <computeroutput>expr</computeroutput> object initialized with the specified arguments.
+ </para>
+ </returns>
+ </method>
+
+ </method-group>
+
+ <method-group name="public member functions">
+
+ <method name="proto_base">
+ <type>expr &</type>
+ <returns><para><computeroutput>*this</computeroutput></para></returns>
+ </method>
+
+ <method name="proto_base" cv="const">
+ <type>expr const &</type>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.</para>
+ </description>
+ </method>
+
+ <!-- operator= -->
+ <method name="operator=">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>Lazy assignment expression</para>
+ </description>
+ <returns>
+ <para>A new expression node representing the assignment operation.</para>
+ </returns>
+ </method>
+
+ <method name="operator=">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator=" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator=" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <!-- operator[] -->
+ <method name="operator[]">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>Lazy subscript expression</para>
+ </description>
+ <returns>
+ <para>A new expression node representing the subscript operation.</para>
+ </returns>
+ </method>
+
+ <method name="operator[]">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator[]" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator[]" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <!-- operator() -->
+ <method name="operator()">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>Lazy function call</para>
+ </description>
+ <returns>
+ <para>A new expression node representing the function call operation.</para>
+ </returns>
+ </method>
+
+ <method name="operator()" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ </method-group>
+
+ <data-member name="childN">
+ <type>proto_child<replaceable>N</replaceable></type>
+ <purpose>For each <replaceable>N</replaceable> in <replaceable>[0,max(Arity,1))</replaceable>.</purpose>
+ </data-member>
+
+ </struct>
+
+ <!-- proto::unexpr -->
+ <struct name="unexpr">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <purpose>Lets you inherit the interface of an expression while hiding from Proto the fact that
+ the type is a Proto expression.</purpose>
+ <method-group name="public member functions"/>
+ <constructor>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </constructor>
+ </struct>
+
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/extends.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/extends.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,479 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/extends.hpp">
+ <para>Macros and a base class for defining end-user expression types </para>
+ <namespace name="boost">
+ <namespace name="proto">
+
+ <!-- proto::is_proto_expr -->
+ <struct name="is_proto_expr">
+ <purpose>Empty type to be used as a dummy template parameter of POD expression wrappers. It allows
+ argument-dependent lookup to find Proto's operator overloads.</purpose>
+ <description>
+ <para>
+ <computeroutput>proto::is_proto_expr</computeroutput> allows argument-dependent lookup to find Proto's operator overloads. For example:
+ </para>
+ <para>
+ <programlisting> template<typename T, typename Dummy = <classname>proto::is_proto_expr</classname>>
+ struct my_terminal
+ {
+ <macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>(
+ typename <classname>proto::terminal</classname><T>::type
+ , my_terminal<T>
+ , <classname>proto::default_domain</classname>
+ )
+ };
+
+ // ...
+ my_terminal<int> _1, _2;
+ _1 + _2; // OK, uses proto::operator+</programlisting>
+ </para>
+ <para>
+ Without the second <computeroutput>Dummy</computeroutput> template parameter, Proto's operator overloads
+ would not be considered by name lookup.
+ </para>
+ </description>
+ </struct>
+
+ <!-- proto::extends -->
+ <struct name="extends">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Derived"/>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::default_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>For adding behaviors to a Proto expression template.</purpose>
+ <struct name="result">
+ <template>
+ <template-type-parameter name="Signature"/>
+ </template>
+ <typedef name="type">
+ <type><replaceable>unspecified</replaceable></type>
+ </typedef>
+ </struct>
+ <data-member name="proto_expr_">
+ <type>Expr</type>
+ </data-member>
+ <typedef name="proto_base_expr">
+ <type>typename Expr::proto_base_expr</type>
+ </typedef>
+ <typedef name="proto_domain">
+ <type>Domain</type>
+ </typedef>
+ <typedef name="proto_derived_expr">
+ <type>Derived</type>
+ </typedef>
+ <typedef name="proto_tag">
+ <type>typename proto_base_expr::proto_tag</type>
+ </typedef>
+ <typedef name="proto_args">
+ <type>typename proto_base_expr::proto_args</type>
+ </typedef>
+ <typedef name="proto_arity">
+ <type>typename proto_base_expr::proto_arity</type>
+ </typedef>
+ <typedef name="proto_childN">
+ <purpose>For each <replaceable>N</replaceable> in <replaceable>[0,max(1,proto_arity::value))</replaceable></purpose>
+ <type>typename proto_base_expr::proto_child<replaceable>N</replaceable></type>
+ </typedef>
+
+ <!-- constructors -->
+ <constructor/>
+ <constructor>
+ <parameter name="that">
+ <paramtype><classname>extends</classname> const &</paramtype>
+ </parameter>
+ </constructor>
+ <constructor>
+ <parameter name="expr_">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </constructor>
+
+ <method-group name="public static functions">
+ <method name="make">
+ <type>static Derived const</type>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </method>
+ </method-group>
+
+ <method-group name="public member functions">
+
+ <!-- proto_base() -->
+ <method name="proto_base">
+ <type>proto_base_expr &</type>
+ <returns><computeroutput>proto_expr_.proto_base()</computeroutput></returns>
+ <throws><simpara>Will not throw.</simpara></throws>
+ </method>
+ <method name="proto_base" cv="const">
+ <type>proto_base_expr const &</type>
+ <returns><computeroutput>proto_expr_.proto_base()</computeroutput></returns>
+ <throws><simpara>Will not throw.</simpara></throws>
+ </method>
+
+ <!-- operator= -->
+ <method name="operator=">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>Lazy assignment expression</para>
+ </description>
+ <returns>
+ <para>A new expression node representing the assignment operation.</para>
+ </returns>
+ </method>
+
+ <method name="operator=">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator=" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator=" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <!-- operator[] -->
+ <method name="operator[]">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>Lazy subscript expression</para>
+ </description>
+ <returns>
+ <para>A new expression node representing the subscript operation.</para>
+ </returns>
+ </method>
+
+ <method name="operator[]">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator[]" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <method name="operator[]" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A"/>
+ </template>
+ <parameter name="a">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+
+ <!-- operator() -->
+ <method name="operator()">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>Lazy function call</para>
+ </description>
+ <returns>
+ <para>A new expression node representing the function call operation.</para>
+ </returns>
+ </method>
+
+ <method name="operator()" cv="const">
+ <type><replaceable>unspecified</replaceable></type>
+ <template>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ This is an overloaded member function, provided for convenience. It differs from
+ the above function only in what argument(s) it accepts.
+ </para>
+ </description>
+ </method>
+ </method-group>
+
+ </struct>
+
+ </namespace>
+ </namespace>
+
+ <macro name="BOOST_PROTO_BASIC_EXTENDS" kind="functionlike">
+ <macro-parameter name="Expr">
+ <purpose>Expr purpose</purpose>
+ </macro-parameter>
+ <macro-parameter name="Derived"/>
+ <macro-parameter name="Domain"/>
+ <purpose>For creating expression wrappers that to a Proto expression template, like
+ <computeroutput><classname alt="boost::proto::extends">proto::extends<></classname></computeroutput>,
+ but while retaining POD-ness of the expression wrapper.</purpose>
+ <description>
+ <para>
+ <computeroutput>BOOST_PROTO_BASIC_EXTENDS()</computeroutput> adds the basic typedefs, member functions, and
+ data members necessary to make a struct a valid Proto expression extension. It does <emphasis>not</emphasis>
+ add any constructors, virtual functions or access control blocks that would render the containing
+ struct non-POD.
+ </para>
+ <para>
+ <computeroutput>Expr</computeroutput> is the Proto expression that the enclosing struct extends.
+ <computeroutput>Derived</computeroutput> is the type of the enclosing struct.
+ <computeroutput>Domain</computeroutput> is the Proto domain to which this expression extension belongs.
+ (See <computeroutput><classname alt="boost::proto::domain">proto::domain<></classname></computeroutput>.)
+ </para>
+ <para><computeroutput>BOOST_PROTO_BASIC_EXTENDS()</computeroutput> adds to its enclosing struct
+ exactly one data member of type <computeroutput>Expr</computeroutput>.
+ </para>
+ <para>
+ <emphasis role="bold">Example:</emphasis><programlisting>template< class Expr >
+struct my_expr;
+
+struct my_domain
+ : <classname alt="boost::proto::domain">proto::domain</classname>< <classname alt="boost::proto::pod_generator">proto::pod_generator</classname>< my_expr > >
+{};
+
+template< class Expr >
+struct my_expr
+{
+ // OK, this makes my_expr<> a valid Proto expression extension.
+ // my_expr<> does /not/ have overloaded assignment, subscript,
+ // and function call operators that build expression templates, however.
+ <macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>(Expr, my_expr, my_domain)
+};
+
+// OK, my_expr<> is POD, so this is statically initialized:
+my_expr< <classname alt="boost::proto::terminal">proto::terminal</classname><int>::type > const _1 = {{1}};</programlisting>
+ </para>
+ <para>
+ See also:
+ <itemizedlist>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_ASSIGN</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_SUBSCRIPT</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_FUNCTION</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS</macroname>()</computeroutput>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </macro>
+
+ <macro name="BOOST_PROTO_EXTENDS_ASSIGN" kind="functionlike">
+ <purpose>For adding to an expression extension class an overloaded assignment operator that
+ builds an expression template.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>BOOST_PROTO_EXTENDS_ASSIGN()</computeroutput> after <computeroutput>
+ <macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>()</computeroutput> to give an expression
+ extension class an overloaded assignment operator that builds an expression template.
+ </para>
+ <para>
+ See also:
+ <itemizedlist>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_SUBSCRIPT</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_FUNCTION</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS</macroname>()</computeroutput>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </macro>
+
+ <macro name="BOOST_PROTO_EXTENDS_SUBSCRIPT" kind="functionlike">
+ <purpose>For adding to an expression extension class an overloaded subscript operator that
+ builds an expression template.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>BOOST_PROTO_EXTENDS_SUBSCRIPT()</computeroutput> after <computeroutput>
+ <macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>()</computeroutput> to give an expression
+ extension class an overloaded subscript operator that builds an expression template.
+ </para>
+ <para>
+ See also:
+ <itemizedlist>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_ASSIGN</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_FUNCTION</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS</macroname>()</computeroutput>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </macro>
+
+ <macro name="BOOST_PROTO_EXTENDS_FUNCTION" kind="functionlike">
+ <purpose>For adding to an expression extension class a set of overloaded function call operators
+ that build expression templates.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>BOOST_PROTO_EXTENDS_FUNCTION()</computeroutput> after <computeroutput>
+ <macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>()</computeroutput> to give an expression
+ extension class a set of overloaded function call operators that build expression templates.
+ In addition, <computeroutput>BOOST_PROTO_EXTENDS_FUNCTION()</computeroutput> adds a nested
+ <computeroutput>result<></computeroutput> class template that is a metafunction for
+ calculating the return type of the overloaded function call operators.
+ </para>
+ <para>
+ See also:
+ <itemizedlist>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_ASSIGN</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS_SUBSCRIPT</macroname>()</computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput><macroname>BOOST_PROTO_EXTENDS</macroname>()</computeroutput>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </macro>
+
+ <macro name="BOOST_PROTO_EXTENDS" kind="functionlike">
+ <macro-parameter name="Expr"/>
+ <macro-parameter name="Derived"/>
+ <macro-parameter name="Domain"/>
+ <purpose>For creating expression wrappers that add behaviors to a Proto expression template, like
+ <computeroutput><classname alt="boost::proto::extends">proto::extends<></classname></computeroutput>,
+ but while retaining POD-ness of the expression wrapper.</purpose>
+ <description>
+ <para>
+ Equivalent to:
+ <programlisting><macroname>BOOST_PROTO_BASIC_EXTENDS</macroname>(Expr, Derived, Domain)
+<macroname>BOOST_PROTO_EXTENDS_ASSIGN</macroname>()
+<macroname>BOOST_PROTO_EXTENDS_SUBSCRIPT</macroname>()
+<macroname>BOOST_PROTO_EXTENDS_FUNCTION</macroname>()</programlisting>
+ </para>
+ <para>
+ <emphasis role="bold">Example:</emphasis><programlisting>template< class Expr >
+struct my_expr;
+
+struct my_domain
+ : <classname alt="boost::proto::domain">proto::domain</classname>< <classname alt="boost::proto::pod_generator">proto::pod_generator</classname>< my_expr > >
+{};
+
+template< class Expr >
+struct my_expr
+{
+ // OK, this makes my_expr<> a valid Proto expression extension.
+ // my_expr<> has overloaded assignment, subscript,
+ // and function call operators that build expression templates.
+ <macroname>BOOST_PROTO_EXTENDS</macroname>(Expr, my_expr, my_domain)
+};
+
+// OK, my_expr<> is POD, so this is statically initialized:
+my_expr< <classname alt="boost::proto::terminal">proto::terminal</classname><int>::type > const _1 = {{1}};</programlisting>
+ </para>
+ </description>
+ </macro>
+
+</header>
Added: trunk/libs/proto/doc/reference/fusion.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/fusion.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/fusion.hpp">
+ <para>Make any Proto expression a valid Fusion sequence </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="functional">
+
+ <!-- proto::functional::flatten -->
+ <struct name="flatten">
+ <purpose>A <conceptname>PolymorphicFunctionObject</conceptname> type that returns a "flattened"
+ view of a Proto expression tree. </purpose>
+ <description>
+ <para>
+ A <conceptname>PolymorphicFunctionObject</conceptname> type that returns a "flattened" view
+ of a Proto expression tree. For a tree with a top-most node tag of type
+ <computeroutput>T</computeroutput>, the elements of the flattened sequence are determined by
+ recursing into each child node with the same tag type and returning those nodes of different
+ type. So for instance, the Proto expression tree corresponding to the expression
+ <computeroutput>a | b | c</computeroutput> has a flattened view with elements [a, b, c], even
+ though the tree is grouped as <computeroutput>((a | b) | c)</computeroutput>.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type>
+ <classname>proto::result_of::flatten</classname><
+ typename boost::remove_reference< Expr >::type
+ ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::flatten</classname>< Expr const >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- proto::functional::pop_front -->
+ <struct name="pop_front">
+ <purpose>A <conceptname>PolymorphicFunctionObject</conceptname> type that invokes the
+ <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument.</purpose>
+ <description>
+ <para>
+ A <conceptname>PolymorphicFunctionObject</conceptname> type that invokes the
+ <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. This is
+ useful for defining a <conceptname>CallableTransform</conceptname> such as
+ <computeroutput>pop_front(_)</computeroutput>, which removes the first child from a Proto
+ expression node. Such a transform might be used as the first argument to the
+ <computeroutput><classname alt="proto::fold">proto::fold<></classname></computeroutput>
+ transform; that is, fold all but the first child.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type>
+ fusion::result_of::pop_front<
+ typename boost::remove_reference< Expr >::type const
+ ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename fusion::result_of::pop_front< Expr const >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- proto::functional::reverse -->
+ <struct name="reverse">
+ <purpose>A <conceptname>PolymorphicFunctionObject</conceptname> type that invokes the
+ <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument.
+ </purpose>
+ <description>
+ <para>
+ A <conceptname>PolymorphicFunctionObject</conceptname> type that invokes the
+ <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. This is
+ useful for defining a <conceptname>CallableTransform</conceptname> like
+ <computeroutput>reverse(_)</computeroutput>, which reverses the order of the children
+ of a Proto expression node.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type>
+ fusion::result_of::reverse<
+ typename boost::remove_reference< Expr >::type const
+ ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename fusion::result_of::reverse< Expr const >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </method>
+ </method-group>
+ </struct>
+ </namespace>
+
+ <namespace name="result_of">
+ <!-- proto::result_of::flatten -->
+ <struct name="flatten">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <purpose>Metafunction that computes the return type of <computeroutput>
+ <functionname alt="proto::flatten">proto::flatten()</functionname></computeroutput></purpose>
+ <typedef name="type">
+ <type><emphasis>unspecified</emphasis></type>
+ </typedef>
+ </struct>
+ </namespace>
+
+ <!-- proto::flatten() -->
+ <function name="flatten">
+ <type>typename <classname>proto::result_of::flatten</classname>< Expr const >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ <purpose>A function that returns a "flattened" view of a Proto expression tree. </purpose>
+ <description>
+ <para>
+ For a tree with a top-most node tag of type <computeroutput>T</computeroutput>, the elements
+ of the flattened sequence are determined by recursing into each child node with the same tag
+ type and returning those nodes of different type. So for instance, the Proto expression tree
+ corresponding to the expression <computeroutput>a | b | c</computeroutput> has a flattened
+ view with elements [a, b, c], even though the tree is grouped as
+ <computeroutput>((a | b) | c)</computeroutput>.
+ </para>
+ </description>
+ </function>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/generate.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/generate.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,264 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/generate.hpp">
+ <para>Contains definition of <computeroutput><classname alt="boost::proto::generator">proto::generator<></classname></computeroutput>
+ class template and friends that end users can use to generate domain-specific expression wrappers.</para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <!-- proto::default_generator -->
+ <struct name="default_generator">
+ <purpose>A simple generator that passes an expression through unchanged.</purpose>
+ <description>
+ <para>
+ Generators are intended for use as the first template parameter to the
+ <computeroutput><classname alt="proto::domain">proto::domain<></classname></computeroutput>
+ class template and control if and how expressions within that domain are to be customized.
+ The <computeroutput>proto::default_generator</computeroutput> makes no modifications to the
+ expressions passed to it.
+ </para>
+ </description>
+ <inherit>
+ <type>proto::callable</type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>Expr</type>
+ </typedef>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>Expr const &</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ <description>
+ <para>A Proto expression</para>
+ </description>
+ </parameter>
+ <returns>
+ <para><computeroutput>expr</computeroutput></para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- proto::generator -->
+ <struct name="generator">
+ <template>
+ <template-nontype-parameter name="Extends">
+ <type>template< typename > class</type>
+ </template-nontype-parameter>
+ </template>
+ <purpose>A generator that wraps expressions passed to it in the specified extension wrapper.</purpose>
+ <description>
+ <para>
+ Generators are intended for use as the first template parameter to the
+ <computeroutput><classname alt="proto::domain">proto::domain<></classname></computeroutput>
+ class template and control if and how expressions within that domain are to be customized.
+ <computeroutput>proto::generator<></computeroutput> wraps each expression passed to it in
+ the <computeroutput>Extends<></computeroutput> wrapper.
+ </para>
+ </description>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>Extends< Expr ></type>
+ </typedef>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>Extends< Expr ></type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ <description>
+ <para>A Proto expression</para>
+ </description>
+ </parameter>
+ <returns>
+ <para><computeroutput>Extends<Expr>(expr)</computeroutput></para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- proto::pod_generator -->
+ <struct name="pod_generator">
+ <template>
+ <template-nontype-parameter name="Extends">
+ <type>template< typename > class</type>
+ </template-nontype-parameter>
+ </template>
+ <purpose>A generator that wraps expressions passed to it in the specified extension wrapper and uses aggregate initialization for the wrapper. </purpose>
+ <description>
+ <para>
+ Generators are intended for use as the first template parameter to the
+ <computeroutput><classname alt="proto::domain">proto::domain<></classname></computeroutput>
+ class template and control if and how expressions within that domain are to be customized.
+ <computeroutput>proto::pod_generator<></computeroutput> wraps each expression passed
+ to it in the <computeroutput>Extends<></computeroutput> wrapper, and uses aggregate
+ initialzation for the wrapped object.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>Extends< Expr ></type>
+ </typedef>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>Extends< Expr ></type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ <description>
+ <para>A Proto expression</para>
+ </description>
+ </parameter>
+ <returns>
+ <para>
+ <computeroutput>Extends<Expr> that = {expr}; return that;</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- by_value_generator -->
+ <struct name="by_value_generator">
+ <purpose>A generator that replaces child nodes held by reference with ones held by value.
+ Use with <computeroutput><classname alt="proto::compose_generators">proto::compose_generators<></classname>
+ </computeroutput> to forward that result to another generator.
+ </purpose>
+ <description>
+ <para>
+ Generators are intended for use as the first template parameter to the
+ <computeroutput><classname alt="proto::domain">proto::domain<></classname></computeroutput>
+ class template and control if and how expressions within that domain are to be customized.
+ <computeroutput>proto::by_value_generator</computeroutput> ensures all child nodes are held
+ by value. This generator is typically composed with a second generator for further processing,
+ as <computeroutput><classname>proto::compose_generators</classname><proto::by_value_generator,
+ MyGenerator></computeroutput>.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type><emphasis>unspecified</emphasis></type>
+ </typedef>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ <description>
+ <para>A Proto expression.</para>
+ </description>
+ </parameter>
+ <returns>
+ <para>Equivalent to <computeroutput><functionname>proto::deep_copy</functionname>(expr)</computeroutput></para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- proto::compose_generator -->
+ <struct name="compose_generators">
+ <template>
+ <template-type-parameter name="First"/>
+ <template-type-parameter name="Second"/>
+ </template>
+ <purpose>A composite generator that first applies one transform to an expression and then forwards
+ the result on to another generator for further transformation.</purpose>
+ <description>
+ <para>
+ Generators are intended for use as the first template parameter to the
+ <computeroutput><classname alt="proto::domain">proto::domain<></classname></computeroutput>
+ class template and control if and how expressions within that domain are to be customized.
+ <computeroutput>proto::compose_generators<></computeroutput> is a composite generator
+ that first applies one transform to an expression and then forwards the result on to another
+ generator for further transformation.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type>
+ boost::result_of<
+ Second(typename boost::result_of<First(Expr)>::type)
+ ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename boost::result_of<
+ Second(typename boost::result_of<First(Expr)>::type)
+ >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ <description>
+ <para>A Proto expression.</para>
+ </description>
+ </parameter>
+ <returns>
+ <para><computeroutput>Second()(First()(expr))</computeroutput></para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/literal.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/literal.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,130 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/literal.hpp">
+ <para>
+ The
+ <computeroutput><classname alt="boost::proto::literal">proto::literal<></classname></computeroutput>
+ terminal wrapper, and the
+ <computeroutput><functionname alt="boost::proto::lit">proto::lit()</functionname></computeroutput>
+ function for creating
+ <computeroutput><classname alt="boost::proto::literal">proto::literal<></classname></computeroutput>
+ wrappers.
+ </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="literal">
+ <template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::default_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <inherit>
+ <type>
+ <classname>proto::extends</classname><typename <classname>proto::terminal</classname><T>::type, proto::literal<T, Domain>, Domain></type>
+ </inherit>
+ <purpose>A simple wrapper for a terminal, provided for ease of use.</purpose>
+ <description>
+ <para>
+ A simple wrapper for a terminal, provided for ease of use. In all cases,
+ <computeroutput>proto::literal<X> l(x);</computeroutput> is equivalent to
+ <computeroutput><classname>proto::terminal</classname><X>::type l = {x};</computeroutput>.
+ </para>
+ <para>
+ The <computeroutput>Domain</computeroutput> template parameter defaults to
+ <computeroutput><classname>proto::default_domain</classname></computeroutput>.
+ </para>
+ </description>
+ <typedef name="X">
+ <purpose>For exposition only</purpose>
+ <type>typename <classname>proto::terminal</classname><T>::type</type>
+ </typedef>
+ <typedef name="value_type">
+ <type>typename <classname>proto::result_of::value</classname><X>::type</type>
+ </typedef>
+ <typedef name="reference">
+ <type>typename <classname>proto::result_of::value</classname><X &>::type</type>
+ </typedef>
+ <typedef name="const_reference">
+ <type>typename <classname>proto::result_of::value</classname><X const &>::type</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="get">
+ <type>reference</type>
+ <returns>
+ <computeroutput><functionname>proto::value</functionname>(*this)</computeroutput>
+ </returns>
+ </method>
+ <method name="get" cv="const">
+ <type>const_reference</type>
+ <returns>
+ <computeroutput><functionname>proto::value</functionname>(*this)</computeroutput>
+ </returns>
+ </method>
+ </method-group>
+ <constructor>
+ <template>
+ <template-type-parameter name="U"/>
+ </template>
+ <parameter name="u">
+ <paramtype>U &</paramtype>
+ </parameter>
+ </constructor>
+ <constructor>
+ <template>
+ <template-type-parameter name="U"/>
+ </template>
+ <parameter name="u">
+ <paramtype>U const &</paramtype>
+ </parameter>
+ </constructor>
+ <constructor>
+ <template>
+ <template-type-parameter name="U"/>
+ </template>
+ <parameter name="u">
+ <paramtype><classname>proto::literal</classname>< U, Domain > const &</paramtype>
+ </parameter>
+ </constructor>
+ </struct>
+
+ <!-- proto::lit() -->
+ <overloaded-function name="lit">
+ <signature>
+ <type><classname>proto::literal</classname>< T & > const</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ <description>
+ <para>The object to wrap.</para>
+ </description>
+ </parameter>
+ </signature>
+ <signature>
+ <type><classname>proto::literal</classname>< T const & > const</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>A helper function for creating a <computeroutput>
+ <classname alt="proto::literal">proto::literal<></classname></computeroutput> wrapper.
+ </purpose>
+ <returns>
+ <para>
+ <computeroutput><classname>proto::literal</classname><T &>(t)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ <notes>
+ <para>The returned value holds the argument by reference. </para>
+ </notes>
+ </overloaded-function>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/make_expr.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/make_expr.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,444 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/make_expr.hpp">
+ <para>
+ Definition of the <computeroutput><functionname alt="boost::proto::make_expr">proto::make_expr()</functionname>
+ </computeroutput> and <computeroutput><functionname alt="boost::proto::unpack_expr">proto::unpack_expr()</functionname>
+ </computeroutput> utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child
+ nodes, respectively.
+ </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="functional">
+ <!-- proto::functional::make_expr -->
+ <struct name="make_expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::deduce_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>A <conceptname>PolymorphicFunctionObject</conceptname> equivalent to the <computeroutput>
+ <functionname alt="proto::make_expr">proto::make_expr()</functionname></computeroutput> function.</purpose>
+ <description>
+ <para>
+ In all cases, <computeroutput>proto::functional::make_expr<Tag, Domain>()(a...)</computeroutput>
+ is equivalent to <computeroutput><functionname>proto::make_expr</functionname><Tag, Domain>(a...)</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>proto::functional::make_expr<Tag>()(a...)</computeroutput> is equivalent to
+ <computeroutput><functionname>proto::make_expr</functionname><Tag>(a...)</computeroutput>.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <specialization>
+ <template-arg>This(A...)</template-arg>
+ </specialization>
+ <inherit>
+ <type>
+ <classname>proto::result_of::make_expr</classname>< Tag, Domain, A... ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::make_expr</classname>< Tag, Domain, A const... >::type const</type>
+ <template>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ <description>
+ <para>
+ Construct an expression node with tag type <computeroutput>Tag</computeroutput> and in the
+ domain <computeroutput>Domain</computeroutput>.
+ </para>
+ <para>
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::make_expr</functionname><Tag, Domain>(a...)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- proto::functional::unpack_expr -->
+ <struct name="unpack_expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::deduce_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>A <conceptname>PolymorphicFunctionObject</conceptname> equivalent to the
+ <computeroutput><functionname alt="proto::unpack_expr">proto::unpack_expr()</functionname></computeroutput> function.
+ </purpose>
+ <description>
+ <para>
+ In all cases, <computeroutput>proto::functional::unpack_expr<Tag, Domain>()(seq)</computeroutput> is
+ equivalent to <computeroutput><functionname alt="proto::unpack_expr">proto::unpack_expr()</functionname><Tag,
+ Domain>(seq)</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>proto::functional::unpack_expr<Tag>()(seq)</computeroutput> is equivalent to
+ <computeroutput><functionname alt="proto::unpack_expr">proto::unpack_expr()</functionname><Tag>(seq)</computeroutput>.
+ </para>
+ </description>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Sequence"/>
+ </template>
+ <specialization>
+ <template-arg>This(Sequence)</template-arg>
+ </specialization>
+ <inherit>
+ <type>
+ <classname>proto::result_of::unpack_expr</classname><
+ Tag,
+ Domain,
+ typename boost::remove_reference< Sequence >::type
+ ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::unpack_expr</classname>< Tag, Domain, Sequence const >::type const</type>
+ <template>
+ <template-type-parameter name="Sequence"/>
+ </template>
+ <parameter name="sequence">
+ <paramtype>Sequence const &</paramtype>
+ <description>
+ <para>A Fusion Random Access Sequence </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Construct an expression node with tag type <computeroutput>Tag</computeroutput> and in the
+ domain <computeroutput>Domain</computeroutput>.
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::unpack_expr</functionname><Tag, Domain>(sequence)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ </namespace>
+
+ <namespace name="result_of">
+ <!-- proto::result_of::make_expr -->
+ <struct name="make_expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <purpose>Metafunction that computes the return type of the
+ <computeroutput><functionname alt="proto::make_expr">proto::make_expr()</functionname></computeroutput>
+ function, with a domain deduced from the domains of the children.</purpose>
+ <description>
+ <para>
+ Computes the return type of the
+ <computeroutput><functionname alt="proto::make_expr">proto::make_expr()</functionname></computeroutput> function.
+ </para>
+ <para>
+ In this specialization, the domain is deduced from the domains of the child types.
+ If <computeroutput><classname>proto::is_domain</classname><A<subscript>0</subscript>>::value</computeroutput>
+ is <computeroutput>true</computeroutput>, then another specialization is selected.
+ </para>
+ </description>
+ <typedef name="D">
+ <purpose>For exposition only</purpose>
+ <type><replaceable>domain-deduced-from-child-types</replaceable></type>
+ <description>
+ <para>
+ For each <computeroutput>x</computeroutput> in <computeroutput>[0,N)</computeroutput>
+ (proceeding in order beginning with <computeroutput>x=0</computeroutput>), if
+ <computeroutput><classname>proto::domain_of</classname><A<subscript>x</subscript>>::type</computeroutput> is not
+ <computeroutput><classname>proto::default_domain</classname></computeroutput>, then
+ <computeroutput>D</computeroutput> is
+ <computeroutput><classname>proto::domain_of</classname><A<subscript>x</subscript>>::type</computeroutput>.
+ Otherwise, <computeroutput>D</computeroutput> is
+ <computeroutput><classname>proto::default_domain</classname></computeroutput>.
+ </para>
+ </description>
+ </typedef>
+ <typedef name="type">
+ <type>typename <classname>proto::result_of::make_expr</classname><Tag, D, A...>::type</type>
+ </typedef>
+ </struct>
+ <struct-specialization name="make_expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <specialization>
+ <template-arg>Tag</template-arg>
+ <template-arg>Domain</template-arg>
+ <template-arg pack="1">A</template-arg>
+ </specialization>
+ <purpose>Metafunction that computes the return type of the
+ <computeroutput><functionname alt="proto::make_expr">proto::make_expr()</functionname></computeroutput>
+ function, within the specified domain.</purpose>
+ <description>
+ <para>
+ Computes the return type of the
+ <computeroutput><functionname alt="proto::make_expr">proto::make_expr()</functionname></computeroutput>
+ function.
+ </para>
+ </description>
+ <typedef name="type">
+ <description>
+ <para>
+ If <computeroutput>Tag</computeroutput> is
+ <computeroutput><classname>proto::tag::terminal</classname></computeroutput>, then
+ <computeroutput>type</computeroutput> is a typedef for
+ <computeroutput>boost::result_of<Domain(<classname>proto::expr</classname><
+ <classname>proto::tag::terminal</classname>, <classname>proto::term</classname><
+ A<subscript>0</subscript> > >)>::type</computeroutput>.
+ </para>
+ <para>
+ Otherwise, <computeroutput>type</computeroutput> is a typedef for
+ <computeroutput>boost::result_of<Domain(<classname>proto::expr</classname><
+ Tag, <classname alt="proto::listN">proto::list<emphasis>N</emphasis></classname><
+ typename <classname>proto::result_of::as_child</classname><A>::type...> >)>::type</computeroutput>
+ </para>
+ </description>
+ <type><emphasis>see-below</emphasis></type>
+ </typedef>
+ </struct-specialization>
+ <!-- proto::result_of::unpack_expr -->
+ <struct name="unpack_expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Sequence"/>
+ <template-type-parameter name="Void">
+ <default><type>void</type></default>
+ </template-type-parameter>
+ </template>
+ <purpose>Metafunction that computes the return type of the
+ <computeroutput><functionname alt="proto::unpack_expr">proto::unpack_expr()</functionname></computeroutput>
+ function, with a domain deduced from the domains of the children.
+ </purpose>
+ <description>
+ <para>
+ Compute the return type of the
+ <computeroutput><functionname alt="proto::unpack_expr">proto::unpack_expr()</functionname></computeroutput>
+ function.
+ </para>
+ <para>
+ <computeroutput>Sequence</computeroutput> is a Fusion Random Access Sequence.
+ </para>
+ <para>
+ In this specialization, the domain is deduced from the domains of the child types.
+ If <computeroutput><classname>proto::is_domain</classname><Sequence>::value</computeroutput>
+ is <computeroutput>true</computeroutput>, then another specialization is selected.
+ </para>
+ </description>
+ <typedef name="type">
+ <purpose>Where N is the size of Sequence.</purpose>
+ <type>
+ typename <classname>proto::result_of::make_expr</classname><
+ Tag,
+ typename fusion::value_at<Sequence, 0>::type,
+ ...
+ typename fusion::value_at<Sequence, <replaceable>N</replaceable>-1>::type
+ >::type
+ </type>
+ </typedef>
+ </struct>
+ <struct-specialization name="unpack_expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="Sequence"/>
+ </template>
+ <specialization>
+ <template-arg>Tag</template-arg>
+ <template-arg>Domain</template-arg>
+ <template-arg>Sequence</template-arg>
+ </specialization>
+ <purpose>Metafunction that computes the return type of the
+ <computeroutput><functionname alt="proto::unpack_expr">proto::unpack_expr()</functionname></computeroutput>
+ function, within the specified domain.
+ </purpose>
+ <description>
+ <para>
+ Computes the return type of the
+ <computeroutput><functionname alt="proto::unpack_expr">proto::unpack_expr()</functionname></computeroutput>
+ function.
+ </para>
+ </description>
+ <typedef name="type">
+ <purpose>Where N is the size of Sequence.</purpose>
+ <type>
+ typename <classname>proto::result_of::make_expr</classname><
+ Tag,
+ Domain,
+ typename fusion::value_at<Sequence, 0>::type,
+ ...
+ typename fusion::value_at<Sequence, <replaceable>N</replaceable>-1>::type
+ >::type
+ </type>
+ </typedef>
+ </struct-specialization>
+ </namespace>
+
+ <!-- proto::make_expr() -->
+ <overloaded-function name="make_expr">
+ <signature>
+ <type>typename <classname>proto::result_of::make_expr</classname><Tag, A const...>::type const</type>
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::make_expr</classname><Tag, Domain, A const...>::type const</type>
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <parameter name="a" pack="1">
+ <paramtype>A const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Construct an expression of the requested tag type with a domain and with the specified
+ arguments as children.</purpose>
+ <description>
+ <para>
+ This function template may be invoked either with or without specifying a
+ <computeroutput>Domain</computeroutput> template parameter. If no domain is specified, the domain
+ is deduced by examining in order the domains of the given arguments and taking the first that is
+ not <computeroutput><classname>proto::default_domain</classname></computeroutput>, if any such
+ domain exists, or <computeroutput><classname>proto::default_domain</classname></computeroutput>
+ otherwise.
+ </para>
+ <para>
+ Let <computeroutput><replaceable>WRAP</replaceable>(x)</computeroutput> be defined such that:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>x</computeroutput> is a <computeroutput>boost::reference_wrapper<></computeroutput>,
+ <computeroutput><replaceable>WRAP</replaceable>(x)</computeroutput> is equivalent to
+ <computeroutput><functionname>proto::as_child</functionname><Domain>(x.get())</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, <computeroutput><replaceable>WRAP</replaceable>(x)</computeroutput> is equivalent to
+ <computeroutput><functionname>proto::as_expr</functionname><Domain>(x)</computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
+ Let <computeroutput><replaceable>MAKE</replaceable><Tag>(a...)</computeroutput> be defined as
+ <computeroutput><classname>proto::expr</classname><Tag,
+ <classname alt="proto::listN">proto::list<emphasis>N</emphasis></classname><A...> >::make(a...)</computeroutput>
+ where
+ <computeroutput>A<subscript>x</subscript></computeroutput> is the type of
+ <computeroutput>a<subscript>x</subscript></computeroutput>.
+ </para>
+ <para>
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>Domain()(<replaceable>MAKE</replaceable><Tag>(<replaceable>WRAP</replaceable>(a)...))</computeroutput>.
+ </para>
+ </returns>
+ </overloaded-function>
+
+ <!-- proto::unpack_expr() -->
+ <overloaded-function name="unpack_expr">
+ <signature>
+ <type>typename <classname>proto::result_of::unpack_expr</classname><Tag, Sequence const>::type const</type>
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Sequence"/>
+ </template>
+ <parameter name="sequence">
+ <paramtype>Sequence const &</paramtype>
+ <description>
+ <para>A Fusion Random Access Sequence.</para>
+ </description>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::unpack_expr</classname><Tag, Domain, Sequence const>::type const</type>
+ <template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="Sequence"/>
+ </template>
+ <parameter name="sequence">
+ <paramtype>Sequence const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Construct an expression of the requested tag type with a domain and with children
+ from the specified Fusion Random Access Sequence.</purpose>
+ <description>
+ <para>
+ This function template may be invoked either with or without specifying a
+ <computeroutput>Domain</computeroutput> argument. If no domain is specified, the domain is
+ deduced by examining in order the domains of the elements of <computeroutput>sequence</computeroutput>
+ and taking the first that is not
+ <computeroutput><classname>proto::default_domain</classname></computeroutput>, if any such domain
+ exists, or <computeroutput><classname>proto::default_domain</classname></computeroutput> otherwise.
+ </para>
+ <para>
+ Let <computeroutput><replaceable>WRAP</replaceable><N>(s)</computeroutput>, where
+ <computeroutput>s</computeroutput> has type <computeroutput>S</computeroutput>, be defined such that:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>fusion::value_at<S,N>::type</computeroutput> is a reference,
+ <computeroutput><replaceable>WRAP</replaceable><N>(s)</computeroutput> is equivalent to
+ <computeroutput><functionname>proto::as_child</functionname><Domain>(fusion::at_c<N>(s))</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, <computeroutput><replaceable>WRAP</replaceable><N>(s)</computeroutput> is equivalent to
+ <computeroutput><functionname>proto::as_expr</functionname><Domain>(fusion::at_c<N>(s))</computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
+ Let <computeroutput><replaceable>MAKE</replaceable><Tag>(a...)</computeroutput> be defined as
+ <computeroutput><classname>proto::expr</classname><Tag,
+ <classname alt="proto::listN">proto::list<emphasis>N</emphasis></classname><A...> >::make(a...)</computeroutput>
+ where
+ <computeroutput>A<subscript>x</subscript></computeroutput> is the type of
+ <computeroutput>a<subscript>x</subscript></computeroutput>.
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>Domain()(<replaceable>MAKE</replaceable><Tag>(<replaceable>WRAP</replaceable><0>(s),...
+ <replaceable>WRAP</replaceable><<replaceable>N</replaceable>-1>(s)))</computeroutput>, where
+ <replaceable>N</replaceable> is the size of <computeroutput>Sequence</computeroutput>.
+ </para>
+ </returns>
+ </overloaded-function>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/matches.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/matches.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,820 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/matches.hpp">
+ <para>Contains definition of the <classname alt="boost::proto::matches">proto::matches<></classname>
+ metafunction for determining if a given expression matches a given pattern.</para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="_">
+ <inherit><type><classname>proto::transform</classname><_></type></inherit>
+ <purpose>A wildcard grammar element that matches any expression, and a transform that returns
+ the current expression unchanged.</purpose>
+ <description>
+ <para>
+ The wildcard type, <computeroutput>proto::_</computeroutput>, is a grammar element such
+ that <computeroutput><classname>proto::matches</classname><E, proto::_>::value</computeroutput>
+ is <computeroutput>true</computeroutput> for any expression type <computeroutput>E</computeroutput>.
+ </para>
+ <para>
+ The wildcard can also be used as a stand-in for a template argument when matching terminals.
+ For instance, the following is a grammar that will match any
+ <computeroutput>std::complex<></computeroutput> terminal:<programlisting>BOOST_MPL_ASSERT((
+ <classname>proto::matches</classname><
+ <classname>proto::terminal</classname><std::complex<double> >::type,
+ <emphasis role="bold"><classname>proto::terminal</classname><std::complex< proto::_ > ></emphasis>
+ >
+));</programlisting>
+ </para>
+ <para>
+ When used as a transform, <computeroutput>proto::_</computeroutput> returns the current expression
+ unchanged. For instance, in the following, <computeroutput>proto::_</computeroutput> is used with
+ the <computeroutput><classname alt="proto::fold">proto::fold<></classname></computeroutput>
+ transform to fold the children of a node:<programlisting>struct CountChildren :
+ <classname>proto::or_</classname><
+ // Terminals have no children
+ <classname>proto::when</classname><<classname>proto::terminal</classname><proto::_>, mpl::int_<0>()>,
+ // Use proto::fold<> to count the children of non-terminals
+ <classname>proto::otherwise</classname><
+ <classname>proto::fold</classname><
+ proto::_, // <-- fold the current expression
+ mpl::int_<0>(),
+ mpl::plus<<classname>proto::_state</classname>, mpl::int_<1> >()
+ >
+ >
+ >
+{};</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl</classname><Expr, State, Data></type></inherit>
+ <typedef name="result_type">
+ <type>Expr</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename impl::expr_param</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>An expression </para>
+ </description>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <returns>
+ <para>
+ <computeroutput>expr</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ <typedef name="proto_base_expr">
+ <type>_</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::not_ -->
+ <struct name="not_">
+ <template>
+ <template-type-parameter name="Grammar"/>
+ </template>
+ <inherit><type><classname>proto::transform</classname><not_<Grammar> ></type></inherit>
+ <purpose>Inverts the set of expressions matched by a grammar. When used as a transform,
+ <computeroutput>proto::not_<></computeroutput> returns the current expression unchanged.
+ </purpose>
+ <description>
+ <para>
+ If an expression type <computeroutput>E</computeroutput> does not match a grammar
+ <computeroutput>G</computeroutput>, then <computeroutput>E</computeroutput> <emphasis>does</emphasis>
+ match <computeroutput>proto::not_<G></computeroutput>. For example,
+ <computeroutput><classname>proto::not_</classname><<classname>proto::terminal</classname><<classname>proto::_</classname>> ></computeroutput>
+ will match any non-terminal.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl</classname><Expr, State, Data></type></inherit>
+ <typedef name="result_type">
+ <type>Expr</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename impl::expr_param</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>An expression </para>
+ </description>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::matches</classname><Expr, proto::not_>::value</computeroutput>
+ is <computeroutput>true</computeroutput>.
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput>expr</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ <typedef name="proto_base_expr">
+ <type>not_</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::if_ -->
+ <struct name="if_">
+ <template>
+ <template-type-parameter name="If"/>
+ <template-type-parameter name="Then">
+ <default><type><classname>proto::_</classname></type></default>
+ </template-type-parameter>
+ <template-type-parameter name="Else">
+ <default><type><classname>proto::not_</classname><<classname>proto::_</classname>></type></default>
+ </template-type-parameter>
+ </template>
+ <inherit><classname>proto::transform</classname><if_<If, Then, Else> ></inherit>
+ <purpose>Used to select one grammar or another based on the result of a compile-time Boolean.
+ When used as a transform, <computeroutput>proto::if_<></computeroutput> selects between two
+ transforms based on a compile-time Boolean.</purpose>
+ <description>
+ <para>
+ When <computeroutput>proto::if_<If, Then, Else></computeroutput> is used as a grammar,
+ <computeroutput>If</computeroutput> must be a Proto transform and
+ <computeroutput>Then</computeroutput> and <computeroutput>Else</computeroutput> must be grammars.
+ An expression type <computeroutput>E</computeroutput> matches
+ <computeroutput>proto::if_<If, Then, Else></computeroutput> if
+ <computeroutput>boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>, If>(E)>::type::value</computeroutput>
+ is <computeroutput>true</computeroutput> and
+ <computeroutput>E</computeroutput> matches <computeroutput>Then</computeroutput>; or, if
+ <computeroutput>boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>, If>(E)>::type::value</computeroutput>
+ is <computeroutput>false</computeroutput> and <computeroutput>E</computeroutput> matches <computeroutput>Else</computeroutput>.
+ </para>
+ <para>
+ The template parameter <computeroutput>Then</computeroutput> defaults to <computeroutput><classname>proto::_</classname></computeroutput>
+ and <computeroutput>Else</computeroutput> defaults to
+ <computeroutput><classname>proto::not_</classname><<classname>proto::_</classname>></computeroutput>,
+ so an expression type <computeroutput>E</computeroutput> will match
+ <computeroutput>proto::if_<If></computeroutput> if and only if
+ <computeroutput>boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>, If>(E)>::type::value</computeroutput>
+ is <computeroutput>true</computeroutput>.
+ </para>
+ <para>
+ <programlisting>// A grammar that only matches integral terminals,
+// using is_integral<> from Boost.Type_traits.
+struct IsIntegral :
+ <classname>proto::and_</classname><
+ <classname>proto::terminal</classname><<classname>proto::_</classname>>,
+ <classname>proto::if_</classname>< boost::is_integral<<classname>proto::_value</classname>>()>
+ >
+{};</programlisting>
+ </para>
+ <para>
+ When <computeroutput>proto::if_<If, Then, Else></computeroutput> is used as a transform,
+ <computeroutput>If</computeroutput>, <computeroutput>Then</computeroutput> and
+ <computeroutput>Else</computeroutput> must be Proto transforms. When applying the transform to
+ an expression <computeroutput>E</computeroutput>, state <computeroutput>S</computeroutput> and
+ data <computeroutput>V</computeroutput>, if
+ <computeroutput>boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>, If>(E,S,V)>::type::value</computeroutput>
+ is <computeroutput>true</computeroutput> then the <computeroutput>Then</computeroutput> transform
+ is applied; otherwise the <computeroutput>Else</computeroutput> transform is applied.
+ <programlisting>// Match a terminal. If the terminal is integral, return
+// mpl::true_; otherwise, return mpl::false_.
+struct IsIntegral2 :
+ <classname>proto::when</classname><
+ <classname>proto::terminal</classname><_>,
+ proto::if_<
+ boost::is_integral<<classname>proto::_value</classname>>(),
+ mpl::true_(),
+ mpl::false_()
+ >
+ >
+{};</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl</classname>< Expr, State, Data ></type></inherit>
+ <typedef name="result_type">
+ <type>typename mpl::if_<
+ typename boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>, If>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>, Then>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>, Else>(Expr, State, Data)>::type
+ >::type</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>An expression </para>
+ </description>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ <description>
+ <para>The current state </para>
+ </description>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ <description>
+ <para>A data of arbitrary type </para>
+ </description>
+ </parameter>
+ <returns>
+ <para>
+ <computeroutput><classname>proto::when</classname><<classname>proto::_</classname>, <replaceable>Then-or-Else</replaceable>>()(expr, state, data)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ <typedef name="proto_base_expr">
+ <type>if_</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::or_ -->
+ <struct name="or_">
+ <template>
+ <template-type-parameter name="G" pack="1"/>
+ </template>
+ <inherit><type><classname>proto::transform</classname><or_<G...> ></type></inherit>
+ <purpose>For matching one of a set of alternate grammars. Alternates are tried in order to avoid ambiguity.
+ When used as a transform, <computeroutput>proto::or_<></computeroutput> applies the transform
+ associated with the first grammar that matches the expression.</purpose>
+ <description>
+ <para>
+ An expression type <computeroutput>E</computeroutput> matches
+ <computeroutput>proto::or_<G<subscript>0</subscript>,G<subscript>1</subscript>,...G<subscript>n</subscript>></computeroutput>
+ if <computeroutput>E</computeroutput> matches any <computeroutput>G<subscript>x</subscript></computeroutput> for
+ <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>.
+ </para>
+ <para>
+ When applying
+ <computeroutput>proto::or_<G<subscript>0</subscript>,G<subscript>1</subscript>,...G<subscript>n</subscript>></computeroutput>
+ as a transform with an expression <computeroutput>e</computeroutput> of type <computeroutput>E</computeroutput>,
+ state <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent to
+ <computeroutput>G<subscript>x</subscript>()(e, s, v)</computeroutput>, where
+ <computeroutput>x</computeroutput> is the lowest number such that
+ <computeroutput><classname>proto::matches</classname><E, G<subscript>x</subscript>>::value</computeroutput>
+ is <computeroutput>true</computeroutput>.
+ </para>
+ <para>
+ The maximun number of template arguments <computeroutput>proto::or_<></computeroutput> accepts
+ is controlled by the <computeroutput><macroname>BOOST_PROTO_MAX_LOGICAL_ARITY</macroname></computeroutput>
+ macro.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl</classname>< Expr, State, Data ></type></inherit>
+ <typedef name="result_type">
+ <type><replaceable>unspecified</replaceable></type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>An expression </para>
+ </description>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ <description>
+ <para>The current state </para>
+ </description>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ <description>
+ <para>A data of arbitrary type </para>
+ </description>
+ </parameter>
+ <returns>
+ <para>
+ <computeroutput>
+ G<subscript>x</subscript>()(expr, state, data)
+ </computeroutput>, where
+ <computeroutput>x</computeroutput> is the lowest number such that
+ <computeroutput>
+ <classname>proto::matches</classname><Expr, G<subscript>x</subscript>>::value
+ </computeroutput>
+ is <computeroutput>true</computeroutput>.
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ <typedef name="proto_base_expr">
+ <type>or_</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::and_ -->
+ <struct name="and_">
+ <template>
+ <template-type-parameter name="G" pack="1"/>
+ </template>
+ <inherit><type><classname>proto::transform</classname><and_<G...> ></type></inherit>
+ <purpose>For matching all of a set of grammars. When used as a transform,
+ <computeroutput>proto::and_<></computeroutput> applies the transform associated
+ with the <emphasis>last</emphasis> grammar in the set.</purpose>
+ <description>
+ <para>
+ An expression type <computeroutput>E</computeroutput> matches
+ <computeroutput>proto::and_<G<subscript>0</subscript>,G<subscript>1</subscript>,...G<subscript>n</subscript>></computeroutput>
+ if <computeroutput>E</computeroutput> matches all <computeroutput>G<subscript>x</subscript></computeroutput>
+ for <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>.
+ </para>
+ <para>
+ When applying
+ <computeroutput>proto::and_<G<subscript>0</subscript>,G<subscript>1</subscript>,...G<subscript>n</subscript>></computeroutput>
+ as a transform with an expression <computeroutput>e</computeroutput>, state
+ <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent
+ to <computeroutput>G<subscript>n</subscript>()(e, s, v)</computeroutput>.
+ </para>
+ <para>
+ The maximun number of template arguments <computeroutput>proto::and_<></computeroutput> accepts
+ is controlled by the <computeroutput><macroname>BOOST_PROTO_MAX_LOGICAL_ARITY</macroname></computeroutput>
+ macro.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl</classname>< Expr, State, Data ></type></inherit>
+ <typedef name="result_type">
+ <type>typename boost::result_of<G<subscript>n</subscript>(Expr, State, Data)>::type</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>An expression </para>
+ </description>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ <description>
+ <para>The current state </para>
+ </description>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ <description>
+ <para>A data of arbitrary type </para>
+ </description>
+ </parameter>
+ <returns>
+ <para>
+ <computeroutput>G<subscript>n</subscript>()(expr, state, data)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ <typedef name="proto_base_expr">
+ <type>and_</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::switch_ -->
+ <struct name="switch_">
+ <template>
+ <template-type-parameter name="Cases"/>
+ </template>
+ <inherit><classname>proto::transform</classname><switch_<Cases> ></inherit>
+ <purpose>For matching one of a set of alternate grammars, which are looked up based on an
+ expression's tag type. When used as a transform,
+ <computeroutput>proto::switch_<></computeroutput> applies the transform associated
+ with the sub-grammar that matches the expression.</purpose>
+ <description>
+ <para>
+ An expression type <computeroutput>E</computeroutput> matches
+ <computeroutput>proto::switch_<C></computeroutput> if
+ <computeroutput>E</computeroutput> matches
+ <computeroutput>C::case_<E::proto_tag></computeroutput>.
+ </para>
+ <para>
+ When applying <computeroutput>proto::switch_<C></computeroutput> as a transform
+ with an expression <computeroutput>e</computeroutput> of type
+ <computeroutput>E</computeroutput>, state <computeroutput>s</computeroutput> and
+ data <computeroutput>v</computeroutput>, it is equivalent to
+ <computeroutput>C::case_<E::proto_tag>()(e, s, v)</computeroutput>.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type>
+ Cases::template case_<typename Expr::tag_type>::template impl<Expr, State, Data></type></inherit>
+ </struct>
+ <typedef name="proto_base_expr">
+ <type>switch_</type>
+ </typedef>
+ </struct>
+
+ <!-- proto::exact -->
+ <struct name="exact">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <purpose>For forcing exact matches of terminal types.</purpose>
+ <description>
+ <para>By default, matching terminals ignores references and cv-qualifiers. For instance,
+ a terminal expression of type
+ <computeroutput><classname>proto::terminal</classname><int const &>::type</computeroutput>
+ will match the grammar <computeroutput><classname>proto::terminal</classname><int></computeroutput>.
+ If that is not desired, you can force an exact match with
+ <computeroutput><classname>proto::terminal</classname><proto::exact<int> ></computeroutput>.
+ This will only match integer terminals where the terminal is held by value.</para>
+ </description>
+ </struct>
+
+ <!-- proto::convertible_to -->
+ <struct name="convertible_to">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <purpose>For matching terminals that are convertible to a type.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>proto::convertible_to<></computeroutput> to match a terminal that is
+ convertible to some type. For example, the grammar
+ <computeroutput><classname>proto::terminal</classname><proto::convertible_to<int> ></computeroutput>
+ will match any terminal whose argument is convertible to an integer.
+ </para>
+ </description>
+ </struct>
+
+ <!-- proto::vararg -->
+ <struct name="vararg">
+ <template>
+ <template-type-parameter name="Grammar"/>
+ </template>
+ <purpose>For matching a Grammar to a variable number of sub-expressions.</purpose>
+ <description>
+ <para>
+ An expression type <computeroutput><classname>proto::expr</classname><AT,
+ <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname><A<subscript>0</subscript>,...A<subscript>n</subscript>,U<subscript>0</subscript>,...U<subscript>m</subscript>> ></computeroutput>
+ matches a grammar <computeroutput><classname>proto::expr</classname><BT,
+ <classname alt="proto::listN">proto::list<replaceable>M</replaceable></classname><B<subscript>0</subscript>,...B<subscript>n</subscript>,proto::vararg<V> > ></computeroutput>
+ if <computeroutput>BT</computeroutput> is <computeroutput><classname>proto::_</classname></computeroutput>
+ or <computeroutput>AT</computeroutput>, and if
+ <computeroutput>A<subscript>x</subscript></computeroutput> matches
+ <computeroutput>B<subscript>x</subscript></computeroutput>
+ for each <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>
+ and if <computeroutput>U<subscript>x</subscript></computeroutput> matches
+ <computeroutput>V</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,m]</computeroutput>.
+ </para>
+ <para>For example:</para>
+ <para>
+ <programlisting>// Match any function call expression, irregardless
+// of the number of function arguments:
+struct Function :
+ <classname>proto::function</classname>< proto::vararg<proto::_> >
+{};</programlisting>
+ </para>
+ <para>
+ When used as a transform, <computeroutput>proto::vararg<G></computeroutput>
+ applies <computeroutput>G</computeroutput>'s transform.
+ </para>
+ </description>
+ </struct>
+
+ <!-- proto::matches -->
+ <struct name="matches">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Grammar"/>
+ </template>
+ <purpose>A Boolean metafunction that evaluates whether a given expression type matches a grammar.</purpose>
+ <description>
+ <para>
+ <computeroutput>proto::matches<Expr, Grammar></computeroutput> inherits from
+ <computeroutput>mpl::true_</computeroutput> if
+ <computeroutput>Expr::proto_base_expr</computeroutput> matches
+ <computeroutput>Grammar::proto_base_expr</computeroutput>, and from
+ <computeroutput>mpl::false_</computeroutput> otherwise.
+ </para>
+ <para>
+ Non-terminal expressions are matched against a grammar according to the following rules:
+ <itemizedlist>
+ <listitem>
+ <para>
+ The wildcard pattern, <computeroutput>
+ <classname>proto::_</classname>
+ </computeroutput>, matches any expression.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ An expression
+ <computeroutput>
+ <classname>proto::expr</classname><AT,
+ <classname alt="proto::listN">
+ proto::list<replaceable>N</replaceable>
+ </classname><A<subscript>0</subscript>,...A<subscript>n</subscript>>
+ >
+ </computeroutput>
+ matches a grammar
+ <computeroutput>
+ <classname>proto::expr</classname><BT,
+ <classname alt="proto::listN">
+ proto::list<replaceable>N</replaceable>
+ </classname><B<subscript>0</subscript>,...B<subscript>n</subscript>>
+ >
+ </computeroutput> if
+ <computeroutput>BT</computeroutput> is <computeroutput>
+ <classname>proto::_</classname>
+ </computeroutput> or
+ <computeroutput>AT</computeroutput>, and if <computeroutput>
+ A<subscript>x</subscript>
+ </computeroutput> matches
+ <computeroutput>
+ B<subscript>x</subscript>
+ </computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ An expression
+ <computeroutput>
+ <classname>proto::expr</classname><AT,
+ <classname alt="proto::listN">
+ proto::list<replaceable>N</replaceable>
+ </classname><A<subscript>0</subscript>,...A<subscript>n</subscript>,U<subscript>0</subscript>,...U<subscript>m</subscript>>
+ >
+ </computeroutput> matches a grammar
+ <computeroutput>
+ <classname>proto::expr</classname><BT,
+ <classname alt="proto::listN">
+ proto::list<replaceable>M</replaceable>
+ </classname><B<subscript>0</subscript>,...B<subscript>n</subscript>,<classname>proto::vararg</classname><V>
+ > >
+ </computeroutput> if
+ <computeroutput>BT</computeroutput> is <computeroutput>
+ <classname>proto::_</classname>
+ </computeroutput> or
+ <computeroutput>AT</computeroutput>, and if
+ <computeroutput>
+ A<subscript>x</subscript>
+ </computeroutput> matches
+ <computeroutput>
+ B<subscript>x</subscript>
+ </computeroutput> for each
+ <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput> and if
+ <computeroutput>
+ U<subscript>x</subscript>
+ </computeroutput> matches
+ <computeroutput>V</computeroutput> for each <computeroutput>x</computeroutput> in
+ <computeroutput>[0,m]</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ An expression <computeroutput>E</computeroutput> matches
+ <computeroutput>
+ <classname>proto::or_</classname><B<subscript>0</subscript>,...B<subscript>n</subscript>>
+ </computeroutput> if
+ <computeroutput>E</computeroutput> matches some
+ <computeroutput>
+ B<subscript>x</subscript>
+ </computeroutput> for
+ <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ An expression <computeroutput>E</computeroutput> matches
+ <computeroutput>
+ <classname>proto::and_</classname><B<subscript>0</subscript>,...B<subscript>n</subscript>>
+ </computeroutput> if
+ <computeroutput>E</computeroutput> matches all
+ <computeroutput>
+ B<subscript>x</subscript>
+ </computeroutput> for
+ <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ An expression <computeroutput>E</computeroutput> matches
+ <computeroutput>
+ <classname>proto::if_</classname><T,U,V>
+ </computeroutput> if:
+ <itemizedlist>
+ <listitem>
+ <computeroutput>
+ boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>,T>(E)>::type::value
+ </computeroutput>
+ is <computeroutput>true</computeroutput> and
+ <computeroutput>E</computeroutput> matches
+ <computeroutput>U</computeroutput>, <emphasis>or</emphasis>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ boost::result_of<<classname>proto::when</classname><<classname>proto::_</classname>,T>(E)>::type::value
+ </computeroutput>
+ is <computeroutput>false</computeroutput> and <computeroutput>E</computeroutput> matches
+ <computeroutput>V</computeroutput>.
+ </listitem>
+ </itemizedlist>
+ Note: <computeroutput>U</computeroutput> defaults to <computeroutput>
+ <classname>proto::_</classname>
+ </computeroutput>
+ and <computeroutput>V</computeroutput> defaults to
+ <computeroutput>
+ <classname>proto::not_</classname><<classname>proto::_</classname>>
+ </computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ An expression <computeroutput>E</computeroutput> matches
+ <computeroutput>
+ <classname>proto::not_</classname><T>
+ </computeroutput> if
+ <computeroutput>E</computeroutput> does <emphasis>not</emphasis> match <computeroutput>T</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ An expression <computeroutput>E</computeroutput> matches
+ <computeroutput>
+ <classname>proto::switch_</classname><C>
+ </computeroutput> if
+ <computeroutput>E</computeroutput> matches <computeroutput>C::case_<E::proto_tag></computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ A terminal expression
+ <computeroutput>
+ <classname>proto::expr</classname><<classname>proto::tag::terminal</classname>,
+ <classname>proto::term</classname><A> >
+ </computeroutput> matches a grammar
+ <computeroutput>
+ <classname>proto::expr</classname><BT, <classname>proto::term</classname><B> >
+ </computeroutput>
+ if <computeroutput>BT</computeroutput> is <computeroutput>
+ <classname>proto::_</classname>
+ </computeroutput> or
+ <computeroutput>
+ <classname>proto::tag::terminal</classname>
+ </computeroutput> and one of the following is true:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>B</computeroutput> is the wildcard pattern,
+ <computeroutput>
+ <classname>proto::_</classname>
+ </computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>A</computeroutput> is <computeroutput>B</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>A</computeroutput> is <computeroutput>B &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>A</computeroutput> is <computeroutput>B const &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>B</computeroutput> is <computeroutput>
+ <classname>proto::exact</classname><A>
+ </computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>B</computeroutput> is
+ <computeroutput>
+ <classname>proto::convertible_to</classname><X>
+ </computeroutput>
+ and <computeroutput>boost::is_convertible<A,X>::value</computeroutput> is
+ <computeroutput>true</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>A</computeroutput> is <computeroutput>X[M]</computeroutput> or
+ <computeroutput>X(&)[M]</computeroutput> and
+ <computeroutput>B</computeroutput> is <computeroutput>
+ X[<globalname>proto::N</globalname>]
+ </computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>A</computeroutput> is <computeroutput>X(&)[M]</computeroutput>
+ and <computeroutput>B</computeroutput> is <computeroutput>
+ X(&)[<globalname>proto::N</globalname>]
+ </computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>A</computeroutput> is <computeroutput>X[M]</computeroutput> or
+ <computeroutput>X(&)[M]</computeroutput> and <computeroutput>B</computeroutput> is
+ <computeroutput>X*</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>B</computeroutput> <replaceable>lambda-matches</replaceable>
+ <computeroutput>A</computeroutput> (see below).
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ A type <computeroutput>B</computeroutput> <replaceable>lambda-matches</replaceable>
+ <computeroutput>A</computeroutput> if one of the following is true:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>B</computeroutput> is <computeroutput>A</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>B</computeroutput> is the wildcard pattern, <computeroutput>
+ <classname>proto::_</classname>
+ </computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>B</computeroutput> is <computeroutput>
+ T<B<subscript>0</subscript>,...B<subscript>n</subscript>>
+ </computeroutput> and <computeroutput>A</computeroutput> is <computeroutput>
+ T<A<subscript>0</subscript>,...A<subscript>n</subscript>>
+ </computeroutput> and for each <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>,
+ <computeroutput>A<subscript>x</subscript></computeroutput> and
+ <computeroutput>B<subscript>x</subscript></computeroutput> are types such that
+ <computeroutput>A<subscript>x</subscript></computeroutput> <replaceable>lambda-matches</replaceable>
+ <computeroutput>B<subscript>x</subscript></computeroutput>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ <inherit>
+ <type>mpl::bool_<<replaceable>true-or-false</replaceable>></type></inherit>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/operators.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/operators.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,1843 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/operators.hpp">
+ <para>Contains all the overloaded operators that make it possible to build Proto expression trees. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="is_extension">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <inherit><type>mpl::false_</type></inherit>
+ <purpose>Boolean metafunction that can be used to enable the operator overloads in the
+ <computeroutput>exops</computeroutput> namespace for the specified non-Proto terminal type.</purpose>
+ </struct>
+ <function name="operator+">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator~">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator~">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator!">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator!">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator++">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator++">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator--">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator--">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator++">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>int</paramtype>
+ </parameter>
+ </function>
+ <function name="operator++">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>int</paramtype>
+ </parameter>
+ </function>
+ <function name="operator--">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg &</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>int</paramtype>
+ </parameter>
+ </function>
+ <function name="operator--">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Arg"/>
+ </template>
+ <parameter name="arg">
+ <paramtype>Arg const &</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>int</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator==">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator==">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator==">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator==">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator!=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator!=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator!=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator!=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator||">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator||">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator||">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator||">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator,">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator,">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator,">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator,">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator->*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator->*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator->*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator->*">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator<<=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator>>=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator*=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator/=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator%=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator+=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator-=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator&=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator|=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right &</paramtype>
+ </parameter>
+ </function>
+ <function name="operator^=">
+ <type><emphasis>unspecified</emphasis></type>
+ <template>
+ <template-type-parameter name="Left"/>
+ <template-type-parameter name="Right"/>
+ </template>
+ <parameter name="left">
+ <paramtype>Left const &</paramtype>
+ </parameter>
+ <parameter name="right">
+ <paramtype>Right const &</paramtype>
+ </parameter>
+ </function>
+ <function name="if_else">
+ <type>typename <classname>proto::result_of::make_expr</classname><
+ <classname>proto::tag::if_else_</classname>,
+ <classname>proto::deduce_domain</classname>,
+ A0 const &,
+ A1 const &,
+ A2 const &
+ >::type const</type>
+ <template>
+ <template-type-parameter name="A0"/>
+ <template-type-parameter name="A1"/>
+ <template-type-parameter name="A2"/>
+ </template>
+ <parameter name="a0">
+ <paramtype>A0 const &</paramtype>
+ </parameter>
+ <parameter name="a1">
+ <paramtype>A1 const &</paramtype>
+ </parameter>
+ <parameter name="a2">
+ <paramtype>A2 const &</paramtype>
+ </parameter>
+ </function>
+ <namespace name="exops">
+ <data-member name="(is_extension, default_domain)">
+ <type><macroname>BOOST_PROTO_DEFINE_OPERATORS</macroname></type>
+ </data-member>
+ </namespace>
+ </namespace>
+ </namespace>
+ <macro name="BOOST_PROTO_DEFINE_OPERATORS" kind="functionlike">
+ <macro-parameter name="Trait"/>
+ <macro-parameter name="Domain"/>
+ <purpose>Defines a complete set of expression template-building operator overloads for use
+ with non-Proto terminal types.</purpose>
+ <description>
+ <para>
+ With <computeroutput>BOOST_PROTO_DEFINE_OPERATORS()</computeroutput>, it is possible to
+ non-intrusively adapt an existing (non-Proto) type to be a Proto terminal.
+ </para>
+ <para>
+ <computeroutput>Trait</computeroutput> is the name of a unary Boolean metafunction that returns
+ true for any types you would like to treat as Proto terminals.
+ </para>
+ <para>
+ <computeroutput>Domain</computeroutput> is the name of the Proto domain associated with
+ these new Proto terminals. You may use
+ <computeroutput><classname alt="boost::proto::default_domain">proto::default_domain</classname></computeroutput>
+ for the <computeroutput>Domain</computeroutput> if you do not wish to associate these terminals
+ with any domain.
+ </para>
+ <para>
+ <emphasis role="bold">Example:</emphasis>
+ <programlisting>namespace My {
+ // A non-Proto terminal type
+ struct S {};
+
+ // A unary Boolean metafunction that returns true for type S
+ template<typename T> struct IsS : mpl::false_ {};
+ template<> struct IsS<S> : mpl::true_ {};
+
+ // Make S a Proto terminal non-intrusively by defining the
+ // appropriate operator overloads. This should be in the same
+ // namespace as S so that these overloads can be found by
+ // argument-dependent lookup
+ <macroname>BOOST_PROTO_DEFINE_OPERATORS</macroname>(IsS, proto::default_domain)
+}
+
+int main() {
+ My::S s1, s2;
+
+ // OK, this builds a Proto expression template:
+ s1 + s2;
+}</programlisting>
+ </para>
+ </description>
+ </macro>
+</header>
Added: trunk/libs/proto/doc/reference/proto.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/proto.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/proto.hpp">
+ <para>Includes all of Proto, except the Boost.Typeof registrations.</para>
+</header>
Added: trunk/libs/proto/doc/reference/proto_fwd.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/proto_fwd.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/proto_fwd.hpp">
+ <para>Forward declarations of all of proto's public types and functions. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="callable">
+ <purpose>Base class for callable <conceptname>PolymorphicFunctionObject</conceptname>s</purpose>
+ <description>
+ <para>
+ When defining a callable <conceptname>PolymorphicFunctionObject</conceptname>, inherit
+ from <computeroutput>proto::callable</computeroutput> so that it can be used to create
+ a <conceptname>CallableTransform</conceptname>.
+ </para>
+ <para>
+ <computeroutput><classname>proto::is_callable</classname><T>::value</computeroutput> is
+ <computeroutput>true</computeroutput> for types that inherit from
+ <computeroutput>proto::callable</computeroutput>.
+ </para>
+ </description>
+ </struct>
+ <data-member name="N">
+ <description>
+ <para>Array size wildcard for Proto grammars that match array terminals.</para></description>
+ <type>int const</type>
+ </data-member>
+ <namespace name="functional">
+ <typedef name="make_terminal">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::terminal</classname> ></type>
+ </typedef>
+ <typedef name="make_unary_plus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::unary_plus</classname> ></type>
+ </typedef>
+ <typedef name="make_negate">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::negate</classname> ></type>
+ </typedef>
+ <typedef name="make_dereference">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::dereference</classname> ></type>
+ </typedef>
+ <typedef name="make_complement">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::complement</classname> ></type>
+ </typedef>
+ <typedef name="make_address_of">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::address_of</classname> ></type>
+ </typedef>
+ <typedef name="make_logical_not">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::logical_not</classname> ></type>
+ </typedef>
+ <typedef name="make_pre_inc">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::pre_inc</classname> ></type>
+ </typedef>
+ <typedef name="make_pre_dec">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::pre_dec</classname> ></type>
+ </typedef>
+ <typedef name="make_post_inc">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::post_inc</classname> ></type>
+ </typedef>
+ <typedef name="make_post_dec">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::post_dec</classname> ></type>
+ </typedef>
+ <typedef name="make_shift_left">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_left</classname> ></type>
+ </typedef>
+ <typedef name="make_shift_right">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_right</classname> ></type>
+ </typedef>
+ <typedef name="make_multiplies">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::multiplies</classname> ></type>
+ </typedef>
+ <typedef name="make_divides">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::divides</classname> ></type>
+ </typedef>
+ <typedef name="make_modulus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::modulus</classname> ></type>
+ </typedef>
+ <typedef name="make_plus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::plus</classname> ></type>
+ </typedef>
+ <typedef name="make_minus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::minus</classname> ></type>
+ </typedef>
+ <typedef name="make_less">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::less</classname> ></type>
+ </typedef>
+ <typedef name="make_greater">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::greater</classname> ></type>
+ </typedef>
+ <typedef name="make_less_equal">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::less_equal</classname> ></type>
+ </typedef>
+ <typedef name="make_greater_equal">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::greater_equal</classname> ></type>
+ </typedef>
+ <typedef name="make_equal_to">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::equal_to</classname> ></type>
+ </typedef>
+ <typedef name="make_not_equal_to">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::not_equal_to</classname> ></type>
+ </typedef>
+ <typedef name="make_logical_or">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::logical_or</classname> ></type>
+ </typedef>
+ <typedef name="make_logical_and">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::logical_and</classname> ></type>
+ </typedef>
+ <typedef name="make_bitwise_and">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_and</classname> ></type>
+ </typedef>
+ <typedef name="make_bitwise_or">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_or</classname> ></type>
+ </typedef>
+ <typedef name="make_bitwise_xor">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_xor</classname> ></type>
+ </typedef>
+ <typedef name="make_comma">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::comma</classname> ></type>
+ </typedef>
+ <typedef name="make_mem_ptr">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::mem_ptr</classname> ></type>
+ </typedef>
+ <typedef name="make_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::assign</classname> ></type>
+ </typedef>
+ <typedef name="make_shift_left_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_left_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_shift_right_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_right_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_multiplies_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::multiplies_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_divides_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::divides_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_modulus_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::modulus_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_plus_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::plus_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_minus_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::minus_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_bitwise_and_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_and_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_bitwise_or_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_or_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_bitwise_xor_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_xor_assign</classname> ></type>
+ </typedef>
+ <typedef name="make_subscript">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::subscript</classname> ></type>
+ </typedef>
+ <typedef name="make_if_else">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::if_else_</classname> ></type>
+ </typedef>
+ <typedef name="make_function">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::function</classname> ></type>
+ </typedef>
+ </namespace>
+ <typedef name="_flatten">
+ <type><classname>proto::functional::flatten</classname></type>
+ </typedef>
+ <typedef name="_pop_front">
+ <type><classname>proto::functional::pop_front</classname></type>
+ </typedef>
+ <typedef name="_reverse">
+ <type><classname>proto::functional::reverse</classname></type>
+ </typedef>
+ <typedef name="_eval">
+ <type><classname>proto::functional::eval</classname></type>
+ </typedef>
+ <typedef name="_deep_copy">
+ <type><classname>proto::functional::deep_copy</classname></type>
+ </typedef>
+ <typedef name="_make_terminal">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::terminal</classname> ></type>
+ </typedef>
+ <typedef name="_make_unary_plus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::unary_plus</classname> ></type>
+ </typedef>
+ <typedef name="_make_negate">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::negate</classname> ></type>
+ </typedef>
+ <typedef name="_make_dereference">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::dereference</classname> ></type>
+ </typedef>
+ <typedef name="_make_complement">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::complement</classname> ></type>
+ </typedef>
+ <typedef name="_make_address_of">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::address_of</classname> ></type>
+ </typedef>
+ <typedef name="_make_logical_not">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::logical_not</classname> ></type>
+ </typedef>
+ <typedef name="_make_pre_inc">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::pre_inc</classname> ></type>
+ </typedef>
+ <typedef name="_make_pre_dec">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::pre_dec</classname> ></type>
+ </typedef>
+ <typedef name="_make_post_inc">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::post_inc</classname> ></type>
+ </typedef>
+ <typedef name="_make_post_dec">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::post_dec</classname> ></type>
+ </typedef>
+ <typedef name="_make_shift_left">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_left</classname> ></type>
+ </typedef>
+ <typedef name="_make_shift_right">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_right</classname> ></type>
+ </typedef>
+ <typedef name="_make_multiplies">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::multiplies</classname> ></type>
+ </typedef>
+ <typedef name="_make_divides">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::divides</classname> ></type>
+ </typedef>
+ <typedef name="_make_modulus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::modulus</classname> ></type>
+ </typedef>
+ <typedef name="_make_plus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::plus</classname> ></type>
+ </typedef>
+ <typedef name="_make_minus">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::minus</classname> ></type>
+ </typedef>
+ <typedef name="_make_less">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::less</classname> ></type>
+ </typedef>
+ <typedef name="_make_greater">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::greater</classname> ></type>
+ </typedef>
+ <typedef name="_make_less_equal">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::less_equal</classname> ></type>
+ </typedef>
+ <typedef name="_make_greater_equal">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::greater_equal</classname> ></type>
+ </typedef>
+ <typedef name="_make_equal_to">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::equal_to</classname> ></type>
+ </typedef>
+ <typedef name="_make_not_equal_to">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::not_equal_to</classname> ></type>
+ </typedef>
+ <typedef name="_make_logical_or">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::logical_or</classname> ></type>
+ </typedef>
+ <typedef name="_make_logical_and">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::logical_and</classname> ></type>
+ </typedef>
+ <typedef name="_make_bitwise_and">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_and</classname> ></type>
+ </typedef>
+ <typedef name="_make_bitwise_or">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_or</classname> ></type>
+ </typedef>
+ <typedef name="_make_bitwise_xor">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_xor</classname> ></type>
+ </typedef>
+ <typedef name="_make_comma">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::comma</classname> ></type>
+ </typedef>
+ <typedef name="_make_mem_ptr">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::mem_ptr</classname> ></type>
+ </typedef>
+ <typedef name="_make_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_shift_left_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_left_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_shift_right_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::shift_right_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_multiplies_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::multiplies_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_divides_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::divides_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_modulus_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::modulus_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_plus_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::plus_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_minus_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::minus_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_bitwise_and_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_and_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_bitwise_or_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_or_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_bitwise_xor_assign">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::bitwise_xor_assign</classname> ></type>
+ </typedef>
+ <typedef name="_make_subscript">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::subscript</classname> ></type>
+ </typedef>
+ <typedef name="_make_if_else">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::if_else_</classname> ></type>
+ </typedef>
+ <typedef name="_make_function">
+ <type><classname>proto::functional::make_expr</classname>< <classname>proto::tag::function</classname> ></type>
+ </typedef>
+ <typedef name="_childN">
+ <purpose>For each <replaceable>N</replaceable> in <computeroutput>[0,BOOST_PROTO_MAX_ARITY)</computeroutput></purpose>
+ <type><classname>proto::_child_c</classname>< <replaceable>N</replaceable> ></type>
+ </typedef>
+ <typedef name="_child">
+ <type><classname alt="proto::_childN">proto::_child0</classname></type>
+ </typedef>
+ <typedef name="_left">
+ <type><classname alt="proto::_childN">proto::_child0</classname></type>
+ </typedef>
+ <typedef name="_right">
+ <type><classname alt="proto::_childN">proto::_child1</classname></type>
+ </typedef>
+ </namespace>
+ </namespace>
+ <macro name="BOOST_PROTO_MAX_ARITY">
+ <purpose>Controls the maximum number of child nodes an expression may have.</purpose>
+ <description>
+ <para>
+ <computeroutput>BOOST_PROTO_MAX_ARITY</computeroutput> defaults to 5. It may be set higher or lower, but not
+ lower than 3. Setting it higher will have a negative effect on compile times.
+ </para>
+ <para>
+ See also <computeroutput><macroname>BOOST_PROTO_MAX_FUNCTION_CALL_ARITY</macroname></computeroutput>.
+ </para>
+ </description>
+ </macro>
+ <macro name="BOOST_PROTO_MAX_LOGICAL_ARITY">
+ <purpose>Controls the maximum number of sub-grammars that
+ <computeroutput>
+ <classname alt="boost::proto::or_">proto::or_<></classname>
+ </computeroutput> and
+ <computeroutput>
+ <classname alt="boost::proto::and_">proto::and_<></classname>
+ </computeroutput> accept.</purpose>
+ <description>
+ <para>
+ <computeroutput>BOOST_PROTO_MAX_LOGICAL_ARITY</computeroutput> defaults to 8. It may be set higher or lower. Setting
+ it higher will have a negative effect on compile times.
+ </para>
+ </description>
+ </macro>
+ <macro name="BOOST_PROTO_MAX_FUNCTION_CALL_ARITY">
+ <purpose>Controls the maximum number of arguments that <computeroutput>operator()</computeroutput> overloads
+ accept.</purpose>
+ <description>
+ <para>
+ When setting
+ <computeroutput>
+ <macroname>BOOST_PROTO_MAX_ARITY</macroname>
+ </computeroutput> higher than the default, compile times
+ slow down considerably. That is due in large part to the explosion in the number of
+ <computeroutput>operator()</computeroutput> overloads that must be generated for each
+ Proto expression type. By setting <computeroutput>BOOST_PROTO_MAX_FUNCTION_CALL_ARITY</computeroutput>
+ lower than <computeroutput><macroname>BOOST_PROTO_MAX_ARITY</macroname></computeroutput>,
+ compile times can be sped up considerably.
+ </para>
+ </description>
+ </macro>
+</header>
Added: trunk/libs/proto/doc/reference/tags.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/tags.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/tags.hpp">
+ <para>Contains the tags for all the overloadable operators in C++ </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <namespace name="tag">
+ <struct name="terminal">
+ <purpose>Tag type for terminals; aka, leaves in the expression tree. </purpose>
+ </struct>
+ <struct name="unary_plus">
+ <purpose>Tag type for the unary + operator. </purpose>
+ </struct>
+ <struct name="negate">
+ <purpose>Tag type for the unary - operator. </purpose>
+ </struct>
+ <struct name="dereference">
+ <purpose>Tag type for the unary * operator. </purpose>
+ </struct>
+ <struct name="complement">
+ <purpose>Tag type for the unary ~ operator. </purpose>
+ </struct>
+ <struct name="address_of">
+ <purpose>Tag type for the unary & operator. </purpose>
+ </struct>
+ <struct name="logical_not">
+ <purpose>Tag type for the unary ! operator. </purpose>
+ </struct>
+ <struct name="pre_inc">
+ <purpose>Tag type for the unary prefix ++ operator. </purpose>
+ </struct>
+ <struct name="pre_dec">
+ <purpose>Tag type for the unary prefix -- operator. </purpose>
+ </struct>
+ <struct name="post_inc">
+ <purpose>Tag type for the unary postfix ++ operator. </purpose>
+ </struct>
+ <struct name="post_dec">
+ <purpose>Tag type for the unary postfix -- operator. </purpose>
+ </struct>
+ <struct name="shift_left">
+ <purpose>Tag type for the binary << operator. </purpose>
+ </struct>
+ <struct name="shift_right">
+ <purpose>Tag type for the binary >> operator. </purpose>
+ </struct>
+ <struct name="multiplies">
+ <purpose>Tag type for the binary * operator. </purpose>
+ </struct>
+ <struct name="divides">
+ <purpose>Tag type for the binary / operator. </purpose>
+ </struct>
+ <struct name="modulus">
+ <purpose>Tag type for the binary % operator. </purpose>
+ </struct>
+ <struct name="plus">
+ <purpose>Tag type for the binary + operator. </purpose>
+ </struct>
+ <struct name="minus">
+ <purpose>Tag type for the binary - operator. </purpose>
+ </struct>
+ <struct name="less">
+ <purpose>Tag type for the binary < operator. </purpose>
+ </struct>
+ <struct name="greater">
+ <purpose>Tag type for the binary > operator. </purpose>
+ </struct>
+ <struct name="less_equal">
+ <purpose>Tag type for the binary <= operator. </purpose>
+ </struct>
+ <struct name="greater_equal">
+ <purpose>Tag type for the binary >= operator. </purpose>
+ </struct>
+ <struct name="equal_to">
+ <purpose>Tag type for the binary == operator. </purpose>
+ </struct>
+ <struct name="not_equal_to">
+ <purpose>Tag type for the binary != operator. </purpose>
+ </struct>
+ <struct name="logical_or">
+ <purpose>Tag type for the binary || operator. </purpose>
+ </struct>
+ <struct name="logical_and">
+ <purpose>Tag type for the binary && operator. </purpose>
+ </struct>
+ <struct name="bitwise_and">
+ <purpose>Tag type for the binary & operator. </purpose>
+ </struct>
+ <struct name="bitwise_or">
+ <purpose>Tag type for the binary | operator. </purpose>
+ </struct>
+ <struct name="bitwise_xor">
+ <purpose>Tag type for the binary ^ operator. </purpose>
+ </struct>
+ <struct name="comma">
+ <purpose>Tag type for the binary , operator. </purpose>
+ </struct>
+ <struct name="mem_ptr">
+ <purpose>Tag type for the binary ->* operator. </purpose>
+ </struct>
+ <struct name="assign">
+ <purpose>Tag type for the binary = operator. </purpose>
+ </struct>
+ <struct name="shift_left_assign">
+ <purpose>Tag type for the binary <<= operator. </purpose>
+ </struct>
+ <struct name="shift_right_assign">
+ <purpose>Tag type for the binary >>= operator. </purpose>
+ </struct>
+ <struct name="multiplies_assign">
+ <purpose>Tag type for the binary *= operator. </purpose>
+ </struct>
+ <struct name="divides_assign">
+ <purpose>Tag type for the binary /= operator. </purpose>
+ </struct>
+ <struct name="modulus_assign">
+ <purpose>Tag type for the binary = operator. </purpose>
+ </struct>
+ <struct name="plus_assign">
+ <purpose>Tag type for the binary += operator. </purpose>
+ </struct>
+ <struct name="minus_assign">
+ <purpose>Tag type for the binary -= operator. </purpose>
+ </struct>
+ <struct name="bitwise_and_assign">
+ <purpose>Tag type for the binary &= operator. </purpose>
+ </struct>
+ <struct name="bitwise_or_assign">
+ <purpose>Tag type for the binary |= operator. </purpose>
+ </struct>
+ <struct name="bitwise_xor_assign">
+ <purpose>Tag type for the binary ^= operator. </purpose>
+ </struct>
+ <struct name="subscript">
+ <purpose>Tag type for the binary subscript operator. </purpose>
+ </struct>
+ <struct name="if_else_">
+ <purpose>Tag type for the ternary ?: conditional operator. </purpose>
+ </struct>
+ <struct name="function">
+ <purpose>Tag type for the n-ary function call operator. </purpose>
+ </struct>
+ </namespace>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/traits.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/traits.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,2743 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/traits.hpp">
+ <para>Contains definitions for child<>, child_c<>, left<>, right<>, tag_of<>, and the helper functions child(), child_c(), value(), left() and right(). </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="is_callable">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <purpose>Boolean metafunction which tells whether a type is a callable
+ <conceptname>PolymorphicFunctionObject</conceptname> or not.</purpose>
+ <description>
+ <para>
+ <computeroutput>proto::is_callable<></computeroutput> is used by the
+ <computeroutput><classname alt="proto::when">proto::when<></classname></computeroutput>
+ transform to determine whether a function type <computeroutput>R(A<subscript>1</subscript>,...<subscript>n</subscript>)</computeroutput>
+ is a <conceptname>CallableTransform</conceptname> or an <conceptname>ObjectTransform</conceptname>.
+ The former are evaluated using <computeroutput><classname>proto::call<></classname></computeroutput>
+ and the later with <computeroutput><classname>proto::make<></classname></computeroutput>.
+ If <computeroutput>proto::is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput>,
+ the function type is a <conceptname>CallableTransform</conceptname>; otherwise, it is an <conceptname>ObjectTransform</conceptname>.
+ </para>
+ <para>
+ Unless specialized for a type
+ <computeroutput>T</computeroutput>, <computeroutput>proto::is_callable<T>::value</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is a template type
+ <computeroutput>X<Y<subscript>0</subscript>,...Y<subscript>n</subscript>></computeroutput>,
+ where all <computeroutput>Y<subscript>x</subscript></computeroutput> are types for
+ <computeroutput>x</computeroutput> in <computeroutput>[0,n]</computeroutput>,
+ <computeroutput>proto::is_callable<T>::value</computeroutput> is
+ <computeroutput>boost::is_same<Y<subscript>n</subscript>, <classname>proto::callable</classname>>::value</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is derived from <computeroutput><classname>proto::callable</classname></computeroutput>,
+ <computeroutput>proto::is_callable<T>::value</computeroutput> is <computeroutput>true</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, <computeroutput>proto::is_callable<T>::value</computeroutput>
+ is <computeroutput>false</computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </struct>
+
+ <struct name="is_aggregate">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <purpose>A Boolean metafunction that indicates whether a type requires aggregate initialization. </purpose>
+ <description>
+ <para>
+ <computeroutput>proto::is_aggregate<></computeroutput> is used by the
+ <computeroutput><classname>proto::make<></classname></computeroutput> transform to determine how
+ to construct an object of some type <computeroutput>T</computeroutput>, given some initialization arguments
+ <computeroutput>a<subscript>0</subscript>,...a<subscript>n</subscript></computeroutput>.
+ If <computeroutput>proto::is_aggregate<T>::value</computeroutput> is <computeroutput>true</computeroutput>,
+ then an object of type <computeroutput>T</computeroutput> will be initialized as
+ <computeroutput>T t = {a<subscript>0</subscript>,...a<subscript>n</subscript>};</computeroutput>.
+ Otherwise, it will be initialized as <computeroutput>T t(a<subscript>0</subscript>,...a<subscript>n</subscript>)</computeroutput>.
+ </para>
+ <para>
+ Note: <computeroutput><classname>proto::expr<></classname> is an aggregate.</computeroutput>
+ </para>
+ </description>
+ </struct>
+ <namespace name="functional">
+ <struct name="as_expr">
+ <template>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::default_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::as_expr">proto::as_expr()</functionname></computeroutput> function.
+ </purpose>
+ <inherit><type><classname>proto::callable</classname></type></inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <specialization>
+ <template-arg>This(T)</template-arg>
+ </specialization>
+ <inherit><type><classname>proto::result_of::as_expr</classname>< T, Domain ></type></inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::as_expr</classname>< T, Domain >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ <description>
+ <para>The object to wrap. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Wrap an object in a Proto terminal if it isn't a Proto expression already.
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>proto::as_expr<Domain>(t)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::as_expr</classname>< T const, Domain >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="as_child">
+ <template>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::default_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>
+ A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::as_child">proto::as_child()</functionname></computeroutput> function.
+ </purpose>
+ <inherit><type><classname>proto::callable</classname></type></inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <specialization>
+ <template-arg>This(T)</template-arg>
+ </specialization>
+ <inherit><type><classname>proto::result_of::as_child</classname>< T, Domain ></type></inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::as_child</classname>< T, Domain >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ <description>
+ <para>The object to wrap. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Wrap an object in a Proto terminal if it isn't a Proto expression already.
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>proto::as_child<Domain>(t)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::as_child</classname>< T const, Domain >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="child_c">
+ <template>
+ <template-nontype-parameter name="N">
+ <type>long</type>
+ </template-nontype-parameter>
+ </template>
+ <purpose>
+ A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::child_c">proto::child_c()</functionname></computeroutput> function.
+ </purpose>
+ <inherit><type><classname>proto::callable</classname></type></inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit><type><classname>proto::result_of::child_c</classname>< Expr, N ></type></inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::child_c</classname>< Expr &, N >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The expression node. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Return the <replaceable>N</replaceable><superscript>th</superscript> child of the given expression.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>
+ </para>
+ <para>
+ <computeroutput>N < Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::child_c</functionname><N>(expr)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::child_c</classname>< Expr const &, N >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="child">
+ <template>
+ <template-type-parameter name="N">
+ <default>mpl::long_<0></default>
+ </template-type-parameter>
+ </template>
+ <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::child">proto::child()</functionname></computeroutput> function.</purpose>
+ <description>
+ <para>
+ A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::child">proto::child()</functionname></computeroutput>
+ function. <computeroutput>N</computeroutput> is required to be an MPL Integral Constant.
+ </para>
+ </description>
+ <inherit><type><classname>proto::callable</classname></type></inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type><classname>proto::result_of::child</classname>< Expr, N ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::child</classname>< Expr &, N >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The expression node. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Return the <replaceable>N</replaceable><superscript>th</superscript> child of the given expression.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>
+ </para>
+ <para>
+ <computeroutput>N::value < Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::child</functionname><N>(expr)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::child</classname>< Expr const &, N >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="value">
+ <purpose>
+ A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::value">proto::value()</functionname></computeroutput> function.
+ </purpose>
+ <inherit><type><classname>proto::callable</classname></type></inherit>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type><classname>proto::result_of::value</classname>< Expr ></type>
+ </inherit>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::value</classname>< Expr & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The terminal expression node. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Return the value of the given terminal expression.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>
+ </para>
+ <para>
+ <computeroutput>0 == Expr::proto_arity::value</computeroutput>
+ </para>
+ <para>
+ <computeroutput>Expr::proto_tag</computeroutput> is
+ <computeroutput><classname>proto::tag::terminal</classname></computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::value</functionname>(expr)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::value</classname>< Expr const & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="left">
+ <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::left">proto::left()</functionname></computeroutput> function.</purpose>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type><classname>proto::result_of::left</classname>< Expr ></type>
+ </inherit>
+ </struct-specialization>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::left</classname>< Expr & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The expression node. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Return the left child of the given binary expression.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>
+ </para>
+ <para>
+ <computeroutput>2 == Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::left</functionname>(expr)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::left</classname>< Expr const & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="right">
+ <purpose>A callable <conceptname>PolymorphicFunctionObject</conceptname> that is equivalent to the
+ <computeroutput><functionname alt="proto::right">proto::right()</functionname></computeroutput> function.</purpose>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <inherit>
+ <type><classname>proto::result_of::right</classname>< Expr ></type>
+ </inherit>
+ </struct-specialization>
+ <inherit>
+ <type><classname>proto::callable</classname></type>
+ </inherit>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::right</classname>< Expr & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The expression node. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>Return the right child of the given binary expression.</para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is <computeroutput>true</computeroutput>
+ </para>
+ <para>
+ <computeroutput>2 == Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::right</functionname>(expr)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::right</classname>< Expr const & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </method>
+ </method-group>
+ </struct>
+ </namespace>
+
+ <struct name="terminal">
+ <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>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="result_type">
+ <type>Expr</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>impl::expr_param</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>The current expression </para>
+ </description>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::matches</classname><Expr, proto::terminal<T> >::value</computeroutput> is <computeroutput>true</computeroutput>.
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput>expr</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ </method-group>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::terminal</classname>, <classname>proto::term</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="if_else_">
+ <template>
+ <template-type-parameter name="T"/>
+ <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>
+ that dispatches to the
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><if_else_>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::if_else_</classname>, <classname alt="proto::listN">proto::list3</classname>< T, U, V > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="unary_plus">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><unary_plus>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::unary_plus</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="negate">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><negate>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::negate</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="dereference">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><dereference>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::dereference</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="complement">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><complement>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::complement</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="address_of">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><address_of>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::address_of</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="logical_not">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><logical_not>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::logical_not</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="pre_inc">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><pre_inc>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::pre_inc</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="pre_dec">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><pre_dec>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::pre_dec</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="post_inc">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><post_inc>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::post_inc</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="post_dec">
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><post_dec>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::post_dec</classname>, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="shift_left">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><shift_left>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::shift_left</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="shift_right">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><shift_right>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::shift_right</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="multiplies">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><multiplies>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::multiplies</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="divides">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><divides>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::divides</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="modulus">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><modulus>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::modulus</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="plus">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><plus>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::plus</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="minus">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><minus>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::minus</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="less">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><less>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::less</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="greater">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><greater>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::greater</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="less_equal">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><less_equal>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::less_equal</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="greater_equal">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><greater_equal>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::greater_equal</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="equal_to">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><equal_to>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::equal_to</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="not_equal_to">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><mot_equal_to>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::not_equal_to</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="logical_or">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><logical_or>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::logical_or</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="logical_and">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><logical_and>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::logical_and</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="bitwise_and">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><bitwise_and>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::bitwise_and</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="bitwise_or">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><bitwise_or>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::bitwise_or</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="bitwise_xor">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><bitwise_xor>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::bitwise_xor</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="comma">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><comma>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::comma</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="mem_ptr">
+ <template>
+ <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"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><mem_ptr>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::mem_ptr</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="shift_left_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><shift_left_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::shift_left_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="shift_right_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><shift_right_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::shift_right_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="multiplies_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><multiplies_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::multiplies_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="divides_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><divides_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::divides_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="modulus_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><modulus_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::modulus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="plus_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><plus_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::plus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="minus_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><minus_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::minus_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="bitwise_and_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><bitwise_and_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::bitwise_and_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="bitwise_or_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><bitwise_or_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::bitwise_or_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="bitwise_xor_assign">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><bitwise_xor_assign>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::bitwise_xor_assign</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="subscript">
+ <template>
+ <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
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><subscript>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::subscript</classname>, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="function">
+ <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>
+ that dispatches to the
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><function>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< <classname>proto::tag::function</classname>, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>< A... > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="unary_expr">
+ <template>
+ <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>
+ that dispatches to the
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>proto::unary_expr<<classname>proto::_</classname>, <classname>proto::_</classname>></computeroutput>
+ as a grammar element to match any unary expression.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><unary_expr>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< Tag, <classname alt="proto::listN">proto::list1</classname>< T > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="binary_expr">
+ <template>
+ <template-type-parameter name="Tag"/>
+ <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>
+ that dispatches to the
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>proto::binary_expr<<classname>proto::_</classname>, <classname>proto::_</classname>, <classname>proto::_</classname>></computeroutput> as a grammar element to match any binary expression.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><binary_expr>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< Tag, <classname alt="proto::listN">proto::list2</classname>< T, U > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="nary_expr">
+ <template>
+ <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>
+ that dispatches to the
+ <computeroutput><classname alt="proto::pass_through">proto::pass_through<></classname></computeroutput>
+ transform.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>proto::nary_expr<<classname>proto::_</classname>, <classname>proto::vararg</classname><<classname>proto::_</classname>> ></computeroutput>
+ as a grammar element to match any n-ary expression; that is, any non-terminal.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type><classname>proto::pass_through</classname><nary_expr>::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ <typedef name="type">
+ <type><classname>proto::expr</classname>< Tag, <classname alt="proto::listN">proto::list<replaceable>N</replaceable></classname>< A0 > ></type>
+ </typedef>
+ <typedef name="proto_base_expr">
+ <type>type</type>
+ </typedef>
+ </struct>
+
+ <struct name="is_expr">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <inherit><type>mpl::bool_<<replaceable>true-or-false</replaceable>></type></inherit>
+ <purpose>A Boolean metafunction that indicates whether a given type <computeroutput>T</computeroutput>
+ is a Proto expression type.</purpose>
+ <description>
+ <para>
+ If <computeroutput>T</computeroutput> is an instantiation of <computeroutput>
+ <classname alt="proto::expr">proto::expr<></classname></computeroutput> or is an extension
+ (via <classname alt="proto::extends">proto::extends<></classname> or
+ <macroname>BOOST_PROTO_EXTENDS</macroname>()) of such an instantiation,
+ <computeroutput><classname>proto::is_expr</classname><T>::value</computeroutput>
+ is <computeroutput>true</computeroutput>.
+ Otherwise, <computeroutput><classname>proto::is_expr</classname><T>::value</computeroutput>
+ is <computeroutput>false</computeroutput>.
+ </para>
+ </description>
+ </struct>
+
+ <struct name="tag_of">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <purpose>A metafunction that returns the tag type of a Proto expression. </purpose>
+ <typedef name="type">
+ <type>typename Expr::proto_tag</type>
+ </typedef>
+ </struct>
+
+ <struct name="arity_of">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <purpose>A metafunction that returns the arity of a Proto expression. </purpose>
+ <inherit><type>Expr::proto_arity</type></inherit>
+ </struct>
+
+ <namespace name="result_of">
+ <struct name="as_expr">
+ <template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::default_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>A metafunction that computes the return type of the
+ <computeroutput><functionname alt="proto::as_expr">proto::as_expr()</functionname></computeroutput> function.</purpose>
+ <description>
+ <para>
+ The <computeroutput>proto::result_of::as_expr<></computeroutput> metafunction turns types into Proto types if they are
+ not already, by making them Proto terminals held by value if possible. Types which are already Proto types are
+ left alone.
+ </para>
+ <para>
+ If <computeroutput>T</computeroutput> is not yet a Proto type, the resulting terminal type is calculated
+ as follows:
+ </para>
+ <para>
+ If <computeroutput>T</computeroutput> is a function type, let
+ <computeroutput>A</computeroutput> be <computeroutput>T &</computeroutput>. Otherwise, let
+ <computeroutput>A</computeroutput> be the type <computeroutput>T</computeroutput> stripped of
+ cv-qualifiers. Then, the result type <computeroutput>proto::result_of::as_expr<T, Domain>::type</computeroutput>
+ is <computeroutput>boost::result_of<Domain(<classname>proto::expr</classname>< <classname>proto::tag::terminal</classname>, <classname>proto::term</classname><A> >)>::type</computeroutput>.
+ </para>
+ </description>
+ <typedef name="type">
+ <type><replaceable>see-below</replaceable></type>
+ </typedef>
+ </struct>
+
+ <struct name="as_child">
+ <template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Domain">
+ <default><classname>proto::default_domain</classname></default>
+ </template-type-parameter>
+ </template>
+ <purpose>A metafunction that computes the return type of the
+ <computeroutput><functionname alt="proto::as_child">proto::as_child()</functionname></computeroutput> function.</purpose>
+ <description>
+ <para>
+ The <computeroutput>proto::result_of::as_child<></computeroutput> metafunction turns types into Proto types
+ if they are not already by making them Proto terminals held by reference. Types which are already Proto
+ types are left alone.
+ </para>
+ <para>
+ When <computeroutput>T</computeroutput> is not yet a Proto type,
+ the result type <computeroutput>proto::result_of::as_child<T, Domain>::type</computeroutput> is
+ <computeroutput>boost::result_of<Domain(<classname>proto::expr</classname>< <classname>proto::tag::terminal</classname>, <classname>proto::term</classname><T &> >)>::type</computeroutput>.
+ </para>
+ <para>
+ When <computeroutput>T</computeroutput> is already a Proto type
+ The result type <computeroutput>proto::result_of::as_child<T, Domain>::type</computeroutput> is
+ <computeroutput>T &</computeroutput>.
+ </para>
+ </description>
+ <typedef name="type">
+ <type><replaceable>see-below</replaceable></type>
+ </typedef>
+ </struct>
+
+ <struct name="child">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="N">
+ <default>mpl::long_<0></default>
+ </template-type-parameter>
+ </template>
+ <inherit><type><classname>proto::result_of::child_c</classname><Expr, N::value></type></inherit>
+ <purpose>A metafunction that returns the type of the <replaceable>N</replaceable><superscript>th</superscript>
+ child of a Proto expression, where N is an MPL Integral Constant. </purpose>
+ <description>
+ <para>
+ <computeroutput>proto::result_of::child<Expr, N></computeroutput> is equivalent to
+ <computeroutput><classname>proto::result_of::child_c</classname><Expr, N::value></computeroutput>.
+ </para>
+ </description>
+ </struct>
+
+ <struct name="value">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <purpose>A metafunction that returns the type of the value of a terminal Proto expression. </purpose>
+ <typedef name="value_type">
+ <description>
+ <para>
+ The raw type of the <replaceable>N</replaceable><superscript>th</superscript> child as it is
+ stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference.
+ </para>
+ </description>
+ <type>typename Expr::proto_child0</type>
+ </typedef>
+ <typedef name="type">
+ <description>
+ <para>
+ If <computeroutput>Expr</computeroutput> is not a reference type, <computeroutput>type</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ If <computeroutput>Expr</computeroutput> is a non-const reference type, <computeroutput>type</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ If <computeroutput>Expr</computeroutput> is a const reference type, <computeroutput>type</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ <type><replaceable>see-below</replaceable></type>
+ </typedef>
+ </struct>
+
+ <struct name="left">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <inherit>proto::result_of::child_c< Expr, 0 ></inherit>
+ <purpose>A metafunction that returns the type of the left child of a binary Proto expression. </purpose>
+ <description>
+ <para>
+ <computeroutput>proto::result_of::left<Expr></computeroutput> is equivalent to
+ <computeroutput><classname>proto::result_of::child_c</classname><Expr, 0></computeroutput>.
+ </para>
+ </description>
+ </struct>
+
+ <struct name="right">
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <inherit>proto::result_of::child_c< Expr, 1 ></inherit>
+ <purpose>A metafunction that returns the type of the right child of a binary Proto expression. </purpose>
+ <description>
+ <para>
+ <computeroutput>proto::result_of::right<Expr></computeroutput> is equivalent to
+ <computeroutput><classname>proto::result_of::child_c</classname><Expr, 1></computeroutput>.
+ </para>
+ </description>
+ </struct>
+
+ <struct name="child_c">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-nontype-parameter name="N">
+ <type>long</type>
+ </template-nontype-parameter>
+ </template>
+ <purpose>A metafunction that returns the type of the <replaceable>N</replaceable><superscript>th</superscript>
+ child of a Proto expression. </purpose>
+ <description>
+ <para>
+ A metafunction that returns the type of the <replaceable>N</replaceable><superscript>th</superscript>
+ child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than
+ <computeroutput>Expr::proto_arity::value</computeroutput>.
+ </para>
+ </description>
+ <typedef name="value_type">
+ <description>
+ <para>
+ The raw type of the <replaceable>N</replaceable><superscript>th</superscript> child as it is stored
+ within <computeroutput>Expr</computeroutput>. This may be a value or a reference.
+ </para>
+ </description>
+ <type>typename Expr::proto_child0</type>
+ </typedef>
+ <typedef name="type">
+ <description>
+ <para>
+ If <computeroutput>Expr</computeroutput> is not a reference type, <computeroutput>type</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ If <computeroutput>Expr</computeroutput> is a non-const reference type, <computeroutput>type</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ If <computeroutput>Expr</computeroutput> is a const reference type, <computeroutput>type</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ <computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ <computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ <type><replaceable>see-below</replaceable></type>
+ </typedef>
+ </struct>
+
+ </namespace>
+
+ <overloaded-function name="as_expr">
+ <signature>
+ <type>typename <classname>proto::result_of::as_expr</classname>< T >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::as_expr</classname>< T const >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::as_expr</classname>< T, Domain >::type</type>
+ <template>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::as_expr</classname>< T const, Domain >::type</type>
+ <template>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>A function that wraps non-Proto expression types in Proto terminals and leaves Proto
+ expression types alone.</purpose>
+ <description>
+ <para>
+ The <computeroutput>proto::as_expr()</computeroutput> function turns objects into Proto terminals if they
+ are not Proto expression types already. Non-Proto types are held by value, if possible. Types which are
+ already Proto types are left alone.
+ </para>
+ <para>
+ This function can be called either with an explicitly specified
+ <computeroutput>Domain</computeroutput> parameter
+ (i.e., <computeroutput>proto::as_expr<Domain>(t)</computeroutput>), or without
+ (i.e., <computeroutput>proto::as_expr(t)</computeroutput>). If no domain is specified,
+ <computeroutput><classname>proto::default_domain</classname></computeroutput> is assumed.
+ </para>
+ <para>
+ If <computeroutput><classname>proto::is_expr</classname><T>::value</computeroutput> is
+ <computeroutput>true</computeroutput>, then the argument is returned unmodified. Otherwise,
+ the argument is wrapped in a Proto terminal expression node according to the following rules.
+ If <computeroutput>T</computeroutput> is a function type, let
+ <computeroutput>A</computeroutput> be <computeroutput>T &</computeroutput>. Otherwise, let
+ <computeroutput>A</computeroutput> be the type <computeroutput>T</computeroutput> stripped of
+ cv-qualifiers. Then, <computeroutput>proto::as_expr()</computeroutput> returns
+ <computeroutput>Domain()(<classname>proto::terminal</classname><A>::type::make(t))</computeroutput>.
+ </para>
+ </description>
+ </overloaded-function>
+
+ <overloaded-function name="as_child">
+ <signature>
+ <type>typename <classname>proto::result_of::as_child</classname>< T >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::as_child</classname>< T const >::type</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::as_child</classname>< T, Domain >::type</type>
+ <template>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::as_child</classname>< T const, Domain >::type</type>
+ <template>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>A function that wraps non-Proto expression types in Proto terminals (by reference) and leaves
+ Proto expression types alone.</purpose>
+ <description>
+ <para>
+ The <computeroutput>proto::as_child()</computeroutput> function turns objects into Proto terminals
+ if they are not Proto expression types already. Non-Proto types are held by reference. Types which
+ are already Proto types are simply returned as-is.
+ </para>
+ <para>
+ This function can be called either with an explicitly specified
+ <computeroutput>Domain</computeroutput> parameter
+ (i.e., <computeroutput>proto::as_child<Domain>(t)</computeroutput>), or without
+ (i.e., <computeroutput>proto::as_child(t)</computeroutput>). If no domain is specified,
+ <computeroutput><classname>proto::default_domain</classname></computeroutput> is assumed.
+ </para>
+ <para>
+ If <computeroutput><classname>proto::is_expr</classname><T>::value</computeroutput> is
+ <computeroutput>true</computeroutput>, then the argument is returned as-is. Otherwise,
+ <computeroutput>proto::as_child()</computeroutput> returns
+ <computeroutput>Domain()(<classname>proto::terminal</classname><T &>::type::make(t))</computeroutput>.
+ </para>
+ </description>
+ </overloaded-function>
+
+ <overloaded-function name="child">
+ <signature>
+ <type>typename <classname>proto::result_of::child</classname>< Expr &, N >::type</type>
+ <template>
+ <template-type-parameter name="N"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The Proto expression. </para>
+ </description>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::child</classname>< Expr const &, N >::type</type>
+ <template>
+ <template-type-parameter name="N"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::child</classname>< Expr & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::child</classname>< Expr const & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified Proto expression. </purpose>
+ <description>
+ <para>
+ Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified Proto expression.
+ If <computeroutput>N</computeroutput> is not specified, as in <computeroutput>proto::child(expr)</computeroutput>,
+ then <computeroutput>N</computeroutput> is assumed to be <computeroutput>mpl::long_<0></computeroutput>.
+ The child is returned by reference.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>N</computeroutput> is an MPL Integral Constant.
+ </para>
+ <para>
+ <computeroutput>N::value < Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>A reference to the <replaceable>N</replaceable><superscript>th</superscript> child
+ of <computeroutput>expr</computeroutput>.</para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </overloaded-function>
+
+ <overloaded-function name="child_c">
+ <signature>
+ <type>typename <classname>proto::result_of::child_c</classname>< Expr &, N >::type</type>
+ <template>
+ <template-nontype-parameter name="N">
+ <type>long</type>
+ </template-nontype-parameter>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::child_c</classname>< Expr const &, N >::type</type>
+ <template>
+ <template-nontype-parameter name="N">
+ <type>long</type>
+ </template-nontype-parameter>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified
+ Proto expression. </purpose>
+ <description>
+ <para>
+ Return the <replaceable>N</replaceable><superscript>th</superscript> child of the specified Proto
+ expression. The child is returned by reference.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>N < Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>A reference to the <replaceable>N</replaceable><superscript>th</superscript> child
+ of <computeroutput>expr</computeroutput>.</para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </overloaded-function>
+
+ <overloaded-function name="value">
+ <signature>
+ <type>typename <classname>proto::result_of::value</classname>< Expr & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::value</classname>< Expr const & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Return the value stored within the specified Proto terminal expression. </purpose>
+ <description>
+ <para>
+ Return the the value stored within the specified Proto terminal expression. The value is
+ returned by reference.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput>0 == Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>A reference to the terminal's value </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </overloaded-function>
+
+ <overloaded-function name="left">
+ <signature>
+ <type>typename <classname>proto::result_of::left</classname>< Expr & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::left</classname>< Expr const & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Return the left child of the specified binary Proto expression. </purpose>
+ <description>
+ <para>Return the left child of the specified binary Proto expression. The child is returned by reference.</para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>2 == Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>A reference to the left child of <computeroutput>expr</computeroutput>.
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </overloaded-function>
+
+ <overloaded-function name="right">
+ <signature>
+ <type>typename <classname>proto::result_of::right</classname>< Expr & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ <description>
+ <para>The Proto expression. </para>
+ </description>
+ </parameter>
+ </signature>
+ <signature>
+ <type>typename <classname>proto::result_of::right</classname>< Expr const & >::type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr const &</paramtype>
+ </parameter>
+ </signature>
+ <purpose>Return the right child of the specified binary Proto expression. </purpose>
+ <description>
+ <para>Return the right child of the specified binary Proto expression. The child is returned by reference.</para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::is_expr</classname><Expr>::value</computeroutput> is
+ <computeroutput>true</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>2 == Expr::proto_arity::value</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>
+ A reference to the right child of <computeroutput>expr</computeroutput>.
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </overloaded-function>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/arg.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/arg.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,455 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/arg.hpp">
+ <para>Contains definition of the childN transforms and friends.</para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="_expr">
+ <inherit><classname>proto::transform</classname>< _expr ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that returns the current expression unmodified. </purpose>
+ <description>
+ <para>
+ Example:
+ <programlisting><classname>proto::terminal</classname><int>::type i = {42};
+<classname>proto::terminal</classname><int>::type & j = proto::_expr()(i);
+assert( boost::addressof(i) == boost::addressof(j) );</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="result_type">
+ <type>Expr</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename impl::expr_param</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>The current expression. </para>
+ </description>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <para>
+ Returns the current expression.
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>expr</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+
+ <struct name="_state">
+ <inherit><classname>proto::transform</classname>< _state ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that returns the current state unmodified. </purpose>
+ <description>
+ <para>
+ Example:
+ <programlisting><classname>proto::terminal</classname><int>::type i = {42};
+char ch = proto::_state()(i, 'a');
+assert( ch == 'a' );</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="result_type">
+ <type>State</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename impl::state_param</type>
+ <parameter name="">
+ <paramtype>typename impl::expr_param</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ <description>
+ <para>The current state. </para>
+ </description>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <para>
+ Returns the current state.
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>state</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+
+ <struct name="_data">
+ <inherit><classname>proto::transform</classname>< _data ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that returns the current data unmodified. </purpose>
+ <description>
+ <para>
+ Example:
+ <programlisting><classname>proto::terminal</classname><int>::type i = {42};
+std::string str("hello");
+std::string & data = proto::_data()(i, 'a', str);
+assert( &str == &data );</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="result_type">
+ <type>Data</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename impl::data_param</type>
+ <parameter name="">
+ <paramtype>typename impl::expr_param</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ <description>
+ <para>The current data. </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Returns the current data.
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>data</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+
+ <struct name="_child_c">
+ <template>
+ <template-nontype-parameter name="N">
+ <type>int</type>
+ </template-nontype-parameter>
+ </template>
+ <inherit><classname>proto::transform</classname>< _child_c<N> ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that returns N-th child of the current expression. </purpose>
+ <description>
+ <para>
+ Example:
+ <programlisting><classname>proto::terminal</classname><int>::type i = {42};
+<classname>proto::terminal</classname><int>::type & j = proto::_child_c<0>()(-i);
+assert( boost::addressof(i) == boost::addressof(j) );</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="result_type">
+ <type>typename <classname>proto::result_of::child_c</classname>< Expr, N >::type</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::child_c</classname>< typename impl::expr_param, N >::type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>The current expression. </para>
+ </description>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <para>
+ Returns the N-th child of <computeroutput>expr</computeroutput>
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput>Expr::proto_arity::value > N</computeroutput>
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::child_c</functionname><N>(expr)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+
+ <struct name="_value">
+ <inherit><classname>proto::transform</classname>< _value ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that returns the value of the current terminal expression. </purpose>
+ <description>
+ <para>
+ Example:
+ <programlisting><classname>proto::terminal</classname><int>::type i = {42};
+int j = proto::_value()(i);
+assert( 42 == j );</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="result_type">
+ <type>typename <classname>proto::result_of::value</classname>< Expr >::type</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename <classname>proto::result_of::value</classname>< typename impl::expr_param >::type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>The current expression. </para>
+ </description>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <para>
+ Returns the value of the specified terminal expression.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput>Expr::proto_arity::value == 0</computeroutput>.
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput><functionname>proto::value</functionname>(expr)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+
+ <struct name="_byref">
+ <inherit><classname>proto::callable</classname></inherit>
+ <purpose>A unary callable <conceptname>PolymorphicFunctionObject</conceptname> that wraps its argument
+ in a <computeroutput>boost::reference_wrapper<></computeroutput>.</purpose>
+ <description>
+ <para>
+ Example:
+ <programlisting><classname>proto::terminal</classname><int>::type i = {42};
+boost::reference_wrapper<<classname>proto::terminal</classname><int>::type> j
+ = <classname>proto::when</classname><<classname>proto::_</classname>, proto::_byref(_)>()(i);
+assert( boost::addressof(i) == boost::addressof(j.get()) );</programlisting>
+ </para>
+ </description>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <specialization>
+ <template-arg>This(T &)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>boost::reference_wrapper< T > const</type>
+ </typedef>
+ </struct-specialization>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <specialization>
+ <template-arg>This(T)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>boost::reference_wrapper< T const > const</type>
+ </typedef>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>boost::reference_wrapper< T > const</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T &</paramtype>
+ <description>
+ <para>The object to wrap </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Wrap the parameter <computeroutput>t</computeroutput> in a
+ <computeroutput>boost::reference_wrapper<></computeroutput>
+ </para>
+ </description>
+ <returns>
+ <para>
+ <computeroutput>boost::ref(t)</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ <method name="operator()" cv="const">
+ <type>boost::reference_wrapper< T const > const</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+
+ <struct name="_byval">
+ <inherit><classname>proto::callable</classname></inherit>
+ <purpose>
+ A unary callable <conceptname>PolymorphicFunctionObject</conceptname> that strips references and
+ <computeroutput>boost::reference_wrapper<></computeroutput> from its argument.
+ </purpose>
+ <description>
+ <para>
+ Example:
+ <programlisting><classname>proto::terminal</classname><int>::type i = {42};
+int j = 67;
+int k = <classname>proto::when</classname><<classname>proto::_</classname>, proto::_byval(<classname>proto::_state</classname>)>()(i, boost::ref(j));
+assert( 67 == k );</programlisting>
+ </para>
+ </description>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <specialization>
+ <template-arg>This(boost::reference_wrapper< T >)</template-arg>
+ </specialization>
+ <inherit>result<This(T)></inherit>
+ </struct-specialization>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <specialization>
+ <template-arg>This(T &)</template-arg>
+ </specialization>
+ <inherit>result<This(T)></inherit>
+ </struct-specialization>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template>
+ <specialization>
+ <template-arg>This(T)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>T</type>
+ </typedef>
+ </struct-specialization>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>T</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>T const &</paramtype>
+ <description>
+ <para>The object to unref </para>
+ </description>
+ </parameter>
+ <returns>
+ <para>
+ <computeroutput>t</computeroutput>
+ </para>
+ </returns>
+ <throws>
+ <simpara>Will not throw.</simpara>
+ </throws>
+ </method>
+ <method name="operator()" cv="const">
+ <type>T</type>
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <parameter name="t">
+ <paramtype>boost::reference_wrapper< T > const &</paramtype>
+ </parameter>
+ <description>
+ <para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/call.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/call.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,190 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/call.hpp">
+ <para>Contains definition of the call<> transform. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="call">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <purpose>Make the given <conceptname>Transform</conceptname> into a <conceptname>PrimitiveTransform</conceptname>.</purpose>
+
+ <description>
+ <para>
+ The purpose of <computeroutput>proto::call<></computeroutput> is to annotate a transform as callable
+ so that <computeroutput><classname alt="proto::when">proto::when<></classname></computeroutput> knows
+ how to apply it. The template parameter must be either a <conceptname>PrimitiveTransform</conceptname> or a
+ <conceptname>CallableTransform</conceptname>; that is, a function type for which the return type is a callable
+ <conceptname>PolymorphicFunctionObject</conceptname>.
+ </para>
+
+ <para>
+ For the complete description of the behavior of the <computeroutput>proto::call<></computeroutput>
+ transform, see the documentation for the nested
+ <computeroutput>
+ <classname alt="proto::call::impl">proto::call::impl<></classname>
+ </computeroutput>
+ class template.
+ </para>
+ </description>
+
+ <inherit><type><classname>proto::transform</classname>< call<T> ></type></inherit>
+
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl<Expr, State, Data></classname></type></inherit>
+ <typedef name="result_type">
+ <type><replaceable>see-below</replaceable></type>
+ <description>
+ <para>
+ <computeroutput>proto::call<T>::impl<Expr,State,Data>::result_type</computeroutput>
+ is computed as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> if of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname></computeroutput> or
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>()</computeroutput>, then
+ <computeroutput>result_type</computeroutput> is:
+ <programlisting>typename boost::result_of<PrimitiveTransform(Expr, State, Data)>::type</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0)</computeroutput>, then
+ <computeroutput>result_type</computeroutput> is:
+ <programlisting>typename boost::result_of<PrimitiveTransform(
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
+ State,
+ Data
+)>::type</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1)</computeroutput>, then
+ <computeroutput>result_type</computeroutput> is:
+ <programlisting>typename boost::result_of<PrimitiveTransform(
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,T1>(Expr, State, Data)>::type,
+ Data
+)>::type</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1, T2)</computeroutput>, then
+ <computeroutput>result_type</computeroutput> is:
+ <programlisting>typename boost::result_of<PrimitiveTransform(
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,T1>(Expr, State, Data)>::type,
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,T2>(Expr, State, Data)>::type
+)>::type</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PolymorphicFunctionObject</conceptname>(T0,...TN)</computeroutput>, then
+ <computeroutput>result_type</computeroutput> is:
+ <programlisting>typename boost::result_of<PolymorphicFunctionObject(
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,T0>(Expr, State, Data)>::type,
+ ...
+ typename boost::result_of<<classname>when</classname><<classname>_</classname>,TN>(Expr, State, Data)>::type
+>::type</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <para>
+ <computeroutput>proto::call<T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> if of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname></computeroutput> or
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>()</computeroutput>, then
+ return
+ <programlisting>PrimitiveTransform()(expr, state, data)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0)</computeroutput>, then
+ return
+ <programlisting>PrimitiveTransform()(
+ <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
+ state,
+ sata
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1)</computeroutput>, then
+ return:
+ <programlisting>PrimitiveTransform()(
+ <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,T1>()(expr, state, data),
+ Data
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PrimitiveTransform</conceptname>(T0, T1, T2)</computeroutput>, then
+ return
+ <programlisting>PrimitiveTransform()(
+ <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,T1>()(expr, state, data),
+ <classname>when</classname><<classname>_</classname>,T2>()(expr, state, data)
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> is of the form
+ <computeroutput><conceptname>PolymorphicFunctionObject</conceptname>(T0,...TN)</computeroutput>, then
+ return:
+ <programlisting>PolymorphicFunctionObject()(
+ <classname>when</classname><<classname>_</classname>,T0>()(expr, state, data),
+ ...
+ <classname>when</classname><<classname>_</classname>,TN>()(expr, state, data)
+)</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/default.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/default.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,213 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/default.hpp">
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="_default">
+ <template>
+ <template-type-parameter name="Grammar"/>
+ </template>
+ <inherit><classname>proto::transform</classname>< _default<Grammar> ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that gives expressions their
+ usual C++ behavior</purpose>
+ <description>
+ <para>
+ For the complete description of the behavior of the <computeroutput>proto::_default</computeroutput>
+ transform, see the documentation for the nested <computeroutput>
+ <classname>proto::_default::impl<></classname>
+ </computeroutput> class template.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl<Expr, State, Data></classname></type></inherit>
+ <typedef name="Tag">
+ <purpose>For exposition only</purpose>
+ <type>typename Expr::tag_type</type>
+ </typedef>
+ <data-member name="s_expr">
+ <purpose>For exposition only</purpose>
+ <type>static Expr</type>
+ </data-member>
+ <data-member name="s_state">
+ <purpose>For exposition only</purpose>
+ <type>static State</type>
+ </data-member>
+ <data-member name="s_data">
+ <purpose>For exposition only</purpose>
+ <type>static Data</type>
+ </data-member>
+ <typedef name="result_type">
+ <type><emphasis>see-below</emphasis></type>
+ <description>
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary prefix operator,
+ then the result type is
+ <programlisting>decltype(
+ OP Grammar()(<functionname>proto::child</functionname>(s_expr), s_state, s_data)
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary postfix operator,
+ then the result type is
+ <programlisting>decltype(
+ Grammar()(<functionname>proto::child</functionname>(s_expr), s_state, s_data) OP
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a binary infix operator,
+ then the result type is
+ <programlisting>decltype(
+ Grammar()(<functionname>proto::left</functionname>(s_expr), s_state, s_data) OP
+ Grammar()(<functionname>proto::right</functionname>(s_expr), s_state, s_data)
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::subscript</classname>
+ </computeroutput>,
+ then the result type is
+ <programlisting>decltype(
+ Grammar()(<functionname>proto::left</functionname>(s_expr), s_state, s_data) [
+ Grammar()(<functionname>proto::right</functionname>(s_expr), s_state, s_data) ]
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::if_else_</classname>
+ </computeroutput>,
+ then the result type is
+ <programlisting>decltype(
+ Grammar()(<functionname>proto::child_c</functionname><0>(s_expr), s_state, s_data) ?
+ Grammar()(<functionname>proto::child_c</functionname><1>(s_expr), s_state, s_data) :
+ Grammar()(<functionname>proto::child_c</functionname><2>(s_expr), s_state, s_data)
+)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::function</classname>
+ </computeroutput>,
+ then the result type is
+ <programlisting>decltype(
+ Grammar()(<functionname>proto::child_c</functionname><0>(s_expr), s_state, s_data) (
+ Grammar()(<functionname>proto::child_c</functionname><1>(s_expr), s_state, s_data),
+ ...
+ Grammar()(<functionname>proto::child_c</functionname><N>(s_expr), s_state, s_data) )
+)</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </description>
+ </typedef>
+ <description>
+ <para>
+ Let <computeroutput><computeroutput>OP</computeroutput></computeroutput> be the C++ operator
+ corresponding to <computeroutput>Expr::proto_tag</computeroutput>. (For example, if
+ <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::plus</classname></computeroutput>, let <computeroutput>
+ <computeroutput>OP</computeroutput></computeroutput> be <computeroutput>+</computeroutput>.)
+ </para>
+ </description>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <computeroutput>
+ <classname>proto::_default</classname><Grammar>::impl<Expr, State, Data>::operator()
+ </computeroutput> returns the following:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary prefix operator,
+ then return
+ <programlisting>OP Grammar()(<functionname>proto::child</functionname>(expr), state, data)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a unary postfix operator,
+ then return
+ <programlisting>Grammar()(<functionname>proto::child</functionname>(expr), state, data) OP</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> corresponds to a binary infix operator,
+ then return
+ <programlisting>Grammar()(<functionname>proto::left</functionname>(expr), state, data) OP
+Grammar()(<functionname>proto::right</functionname>(expr), state, data)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::subscript</classname>
+ </computeroutput>,
+ then return
+ <programlisting>Grammar()(<functionname>proto::left</functionname>(expr), state, data) [
+Grammar()(<functionname>proto::right</functionname>(expr), state, data) ]</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::if_else_</classname>
+ </computeroutput>,
+ then return
+ <programlisting>Grammar()(<functionname>proto::child_c</functionname><0>(expr), state, data) ?
+Grammar()(<functionname>proto::child_c</functionname><1>(expr), state, data) :
+Grammar()(<functionname>proto::child_c</functionname><2>(expr), state, data)</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If <computeroutput>Tag</computeroutput> is <computeroutput>
+ <classname>proto::tag::function</classname>
+ </computeroutput>,
+ then return
+ <programlisting>Grammar()(<functionname>proto::child_c</functionname><0>(expr), state, data) (
+Grammar()(<functionname>proto::child_c</functionname><1>(expr), state, data),
+...
+Grammar()(<functionname>proto::child_c</functionname><N>(expr), state, data) )</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </description>
+ </method>
+ </method-group>
+ <description>
+ <para>
+ The behavior of this class is specified in terms of the C++0x <computeroutput>decltype</computeroutput>
+ keyword. In systems where this keyword is not available, Proto uses the Boost.Typeof library to
+ approximate the behavior.
+ </para>
+ </description>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/fold.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/fold.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/fold.hpp">
+ <para>Contains definition of the fold<> and reverse_fold<> transforms. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="fold">
+ <template>
+ <template-type-parameter name="Sequence"/>
+ <template-type-parameter name="State0"/>
+ <template-type-parameter name="Fun"/>
+ </template>
+ <inherit>
+ <classname>proto::transform</classname>< fold<Sequence, State0, Fun> ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that invokes the
+ <computeroutput>fusion::fold<></computeroutput> algorithm to accumulate a value.</purpose>
+ <description>
+ <para>
+ For the complete description of the behavior of the <computeroutput>proto::fold<></computeroutput>
+ transform, see the documentation for the nested <computeroutput>
+ <classname>proto::fold::impl<></classname>
+ </computeroutput> class template.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="X">
+ <purpose>For exposition only</purpose>
+ <type><classname>when</classname><<classname>_</classname>, Sequence></type>
+ </typedef>
+ <typedef name="Y">
+ <purpose>For exposition only</purpose>
+ <type><classname>when</classname><<classname>_</classname>, State0></type>
+ </typedef>
+ <typedef name="seq">
+ <purpose>A Fusion sequence, for exposition only</purpose>
+ <type>typename boost::result_of<X(Expr, State, Data)>::type</type>
+ </typedef>
+ <typedef name="state0">
+ <purpose>An initial state for the fold, for exposition only</purpose>
+ <type>typename boost::result_of<Y(Expr, State, Data)>::type</type>
+ </typedef>
+ <typedef name="fun">
+ <purpose><computeroutput>fun(v)(e,s) == when<_,Fun>()(e,s,v)</computeroutput></purpose>
+ <type><emphasis>unspecified</emphasis></type>
+ </typedef>
+ <typedef name="result_type">
+ <type>typename fusion::result_of::fold<seq, state0, fun>::type</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>The current expression </para>
+ </description>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ <description>
+ <para>The current state </para>
+ </description>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ <description>
+ <para>An arbitrary data </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Let <computeroutput>seq</computeroutput> be
+ <computeroutput>when<_, Sequence>()(expr, state, data)</computeroutput>,
+ let <computeroutput>state0</computeroutput> be
+ <computeroutput>when<_, State0>()(expr, state, data)</computeroutput>,
+ and let <computeroutput>fun(data)</computeroutput> be an object such that
+ <computeroutput>fun(data)(expr, state)</computeroutput> is equivalent to
+ <computeroutput>when<_, Fun>()(expr, state, data)</computeroutput>. Then,
+ this function returns <computeroutput>fusion::fold(seq, state0, fun(data))</computeroutput>.
+ </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+
+ <struct name="reverse_fold">
+ <template>
+ <template-type-parameter name="Sequence"/>
+ <template-type-parameter name="State0"/>
+ <template-type-parameter name="Fun"/>
+ </template>
+ <inherit><classname>proto::fold</classname>< <classname>proto::_reverse</classname>(Sequence), State0, Fun ></inherit>
+ <purpose>
+ A PrimitiveTransform that is the same as the <computeroutput><classname>proto::fold<></classname></computeroutput>
+ transform, except that it folds back-to-front instead of front-to-back. It uses the
+ <computeroutput>
+ <classname>proto::_reverse</classname>
+ </computeroutput> callable <conceptname>PolymorphicFunctionObject</conceptname> to create a
+ <computeroutput>fusion::reverse_view<></computeroutput> of the sequence before invoking
+ <computeroutput>fusion::fold<></computeroutput>.
+ </purpose>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/fold_tree.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/fold_tree.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,125 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/fold_tree.hpp">
+ <para>Contains definition of the fold_tree<> and reverse_fold_tree<> transforms. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="fold_tree">
+ <template>
+ <template-type-parameter name="Sequence"/>
+ <template-type-parameter name="State0"/>
+ <template-type-parameter name="Fun"/>
+ </template>
+ <inherit><classname>proto::transform</classname>< fold_tree<Sequence, State0, Fun> ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that recursively applies the
+ <computeroutput><classname>proto::fold</classname><></computeroutput> transform to sub-trees
+ that all share a common tag type.</purpose>
+ <description>
+ <para>
+ <computeroutput>proto::fold_tree<></computeroutput> is useful for flattening trees into lists;
+ for example, you might use <computeroutput>proto::fold_tree<></computeroutput> to flatten an
+ expression tree like <computeroutput>a | b | c</computeroutput> into a Fusion list like
+ <computeroutput>cons(c, cons(b, cons(a)))</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>proto::fold_tree<></computeroutput> is easily understood in terms of a
+ <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:
+ <programlisting> template<typename Tag, typename Fun>
+struct recurse_if_ :
+ proto::if_<
+ // If the current node has type type "Tag" ...
+ boost::is_same<proto::tag_of<proto::_>, Tag>(),
+ // ... recurse, otherwise ...
+ proto::fold<proto::_, proto::_state, recurse_if_<Tag, Fun> >,
+ // ... apply the Fun transform.
+ Fun
+ >
+{};</programlisting>
+ </para>
+ <para>
+ With <computeroutput>recurse_if_<></computeroutput> as defined above,
+ <computeroutput>proto::fold_tree<Sequence, State0, Fun>()(expr, state, data)</computeroutput>
+ is equivalent to:
+ <programlisting><classname>proto::fold</classname><
+ Sequence,
+ State0,
+ recurse_if_<typename Expr::proto_tag, Fun>
+>()(expr, state, data).</programlisting>
+ It has the effect of folding a tree front-to-back, recursing into child nodes that share a
+ tag type with the parent node.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type>
+ <classname>proto::fold</classname><Sequence, State0, recurse_if_<typename Expr::proto_tag, Fun> >
+ ::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ </struct>
+
+ <struct name="reverse_fold_tree">
+ <template>
+ <template-type-parameter name="Sequence"/>
+ <template-type-parameter name="State0"/>
+ <template-type-parameter name="Fun"/>
+ </template>
+ <inherit><classname>proto::transform</classname>< reverse_fold_tree<Sequence, State0, Fun> ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that recursively applies the
+ <computeroutput><classname>proto::reverse_fold<></classname></computeroutput> transform to
+ sub-trees that all share a common tag type.</purpose>
+ <description>
+ <para>
+ <computeroutput>proto::reverse_fold_tree<></computeroutput> is useful for flattening trees
+ into lists; for example, you might use <computeroutput>proto::reverse_fold_tree<></computeroutput>
+ to flatten an expression tree like <computeroutput>a | b | c</computeroutput> into a Fusion list like
+ <computeroutput>cons(a, cons(b, cons(c)))</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>proto::reverse_fold_tree<></computeroutput> is easily understood in terms of
+ a <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:
+ <programlisting> template<typename Tag, typename Fun>
+struct recurse_if_ :
+ proto::if_<
+ // If the current node has type type "Tag" ...
+ boost::is_same<proto::tag_of<proto::_>, Tag>(),
+ // ... recurse, otherwise ...
+ proto::reverse_fold<proto::_, proto::_state, recurse_if_<Tag, Fun> >,
+ // ... apply the Fun transform.
+ Fun
+ >
+{};</programlisting>
+ </para>
+ <para>
+ With <computeroutput>recurse_if_<></computeroutput> as defined above,
+ <computeroutput>proto::reverse_fold_tree<Sequence, State0, Fun>()(expr, state, data)</computeroutput>
+ is equivalent to:
+ <programlisting>proto::reverse_fold<
+ Sequence,
+ State0,
+ recurse_if_<typename Expr::proto_tag, Fun>
+>()(expr, state, data).</programlisting>
+ It has the effect of folding a tree back-to-front, recursing into child nodes that share a
+ tag type with the parent node.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit>
+ <type>
+ <classname>proto::reverse_fold</classname><Sequence, State0, recurse_if_<typename Expr::proto_tag, Fun> >
+ ::template impl<Expr, State, Data></type>
+ </inherit>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/impl.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/impl.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/impl.hpp">
+ <para>Contains definition of transform<> and transform_impl<> helpers. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+
+ <!-- proto::transform -->
+ <struct name="transform">
+ <template>
+ <template-type-parameter name="PrimitiveTransform"/>
+ </template>
+ <purpose>Inherit from this to make your type a <conceptname>PrimitiveTransform</conceptname>.</purpose>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>typename PrimitiveTransform::template impl< Expr, int, int >::result_type</type>
+ </typedef>
+ </struct-specialization>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr, State)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>typename PrimitiveTransform::template impl< Expr, State, int >::result_type</type>
+ </typedef>
+ </struct-specialization>
+ <struct-specialization name="result">
+ <template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <specialization>
+ <template-arg>This(Expr, State, Data)</template-arg>
+ </specialization>
+ <typedef name="type">
+ <type>typename PrimitiveTransform::template impl< Expr, State, Data >::result_type</type>
+ </typedef>
+ </struct-specialization>
+ <typedef name="transform_type">
+ <type>PrimitiveTransform</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>typename PrimitiveTransform::template impl<Expr &, <replaceable>unspecified</replaceable>, <replaceable>unspecified</replaceable>>::result_type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename PrimitiveTransform::template impl<Expr &, State &, <replaceable>unspecified</replaceable>>::result_type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>State &</paramtype>
+ </parameter>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename PrimitiveTransform::template impl<Expr &, State const &, <replaceable>unspecified</replaceable>>::result_type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>State const &</paramtype>
+ </parameter>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename PrimitiveTransform::template impl<Expr &, State &, Data &>::result_type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>State &</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>Data &</paramtype>
+ </parameter>
+ </method>
+ <method name="operator()" cv="const">
+ <type>typename PrimitiveTransform::template impl<Expr &, State const &, Data &>::result_type</type>
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <parameter name="expr">
+ <paramtype>Expr &</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>State const &</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>Data &</paramtype>
+ </parameter>
+ </method>
+ </method-group>
+ </struct>
+
+ <!-- proto::transform_impl -->
+ <struct name="transform_impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <typedef name="expr">
+ <type>typename boost::remove_reference<Expr const>::type</type>
+ </typedef>
+ <typedef name="expr_param">
+ <type>typename boost::add_reference<Expr const>::type</type>
+ </typedef>
+ <typedef name="state">
+ <type>typename boost::remove_reference<State const>::type</type>
+ </typedef>
+ <typedef name="state_param">
+ <type>typename boost::add_reference<State const>::type</type>
+ </typedef>
+ <typedef name="data">
+ <type>typename boost::remove_reference<Data const>::type</type>
+ </typedef>
+ <typedef name="data_param">
+ <type>typename boost::add_reference<Data const>::type</type>
+ </typedef>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/lazy.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/lazy.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/lazy.hpp">
+ <para>Contains definition of the lazy<> transform. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="lazy">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+ <inherit><classname>proto::transform</classname>< lazy<T> ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that uses
+ <computeroutput><classname>proto::make<></classname></computeroutput> to build a
+ <conceptname>CallableTransform</conceptname>, and then uses
+ <computeroutput><classname>proto::call<></classname></computeroutput> to apply it.
+ </purpose>
+ <description>
+ <para>
+ <computeroutput>proto::lazy<></computeroutput> is useful as a higher-order transform,
+ when the transform to be applied depends on the current state of the transformation. The
+ invocation of the <computeroutput>
+ <classname>proto::make<></classname>
+ </computeroutput> transform evaluates any nested transforms, and the resulting type is treated
+ as a <conceptname>CallableTransform</conceptname>, which is evaluated with
+ <computeroutput><classname>proto::call<></classname></computeroutput>.
+ </para>
+ <para>
+ For the full description of the behavior of the
+ <computeroutput>
+ <classname>proto::lazy<></classname>
+ </computeroutput>
+ transform, see the documentation for the nested
+ <computeroutput>
+ <classname>proto::lazy::impl<></classname>
+ </computeroutput>
+ class template.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl</classname><Expr, State, Data></type></inherit>
+ <typedef name="result_type">
+ <type><replaceable>see-below</replaceable></type>
+ <description>
+ <para>
+ <computeroutput>proto::lazy<T>::impl<Expr,State,Data>::result_type</computeroutput>
+ is calculated as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> if of the form
+ <computeroutput>O(T0,...TN)</computeroutput>, then let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of<<classname>proto::make</classname><O>(Expr, State, Data)>::type</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of<<classname>proto::make</classname><T>(Expr, State, Data)>::type</computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
+ The result type is <computeroutput>boost::result_of<<classname>proto::call</classname><O'(T0,...TN)>(Expr, State, Data)>::type</computeroutput>.
+ </para>
+ </description>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <para>
+ <computeroutput>proto::lazy<T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> if of the form
+ <computeroutput>O(T0,...TN)</computeroutput>, then let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of<<classname>proto::make</classname><O>(Expr, State, Data)>::type</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, let <computeroutput>O'</computeroutput>
+ be <computeroutput>boost::result_of<<classname>proto::make</classname><T>(Expr, State, Data)>::type</computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ <returns>
+ <computeroutput>
+ <classname>proto::call</classname><O'(T0,...TN)>()(expr, state, data)
+ </computeroutput>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/make.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/make.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,239 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/make.hpp">
+ <para>Contains definition of the make<> transform. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="protect">
+ <template>
+ <template-type-parameter name="PrimitiveTransform"/>
+ </template>
+ <inherit><classname>proto::transform</classname>< protect<PrimitiveTransform> ></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> which prevents another
+ <conceptname>PrimitiveTransform</conceptname> from being applied in an
+ <conceptname>ObjectTransform</conceptname>.</purpose>
+ <description>
+ <para>
+ When building higher order transforms with
+ <computeroutput>
+ <classname alt="proto::make">proto::make<></classname>
+ </computeroutput> or
+ <computeroutput>
+ <classname alt="proto::lazy">proto::lazy<></classname>
+ </computeroutput>,
+ you sometimes would like to build types that are parameterized with Proto transforms. In such
+ lambda-style transforms, Proto will unhelpfully find all nested transforms and apply them, even
+ if you don't want them to be applied. Consider the following transform, which will replace the
+ <computeroutput>proto::_</computeroutput> in
+ <computeroutput>Bar<proto::_>()</computeroutput>
+ with <computeroutput>proto::terminal<int>::type</computeroutput>:
+ </para>
+ <para>
+ <programlisting>template<typename T>
+struct Bar
+{};
+
+struct Foo :
+ proto::when<_, Bar<_>() >
+{};
+
+proto::terminal<int>::type i = {0};
+
+int main() {
+ Foo()(i);
+ std::cout << typeid(Foo()(i)).name() << std::endl;
+}</programlisting>
+ </para>
+ <para>
+ If you actually wanted to default-construct an object of type
+ <computeroutput>Bar<_></computeroutput>, you would have to protect the
+ <computeroutput>_</computeroutput> to prevent it from being applied. You can
+ use <computeroutput>proto::protect<></computeroutput> as follows:
+ </para>
+ <para>
+ <programlisting>// OK: replace anything with Bar<_>()
+struct Foo :
+ proto::when<_, Bar<protect<_> >() >
+{};</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name=""/>
+ <template-type-parameter name=""/>
+ <template-type-parameter name=""/>
+ </template>
+ <typedef name="result_type">
+ <type>PrimitiveTransform</type>
+ </typedef>
+ </struct>
+ </struct>
+
+ <struct name="make">
+ <template>
+ <template-type-parameter name="T"/>
+ </template>
+
+ <inherit><classname>proto::transform</classname>< make<T> ></inherit>
+
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> which computes a type by evaluating
+ any nested transforms and then constructs an object of that type. </purpose>
+
+ <description>
+ <para>
+ The purpose of <computeroutput>proto::make<></computeroutput> is to annotate a transform as
+ an <conceptname>ObjectTransform</conceptname> so that
+ <computeroutput>
+ <classname alt="proto::when">proto::when<></classname>
+ </computeroutput> knows
+ how to apply it.
+ </para>
+
+ <para>
+ For the full description of the behavior of the
+ <computeroutput><classname alt="proto::make">proto::make<></classname></computeroutput>
+ transform, see the documentation for the nested
+ <computeroutput><classname alt="proto::make::impl">proto::make::impl<></classname></computeroutput>
+ class template.
+ </para>
+ </description>
+
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="result_type">
+ <type><emphasis>see-below</emphasis></type>
+ <description>
+ <para>
+ <computeroutput>proto::make<T>::impl<Expr, State, Data>::result_type</computeroutput> is
+ computed as follows:
+ </para>
+
+ <para>
+ If <computeroutput>T</computeroutput> is an <conceptname>ObjectTransform</conceptname> of the form
+ <computeroutput>Object(T0,...TN)</computeroutput>, then let <computeroutput>O</computeroutput> be
+ the return type <computeroutput>Object</computeroutput>. Otherwise, let <computeroutput>O</computeroutput>
+ be <computeroutput>T</computeroutput>. The <computeroutput>result_type</computeroutput> typedef is
+ then computed as follows:
+ <itemizedlist>
+ <listitem>
+ If <computeroutput>O</computeroutput> is a template like
+ <computeroutput>S<X0,...XN></computeroutput>, then the result type is calculated as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ For each <computeroutput>X</computeroutput> in
+ <computeroutput>X0,...XN</computeroutput>, let <computeroutput>X'</computeroutput> be
+ <computeroutput>
+ <classname>proto::make</classname><X>::impl<Expr, State, Data>::result_type
+ </computeroutput>
+ (which evaluates this procedure recursively). Note whether any substitutions took place during
+ this operation.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ If any substitutions took place in the above step and
+ <computeroutput>S<X0',...XN'></computeroutput> has a nested
+ <computeroutput>type</computeroutput> typedef, the result type is
+ <computeroutput>S<X0',...XN'>::type</computeroutput>.
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, the result type is
+ <computeroutput>S<X0',...XN'></computeroutput>.
+ </para>
+ </listitem>
+ </itemizedlist>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, if <computeroutput>O</computeroutput> is a <conceptname>Transform</conceptname>, then let
+ the result type be
+ <computeroutput>
+ <classname>when</classname><<classname>_</classname>, O>::impl<Expr, State, Data>::result_type
+ </computeroutput>.
+ Note that a substitution took place.
+ </para>
+ </listitem>
+ <listitem>
+ Otherwise, the result type is <computeroutput>O</computeroutput>, and note that no
+ substitution took place.
+ </listitem>
+ </itemizedlist>
+ Note that <computeroutput><classname alt="proto::when">proto::when<></classname></computeroutput> is implemented
+ in terms of <computeroutput><classname alt="proto::call">proto::call<></classname></computeroutput>
+ and <computeroutput><classname alt="proto::make">proto::make<></classname></computeroutput>, so the
+ above procedure is evaluated recursively.
+ </para>
+ </description>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <description>
+ <para>
+ <computeroutput>proto::make<T>::impl<Expr,State,Data>::operator()</computeroutput> behaves as follows:
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>T</computeroutput> if of the form
+ <computeroutput>O(T0,...TN)</computeroutput>, then:
+ </para>
+ <itemizedlist>
+ <listitem>
+ <para>
+ If <computeroutput>
+ <classname>proto::is_aggregate</classname><result_type>::value
+ </computeroutput> is <computeroutput>true</computeroutput>, then construct
+ and return an object <computeroutput>that</computeroutput> as follows:
+ <programlisting>result_type that = {
+ proto::when<_, T0>()(expr, state, data),
+ ...
+ proto::when<_, TN>()(expr, state, data)
+};</programlisting>
+ </para>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, construct
+ and return an object <computeroutput>that</computeroutput> as follows:
+ <programlisting>result_type that(
+ proto::when<_, T0>()(expr, state, data),
+ ...
+ proto::when<_, TN>()(expr, state, data)
+);</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </listitem>
+ <listitem>
+ <para>
+ Otherwise, construct
+ and return an object <computeroutput>that</computeroutput> as follows:
+ <programlisting>result_type that = result_type();</programlisting>
+ </para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ </description>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/pass_through.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/pass_through.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,135 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/pass_through.hpp">
+ <para>Definition of the <classname alt="boost::proto::pass_through">proto::pass_through<></classname> transform,
+ which is the default transform of all of the expression generator metafunctions such as
+ <classname alt="boost::proto::unary_plus">proto::unary_plus<></classname>,
+ <classname alt="boost::proto::plus">proto::plus<></classname> and
+ <classname alt="boost::proto::nary_expr">proto::nary_expr<></classname>.</para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="pass_through">
+ <template>
+ <template-type-parameter name="Grammar"/>
+ </template>
+ <inherit><type><classname>proto::transform</classname>< pass_through<Grammar> ></type></inherit>
+ <purpose>A <conceptname>PrimitiveTransform</conceptname> that transforms the child expressions of an expression
+ node according to the corresponding children of a Grammar.</purpose>
+ <description>
+ <para>
+ Given a Grammar such as <computeroutput><classname>proto::plus</classname><T0, T1></computeroutput>,
+ an expression type that matches the grammar such as
+ <computeroutput><classname>proto::plus</classname><E0, E1>::type</computeroutput>, a state
+ <computeroutput>S</computeroutput> and a data <computeroutput>V</computeroutput>, the result of applying
+ the <computeroutput>proto::pass_through<plus<T0, T1> ></computeroutput> transform is:
+ <programlisting>plus<
+ boost::result_of<T0(E0, S, V)>::type,
+ boost::result_of<T1(E1, S, V)>::type
+>::type</programlisting>
+ </para>
+ <para>
+ The above demonstrates how child transforms and child expressions are applied pairwise, and how the
+ results are reassembled into a new expression node with the same tag type as the original.
+ </para>
+ <para>
+ The explicit use of <computeroutput>proto::pass_through<></computeroutput> is not usually
+ needed, since the expression generator metafunctions such as
+ <computeroutput><classname>proto::plus</classname><></computeroutput> have
+ <computeroutput>proto::pass_through<></computeroutput> as their default transform. So,
+ for instance, these are equivalent:
+ <itemizedlist>
+ <listitem>
+ <computeroutput>
+ <classname>proto::when</classname>< <classname>proto::plus</classname><X, Y>, proto::pass_through< <classname>proto::plus</classname><X, Y> > >
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname>proto::when</classname>< <classname>proto::plus</classname><X, Y>, <classname>proto::plus</classname><X, Y> >
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname>proto::when</classname>< <classname>proto::plus</classname><X, Y> > // because of proto::when<class X, class Y=X>
+ </computeroutput>
+ </listitem>
+ <listitem>
+ <computeroutput>
+ <classname>proto::plus</classname><X, Y> // because plus<> is both a grammar and a transform
+ </computeroutput>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>
+ For example, consider the following transform that promotes all
+ <computeroutput>float</computeroutput> terminals in an expression to
+ <computeroutput>double</computeroutput>.
+ <programlisting>// This transform finds all float terminals in an expression and promotes
+// them to doubles.
+struct Promote :
+ <classname>proto::or_</classname><
+ <classname>proto::when</classname><<classname>proto::terminal</classname><float>, <classname>proto::terminal</classname><double>::type(<classname>proto::_value</classname>) >,
+ // terminal<>'s default transform is a no-op:
+ <classname>proto::terminal</classname><<classname>proto::_</classname>>,
+ // nary_expr<> has a pass_through<> transform:
+ <classname>proto::nary_expr</classname><<classname>proto::_</classname>, <classname>proto::vararg</classname><Promote> >
+ >
+{};</programlisting>
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><type><classname>proto::transform_impl</classname><Expr, State, Data></type></inherit>
+ <typedef name="GN">
+ <purpose>For each N in [0,Expr arity), for exposition only</purpose>
+ <type>typename proto::result_of::child_c<Grammar, N>::type</type>
+ </typedef>
+ <typedef name="EN">
+ <purpose>For each N in [0,Expr arity), for exposition only</purpose>
+ <type>typename proto::result_of::child_c<Expr, N>::type</type>
+ </typedef>
+ <typedef name="RN">
+ <purpose>For each N in [0,Expr arity), for exposition only</purpose>
+ <type>typename boost::result_of<GN(EN,State,Data)>::type</type>
+ </typedef>
+ <typedef name="T">
+ <purpose>For exposition only</purpose>
+ <type>typename Expr::proto_tag</type>
+ </typedef>
+ <typedef name="result_type">
+ <type><classname>proto::expr</classname><T, <classname>proto::listN</classname><R0,...RN> ></type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ </parameter>
+ <requires>
+ <para>
+ <computeroutput>
+ <classname>proto::matches</classname><Expr, Grammar>::value
+ </computeroutput> is <computeroutput>true</computeroutput>.
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput>result_type::make(G0()(proto::child_c<0>(expr),state,data),...GN()(proto::child_c<N>(expr),state,data))</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Added: trunk/libs/proto/doc/reference/transform/when.xml
==============================================================================
--- (empty file)
+++ trunk/libs/proto/doc/reference/transform/when.xml 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
@@ -0,0 +1,206 @@
+<?xml version="1.0" encoding="utf-8"?>
+<header name="boost/proto/transform/when.hpp">
+ <para>Definition of when transform. </para>
+ <namespace name="boost">
+ <namespace name="proto">
+ <struct name="when">
+ <template>
+ <template-type-parameter name="Grammar"/>
+ <template-type-parameter name="PrimitiveTransform">
+ <default>Grammar</default>
+ </template-type-parameter>
+ </template>
+ <purpose>A grammar element and a <conceptname>PrimitiveTransform</conceptname> that associates
+ a transform with the grammar.</purpose>
+ <description>
+ <para>
+ Use <computeroutput>proto::when<></computeroutput> to override a grammar's default
+ transform with a custom transform. It is for used when composing larger transforms by
+ associating smaller transforms with individual rules in your grammar, as in the following
+ transform which counts the number of terminals in an expression.
+ <programlisting>// Count the terminals in an expression tree.
+// Must be invoked with initial state == mpl::int_<0>().
+struct CountLeaves :
+ proto::or_<
+ proto::when<proto::terminal<proto::_>, mpl::next<proto::_state>()>,
+ proto::otherwise<proto::fold<proto::_, proto::_state, CountLeaves> >
+ >
+{};</programlisting>
+ </para>
+ <para>
+ In <computeroutput>proto::when<G, T></computeroutput>, when <computeroutput>T</computeroutput>
+ is a class type it is a <conceptname>PrimitiveTransform</conceptname> and the following equivalencies hold:
+ </para>
+ <para>
+ <computeroutput>proto::when<G,T>::impl<E,S,V>::type</computeroutput> is the same as
+ <computeroutput>T::impl<E,S,V>::type</computeroutput>.
+ </para>
+ <para>
+ <computeroutput>proto::when<G,T>()(e,s,v)</computeroutput> is the same as
+ <computeroutput>T()(e,s,v)</computeroutput>.
+ </para>
+ </description>
+ <inherit><type>PrimitiveTransform</type></inherit>
+ <typedef name="proto_base_expr">
+ <type>typename Grammar::proto_base_expr</type>
+ </typedef>
+ </struct>
+ <struct-specialization name="when">
+ <template>
+ <template-type-parameter name="Grammar"/>
+ <template-type-parameter name="Fun"/>
+ </template>
+ <specialization>
+ <template-arg>Grammar</template-arg>
+ <template-arg>Fun *</template-arg>
+ </specialization>
+ <inherit>proto::when< Grammar, Fun ></inherit>
+ <purpose>A specialization that treats function pointer <conceptname>Transform</conceptname>s as if they
+ were function type <conceptname>Transform</conceptname>s.</purpose>
+ <description>
+ <para>
+ This specialization requires that <computeroutput>Fun</computeroutput> is actually a function type.
+ </para>
+ <para>
+ This specialization is required for nested transforms such as
+ <computeroutput>proto::when<G, T0(T1(_))></computeroutput>. In C++, functions that are used
+ as parameters to other functions automatically decay to funtion pointer types. In other words, the
+ type <computeroutput>T0(T1(_))</computeroutput> is indistinguishable from
+ <computeroutput>T0(T1(*)(_))</computeroutput>. This specialization is required to handle these
+ nested function pointer type transforms properly.
+ </para>
+ </description>
+ </struct-specialization>
+
+ <struct-specialization name="when">
+ <template>
+ <template-type-parameter name="Grammar"/>
+ <template-type-parameter name="R"/>
+ <template-type-parameter name="A" pack="1"/>
+ </template>
+ <specialization>
+ <template-arg>Grammar</template-arg>
+ <template-arg>R(A...)</template-arg>
+ </specialization>
+ <inherit><classname>proto::transform</classname>< when<Grammar, R(A...)> ></inherit>
+ <purpose>A grammar element and a <conceptname>PrimitiveTransform</conceptname> that associates a
+ transform with the grammar. </purpose>
+ <description>
+ <para>
+ Use <computeroutput>proto::when<></computeroutput> to override a grammar's default
+ transform with a custom transform. It is for used when composing larger transforms by associating
+ smaller transforms with individual rules in your grammar.
+ </para>
+ <para>
+ The <computeroutput>when<G, R(A...)></computeroutput> form accepts either a
+ <conceptname>CallableTransform</conceptname> or an <conceptname>ObjectTransform</conceptname> as its
+ second parameter. <computeroutput>proto::when<></computeroutput> uses
+ <computeroutput><classname>proto::is_callable</classname><R>::value</computeroutput> to
+ distinguish between the two, and uses
+ <computeroutput><classname>proto::call<></classname></computeroutput> to evaluate
+ <conceptname>CallableTransform</conceptname>s and
+ <computeroutput><classname>proto::make<></classname></computeroutput> to evaluate
+ <conceptname>ObjectTransform</conceptname>s.
+ </para>
+ </description>
+ <struct name="impl">
+ <template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template>
+ <inherit><classname>proto::transform_impl</classname>< Expr, State, Data ></inherit>
+ <typedef name="call_">
+ <purpose>For exposition only</purpose>
+ <type><classname>proto::call</classname><R(A...)></type>
+ </typedef>
+ <typedef name="make_">
+ <purpose>For exposition only</purpose>
+ <type><classname>proto::make</classname><R(A...)></type>
+ </typedef>
+ <typedef name="which">
+ <purpose>For exposition only</purpose>
+ <type>typename mpl::if_<<classname>proto::is_callable</classname><R>,call_,make_>::type</type>
+ </typedef>
+ <typedef name="result_type">
+ <type>typename which::template impl< Expr, State, Data >::result_type</type>
+ </typedef>
+ <method-group name="public member functions">
+ <method name="operator()" cv="const">
+ <type>result_type</type>
+ <parameter name="expr">
+ <paramtype>typename impl::expr_param</paramtype>
+ <description>
+ <para>The current expression </para>
+ </description>
+ </parameter>
+ <parameter name="state">
+ <paramtype>typename impl::state_param</paramtype>
+ <description>
+ <para>The current state </para>
+ </description>
+ </parameter>
+ <parameter name="data">
+ <paramtype>typename impl::data_param</paramtype>
+ <description>
+ <para>An arbitrary data </para>
+ </description>
+ </parameter>
+ <description>
+ <para>
+ Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with
+ <computeroutput><classname>proto::call<></classname></computeroutput> or with
+ <computeroutput><classname>proto::make<></classname></computeroutput> depending
+ on whether <computeroutput><classname>proto::is_callable</classname><R>::value</computeroutput>
+ is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.
+ </para>
+ </description>
+ <requires>
+ <para>
+ <computeroutput><classname>proto::matches</classname><Expr, Grammar>::value</computeroutput>
+ is <computeroutput>true</computeroutput>.
+ </para>
+ </requires>
+ <returns>
+ <para>
+ <computeroutput>which()(expr, state, data)</computeroutput>
+ </para>
+ </returns>
+ </method>
+ </method-group>
+ </struct>
+ <typedef name="proto_base_expr">
+ <type>typenme Grammar::proto_base_expr</type>
+ </typedef>
+ </struct-specialization>
+
+ <struct name="otherwise">
+ <template>
+ <template-type-parameter name="Fun"/>
+ </template>
+ <inherit><classname>proto::when</classname>< <classname>proto::_</classname>, Fun ></inherit>
+ <purpose>
+ Syntactic sugar for <computeroutput><classname>proto::when</classname>< <classname>proto::_</classname>, Fun ></computeroutput>,
+ for use in grammars to handle all the cases not yet handled.
+ </purpose>
+ <description>
+ <para>
+ Use <computeroutput>proto::otherwise<T></computeroutput> in your grammars as a synonym for
+ <computeroutput><classname>proto::when</classname>< <classname>proto::_</classname>, Fun ></computeroutput>
+ as in the following transform which counts the number of terminals in an expression.
+ </para>
+ <para>
+ <programlisting>// Count the terminals in an expression tree.
+// Must be invoked with initial state == mpl::int_<0>().
+struct CountLeaves :
+ proto::or_<
+ proto::when<proto::terminal<proto::_>, mpl::next<proto::_state>()>,
+ proto::otherwise<proto::fold<proto::_, proto::_state, CountLeaves> >
+ >
+{};</programlisting>
+ </para>
+ </description>
+ </struct>
+ </namespace>
+ </namespace>
+</header>
Deleted: trunk/libs/proto/doc/transforms_old.qbk
==============================================================================
--- trunk/libs/proto/doc/transforms_old.qbk 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
+++ (empty file)
@@ -1,1503 +0,0 @@
-[/
- / Copyright (c) 2006 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)
- /]
-
-[import ../test/examples.cpp]
-
-[/============================================================================]
-[section:expression_transformation Expression Transformation: Semantic Actions]
-[/============================================================================]
-
-Sometimes, rather than immediately executing an expression template, you'd like to
-transform it into some other object. Maybe the transformation is simple, like
-converting all references into values. Maybe it's complicated, like transforming an
-expression template into a finite-state automata for matching a regular expression.
-Proto provides a framework for applying tree transformations and several canned
-transformations that are generally useful.
-
-[/===============]
-[heading Overview]
-[/===============]
-
-Defining tree transformations involves defining the grammar for your DSEL
-and decorating it with transformations. Each rule in your grammar will
-have an associated transform describing how sub-expressions matching that rule
-are to be transformed. Just as the grammar is defined recursively, so too
-is the tree transformation.
-
-You associate transforms with your grammar rules using _when_. For instance,
-you might want to promote all `int` terminals to `long`. You would say the
-following:
-
- proto::when< proto::terminal<int>, proto::terminal<long>::type(proto::_value) >
-
-`proto::terminal<long>::type(proto::_value)` is an example of a Proto transform. It
-says to create an object of type `proto::terminal<long>::type` and initialize it
-with the result of the `proto::_value` transform. `proto::_value` is a transform
-defined by Proto which extracts the value from a terminal expression.
-
-[note The transform above might look a little strange at first. It appears
-to be constructing a temporary object in place. In fact, it is a
-/function type/. Since `proto::terminal<long>::type` and `proto::_value`
-are types, `proto::terminal<long>::type(proto::_value)` is actually the type
-of a function that takes `proto::_value` as a parameter and returns
-`proto::terminal<long>::type`. But no such function actually exists! Rather,
-Proto interprets this function type as a transform, the effect of which is
-described above. The resemblance to an in-place construction of a temporary
-object is intentional. It is a concise and natural notation for specifying
-transforms. Proto transforms use function types extensively, as we'll see.]
-
-A grammar decorated with transforms is a function object that takes three
-parameters:
-
-* `expr` -- the Proto expression to transform
-* `state` -- an optional initial state for the transformation
-* `data` -- any optional mutable state information
-
-Many transforms do no use the state and data parameters, and you can pass
-dummy values for them or leave them off entirely. Later on we'll describe
-the difference between them and see where they are useful.
-
-In addition to being a function object, a grammar decorated with transforms
-is also a grammar. That is, it can be used as the second parameter to
-the _matches_ metafunction to see if an expression type matches the grammar.
-
-The first pararameter to the transform, `expr`, is a Proto expression. Its
-type /must/ match the grammar defined by the transform. It is an error to
-apply a transform to an expression that does not match the transform's
-grammar. If you try it, you're likely to get an ugly compiler error if you're
-lucky. If you're unlucky, it'll compile and do something weird at runtime.
-For instance, consider the following:
-
- // A grammar that matches an int terminal, and a
- // transform that promotes it to a long terminal.
- typedef
- proto::when<
- proto::terminal<int>
- , proto::terminal<long>::type(proto::_value)
- >
- Promote;
-
- // A character terminal
- proto::terminal<char>::type a = {'a'};
-
- // ERROR! The Promote transform expects an integer
- // terminal, not a character terminal.
- Promote promote;
- proto::terminal<long>::type i = promote(a);
-
-Grammars with transforms are proper function objects, so you can use
-`boost::result_of<>` to calculate their return types. So, applying a
-transform typically looks like this:
-
- // Assuming we have an expression to transform,
- // an initial state, and some auxiliary data ...
- Expr expr;
- State state;
- Data data;
-
- // ... calculate the result type of applying
- // Grammar's transform ...
- typedef typename
- boost::result_of<Grammar(Expr, State, Data)>::type
- result_type;
-
- // ... and apply Grammar's transform:
- result_type result = Grammar()(expr, state, data);
-
-[/====================================]
-[heading The State and Data Parameters]
-[/====================================]
-
-So in a transform, what are the `state` and `data` parameters used for?
-If you are familiar with the `std::accumulate()` standard algorithm,
-you know that it takes an input sequence, an initial state, and a
-binary function. The algorithm passes the initial state and the first
-element to the binary function to calculate a new state, which is
-then similarly combined with the second element, and so on. Users of
-functional programming languages know this operation as `fold`.
-
-Proto provides several variants of a `fold` transform that behaves
-analogously to `std::accumulate()`. The `fold` transform is described
-in detail later, but here we're just interested in the `state`
-parameter. Any transform that uses `fold` is going to require you
-to pass an initial state. That is what the second parameter of a
-transform is used for.
-
-The `data` parameter is a little different. It can be anything you
-want, and -- unlike the `state` parameter -- none of Proto's built-in
-transforms will touch it. Also unlike the `state` parameter, the
-`data` parameter will be passed around by non-const reference. You
-can use the `data` parameter to pass along data that your
-custom transforms might use or mutate.
-
-So the difference between `state` and `data` is that `state` is an
-accumulation variable that Proto will change, both in type and in
-value, during the transformation, whereas `data` is just a blob of
-bits that you would like available to your transforms. For instance,
-you might want to fold an expression tree to a Fusion list and do
-something locale-specific to each element before you put it in the
-list. In that case, your state parameter would be `fusion::nil`
-(i.e., an empty list), and the data parameter would be a
-`std::locale`.
-
-[/==========================================]
-[section Example: Calculator Arity Transform]
-[/==========================================]
-
-Let's have another look at our trusty calculator example. If you recall, the
-calculator allows the lazy evaluation of arithmetic expressions, with
-placeholders substituted with actual values provided at evaluation time. Valid
-expressions are of the form:
-
- (_1 + 3)
- (_2 - _1) / _2 * 100
-
-... and so on. In the first expression, one argument must be provided before
-the expression can be evaluated. In the second, two arguments are needed. We
-could say the /arity/ of the first expression is one and of the second is two.
-The arity is determined by the highest placeholder in the expression. Our job
-will be to write a transform that calculates the arity of any calculator
-expression.
-
-[note *Why Bother Calculating Expression Arity?*
-
-This is more than just an intelectual exercise. Knowing the arity of a calculator
-expression is important if you want to give users a meaningful error message when
-they specify too few or too many arguments to an expression.]
-
-[/=========================]
-[heading Defining a Grammar]
-[/=========================]
-
-First, we must write the grammar for the calculator. It's really very simple.
-Calculator expression can be made up of any combination of 5 constituents:
-
-* Placeholder 1
-* Placeholder 2
-* A literal
-* Unary operations
-* Binary operations
-
-We can immediately write the calculator grammar as follows:
-
-[CalcGrammar]
-
-We can read this as follows: a calculator expression is either placeholder 1,
-placeholder 2, some other terminal, or some unary or binary operator whose operands
-are calculator expressions. Recall that `proto::_` is a wildcard that matches
-anything. So `proto::terminal< _ >` will match any terminal, and
-`proto::unary_expr< _, CalcArity >` will match any unary expression for which the
-operand matches `CalcArity` (the `_` matches any operator tag).
-
-[/============================]
-[heading Writing the Transform]
-[/============================]
-
-It's straightforward to describe in words how the arity of an expression should
-be calculated. First, we describe the arity of each of the 5 constituents in
-the calculator grammar.
-
-[table Calculator Sub-Expression Arities
- [[Sub-Expression] [Arity]]
- [[Placeholder 1] [`1`]]
- [[Placeholder 2] [`2`]]
- [[Literal] [`0`]]
- [[Unary Expression] [ /arity of the operand/ ]]
- [[Binary Expression] [ /max arity of the two operands/ ]]
-]
-
-The total arity of a calculator expression is found by recursively evaluating
-the arity of all of the sub-expressions and taking the maximum.
-
-Let's look at the sub-expression for the placeholder `_1`. It is matched by this
-part of our grammar: `proto::terminal< placeholder<0> >`. We want to associate this
-part of our grammar with an arity of `1`. We do that by attaching a transform.
-Since the arity of an expression can be evaluated at compile time, let's use
-`mpl::int_<1>` to represent the arity of the first placeholder. The following
-attaches a transform that always evaluates to `mpl::int_<1>`:
-
- proto::when< proto::terminal< placeholder<0> >, mpl::int_<1>() >
-
-This grammar rule will match any `placeholder<0>` terminal, and will transform it
-to a (default-constructed) `mpl::int_<1>` object. As described previously,
-`mpl::int_<1>()` is a function type, but Proto interprets it as an object to
-construct. We will have a similar transform to convert `placeholder<1>` terminals
-into `mpl::int_<2>`, and other terminals into `mpl::int_<0>`.
-
-Next, let's write a transform for unary operators that returns the arity of the
-operand. It is simply:
-
- proto::when< proto::unary_expr< _, CalcArity >, CalcArity(proto::_child) >
-
-The transform `CalcArity(proto::_child)` recursively applies the `CalcArity`
-transform to the child node of the unary expression. As you might have noticed,
-`CalcArity(proto::_child)` is another function type, but Proto interprets this one
-differently. Rather than trying to construct a `CalcArity` object, Proto
-knows this is a function object and invokes it instead.
-
-[/================================================]
-[note *Object Transforms vs. Callable Transforms*
-
-When using function types as Proto transforms, they can either represent an object
-to construct or a function to call. It is similar to C++ where the syntax `foo(x)`
-can either be interpreted as an object to construct or a function to call,
-depending on whether `foo` is a type or a function. Proto can't know in general
-which is the case, so it uses a trait, `proto::is_callable<>`, to differentiate.
-`is_callable< mpl::int_<1> >::value` is false so `mpl::int_<1>()` is an object to
-construct, but `is_callable< CalcArity >::value` is true so
-`CalcArity(proto::_child)` is a function to call.
-(`is_callable< CalcArity >::value` is true because `CalcArity` inherits from
-`proto::or_<>`, which is callable.)]
-[/================================================]
-
-[/
- That begs the question, what does `unary_expr<>`'s transform do? Well,
- `unary_expr< _, CalcArity >` has a default transform
- associated with it. It is a /pass-through/ transform. When an expression
- of the form `expr< T, list1< X > >` is passed to the transform, its `apply<>`
- member template will invoke the `CalcArity` transform (which we haven't
- completely defined yet -- patience) on `X` resulting in `Y`, and then
- reassemble the expression as `expr< T, list1< Y > >`.
-
- [note You may have noticed that Proto types like `unary_expr<>` serve several
- different but related roles. In particular, `unary_expr<>` is ...
-
- ... [*a metafunction]: `unary_expr<T, X>::type` is a typedef for
- `expr<T, list1<X> >`.
-
- ... [*a grammar]: `unary_expr<U, Y>` is a simle grammar that matches
- `expr<T, list1<X> >` if an only if `U` is `T` or `proto::_`, and `Y` is a
- grammar that matches `X`.
-
- ... [*a transform]: `unary_expr<U, Y>::apply<expr<T, list1<X> >, S, V>::type`
- applies `unary_expr<>`'s pass-through transform to `expr<T, list1<X> >` with
- state `S` and data `V`. The result is
- `expr<T, list1< Y::apply<X, S, V>::type > >`.
- ]
-
- So, putting a few things together, consider the calculator expression `+_1`,
- which would have the following type:
-
- expr< tag::unary_plus, list1<
- expr< tag::terminal, term< placeholder<0> > >
- > >
-
- If we executed the `unary_expr< _, CalcArity >` transform on this
- expression, we would expect to get:
-
- expr< tag::unary_plus, list1<
- mpl::int_<1>
- > >
-
- And if we added the `_child<>` transform also, as in
- `child< unary_expr< _, CalcArity > >`, we expect the result
- to be:
-
- mpl::int_<1>
-
- Which is exactly what we want.
-
- [note *Default Transforms*
-
- All the tools Proto provides for defining grammar rules have default transforms
- associated with them. Just as `unary_expr<>` has a pass-through transform,
- so too does `binary_expr<>`, `shift_right<>`, and all the others.
- `proto::or_<>` has a default transform which evaluates the transform of the
- branch that matched. `proto::and_<>`'s default transform evaluates the
- transform of the last branch. Even `proto::expr<>`, `proto::if_<>`,
- `proto::not_<>`, and `proto::_` have no-op default transforms that simply return
- unmodified the expressions passed to them.
- ]
-]
-
-The arity of a binary operator is the maximum of the arity of the left and
-right operands. We can specify this with the help of `mpl::max<>`, which is a
-so-called metafunction that computes the maximum of two compile-time integers.
-The transform is described below:
-
- proto::when< proto::binary_expr< _, CalcArity, CalcArity >,
- mpl::max< CalcArity(proto::_left), CalcArity(proto::_right) >()
- >
-
-The above says to match binary calculator expressions and compute their
-arity by first computing the arity of the left and right children and then
-taking their maximum.
-
-[def _X_ [~X]]
-[def _Y_ [~Y]]
-[def _Z_ [~Z]]
-
-There's a lot going on in the above transform, so let's take it one piece
-at a time, starting with the parts we know. `CalcArity(proto::_left)`
-will calculate the arity of the left child, returning a compile-time integer.
-Likewise for `CalcArity(proto::_right)`. What is new is that these two
-transforms are nested within another: `mpl::max<...>()`. Proto notices that
-`mpl::max<...>` is not callable, so this transform is interpreted as an
-object to construct rather than a function to invoke. Using meta-programming
-tricks, Proto disassembles the `mpl::max<...>` template looking for nested
-Proto transforms to apply. It finds two and applies them, resulting in
-`mpl::max< mpl::int_<_X_>, mpl::int_<_Y_> >`.
-
-Having first applied any nested transforms, Proto then looks to see if
-`mpl::max< mpl::int_<_X_>, mpl::int_<_Y_> >` has a nested `::type` typedef.
-This is a common convention used by metafunctions. In this case,
-`mpl::max<...>::type` is a typedef for `mpl::int_< _Z_ >` where `_Z_` is the
-maximum of `_X_` and `_Y_`. The trailing `()` on the transform indicates that
-the result should be default-constructed, so this transform returns
-`mpl::int_<_Z_>()`. And we're done.
-
-[note Had `mpl::max<>` not had a nested `::type` typedef, the transform
-would have created and returned a default-constructed `mpl::max<>` object
-instead. That is, the result of substituting nested transforms need not
-of necessity have a nested `::type` typedef, but it is used if it is there.]
-
-Piecing it all together, the complete `CalcArity` looks like this:
-
-[CalcArity]
-
-We can use our `CalcArity` transform to calculate the arity of any
-calculator expression:
-
- CalcArity arity_of;
- std::cout << arity_of( proto::lit(100) * 20 ) << '\n';
- std::cout << arity_of( (_1 - _1) / _1 * 100 ) << '\n';
- std::cout << arity_of( (_2 - _1) / _2 * 100 ) << '\n';
-
-This displays the following:
-
-[pre
-0
-1
-2
-]
-
-(Aside: the output statements use the fact that `mpl::int_<_X_>`
-has a conversion to `int(_X_)`.)
-
-[endsect]
-
-[/========================]
-[section Canned Transforms]
-[/========================]
-
-So far, we've seen how to write custom transforms using function types.
-These were implemented in terms of more primitive transforms provided by
-Proto, such as `_child`, `_left`, and `_right`. This section describes those
-transforms and others in detail.
-
-[/
-
-Why is this here??
-
-All the transforms defined in this section are of the following form:
-
-[def _some_transform_ [~some_transform]]
-
- struct _some_transform_ : proto::transform< _some_transform_ >
- {
- template<typename Expr, typename State, typename Date>
- struct impl : proto::transform_impl< Expr, State, Data >
- {
- typedef ... result_type;
-
- result_type operator()(
- typename impl::expr_param expr
- , typename impl::state_param state
- , typename impl::data_param data
- ) const
- {
- return ...;
- }
- };
- };
-
-So defined, `_some_transform_` is a transform "in the raw", just like
-`proto::_value` or `proto::_child`. These transforms are the building
-blocks from which you can compose larger transforms using function types.
-
-]
-
-[section:child_c_and_friends [^_value], [^_child], [^_left], and [^_right]]
-
- namespace boost { namespace proto
- {
- struct _value;
-
- template<long N>
- struct _child_c;
-
- typedef _child_c<0> _child0;
- typedef _child_c<1> _child1;
- // ... up to BOOST_PROTO_MAX_ARITY-1
-
- typedef _child_c<0> _child;
- typedef _child_c<0> _left;
- typedef _child_c<1> _right;
- }}
-
-These transforms are useful for extracting the ['[^N]]th argument from an
-expression. The `_left` transform is equivalent to the `_child_c<0>` transform,
-and the `_right` transform is equivalent to the `_child_c<1>` transform. The
-`_value` transform extracts the value from a terminal expression.
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<proto::_value(Expr, State, Data)>::type`]
- [`proto::result_of::value<Expr>::type`]
- ]
- [ [`proto::_value()(expr, state, data)`]
- [`proto::value(expr)`]
- ]
- [ [`boost::result_of<proto::_child_c<N>(Expr, State, Data)>::type`]
- [`proto::result_of::child_c<Expr, N>::type`]
- ]
- [ [`proto::_child_c<N>()(expr, state, data)`]
- [`proto::child_c<N>(expr)`]
- ]
- [ [`boost::result_of<proto::_left(Expr, State, Data)>::type`]
- [`proto::result_of::left<Expr>::type`]
- ]
- [ [`proto::_left()(expr, state, data)`]
- [`proto::left(expr)`]
- ]
- [ [`boost::result_of<proto::_right(Expr, State, Data)>::type`]
- [`proto::result_of::right<Expr>::type`]
- ]
- [ [`proto::_right()(expr, state, data)`]
- [`proto::right(expr)`]
- ]
-]
-
-Example:
-
- // Matches an integer terminal and extracts the int.
- struct Int
- : when< terminal<int>, _value >
- {};
-
-[endsect]
-
-[section:identity_and_friends [^_expr], [^_state] and [^_data]]
-
- namespace boost { namespace proto
- {
- struct _expr;
- struct _state;
- struct _data;
- }}
-
-The `_expr`, `_state` and `_data` transforms merely return the
-`expr`, `state` and `data` arguments, respectively. Proto's
-wildcard pattern, `_`, behaves like `_expr` when used
-as a transform.
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<proto::_(Expr, State, Data)>::type`]
- [`Expr`]
- ]
- [ [`proto::_()(expr, state, data)`]
- [`expr`]
- ]
- [ [`boost::result_of<proto::_expr(Expr, State, Data)>::type`]
- [`Expr`]
- ]
- [ [`proto::_expr()(expr, state, data)`]
- [`expr`]
- ]
- [ [`boost::result_of<proto::_state(Expr, State, Data)>::type`]
- [`State`]
- ]
- [ [`proto::_state()(expr, state, data)`]
- [`state`]
- ]
- [ [`boost::result_of<proto::_data(Expr, State, Data)>::type`]
- [`Data`]
- ]
- [ [`proto::_data()(expr, state, data)`]
- [`data`]
- ]
-]
-
-Example:
-
- // Matches a subscript expression where the left- and right-hand operands
- // match MyGrammar, returns the expression unmodified
- struct Subscript
- : proto::when< proto::subscript<MyGrammar, MyGrammar>, proto::_expr >
- {};
-
-[endsect]
-
-[section:if [^if_<>]]
-
- namespace boost { namespace proto
- {
- namespace control
- {
- template<
- typename If
- , typename Then = _
- , typename Else = not_<_>
- >
- struct if_;
- }
-
- using control::if_;
- }}
-
-We've already seen the _if_ template in the context of grammars, but
-_if_ can also be used as a transform. It can be used to conditionally
-apply one transform or another based on some condition. The three
-template parameters are Proto transforms. The result of applying the
-first transform should be a compile-time Boolean. If it is true, then
-the first transform is applied. The second is applied otherwise.
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [``boost::result_of<
- proto::if_<If, Then, Else>(Expr, State, Data)
->::type``]
- [``typedef
- mpl::if_<
- boost::result_of<proto::when<_, If>(Expr, State, Data)>::type
- , proto::when<_, Then>
- , proto::when<_, Else>
- >::type
-branch;
-
-typedef boost::result_of<branch(Expr, State, Data)>::type type;``]
- ]
- [ [`proto::if_<If, Then, Else>()(expr, state, data)`]
- [``typedef ... branch; // Same as above
-branch()(expr, state, data);``]
- ]
-]
-
-Example:
-
- // Match a terminal. If size of the terminal
- // argument is less than or equal to 4, make
- // a new terminal that stores the argument by
- // value. Otherwise, store the argument by
- // reference.
- struct ByValOrRef
- : proto::when<
- proto::terminal<_>
- , proto::if_<
- mpl::less_equal<
- mpl::sizeof_<proto::_value>
- , mpl::size_t<4>
- >()
- , proto::_make_terminal(proto::_value)
- , proto::_make_terminal(proto::_ref(proto::_value))
- >
- >
- {};
-
-[endsect]
-
-[section:and_or_not [^and_<>], [^or_<>], and [^not_<>]]
-
- namespace boost { namespace proto
- {
- namespace control
- {
- template<typename... T>
- struct and_;
-
- template<typename... T>
- struct or_;
-
- template<typename T>
- struct not_;
- }
-
- using control::and_;
- using control::or_;
- using control::not_;
- }}
-
-As with _if_, the grammar elements _and_, _or_, and _not_ can
-also be used as transforms. At a high level, here is what the
-transforms do:
-
-[variablelist
-[ [`and_<T0,T1,...,Tn>`]
- [Apply the transform `Tn`.] ]
-[ [`or_<T0,T1,...,Tn>`]
- [Apply the transform `Tx` where `x` is the lowest number
- such that `matches<Expr,Tx>::value` is `true`.] ]
-[ [`not_<T>`] [Return the current expression unchanged.] ]
-]
-
-The following table specifies the behaviors described above more
-precisely.
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [``boost::result_of<
- proto::and_<A,B,C>(Expr, State, Data)
->::type``]
- [`boost::result_of<C(Expr, State, Data)>::type`]
- ]
- [ [`proto::and_<A,B,C>()(expr, state, data)`]
- [`C()(expr, state, data)`]
- ]
- [ [``boost::result_of<
- proto::or_<A,B,C>(Expr, State, Data)
->::type``]
- [``typedef mpl::if_<
- proto::matches<Expr, A>
- , A
- , mpl::if_<
- proto::matches<Expr, B>
- , B
- , C
- >::type
->::type which;
-
-typedef boost::result_of<which(Expr, State, Data)>::type type;``]
- ]
- [ [`proto::or_<A,B,C>()(expr, state, data)`]
- [``typedef ... which; // Same as above
-which()(expr, state, data);``]
- ]
- [ [``boost::result_of<
- proto::not_<A>(Expr, State, Data)
->::type``]
- [`Expr`]
- ]
- [ [`proto::not_<A>()(expr, state, data)`]
- [`expr`]
- ]
-]
-
-Example:
-
- // A transform that matches any expression and
- // unwraps any reference_wrapped terminals it
- // finds.
- struct UnwrapReference
- : proto::or_<
- // Pass through terminals that are not
- // reference_wrappers unchanged:
- proto::and_<
- proto::terminal<_>
- , proto::not_<proto::if_<boost::is_reference_wrapper<proto::_value>()> >
- >
- // For other terminals (i.e., reference_wrapper
- // terminals), unwrap the reference:
- , proto::when<
- proto::terminal<_>
- , proto::terminal<boost::unwrap_reference<proto::_value> >(proto::_value)
- >
- // Otherwise, match non-terminals and
- // recurse.
- , proto::when<
- proto::nary_expr<_, proto::vararg<UnwrapReference> >
- >
- >
- {};
-
-The above transform serves to illustrate the behaviors of the _and_,
-_or_, and _not_ transforms, but it is admittedly contrived. The
-transform is more easily written as follows:
-
- // Functionally identical to the UnwrapReference
- // transform above:
- struct UnwrapReference
- : proto::or_<
- proto::when<
- proto::terminal<boost::reference_wrapper<_> >
- , proto::terminal<boost::unwrap_reference<proto::_value> >(proto::_value)
- >
- , proto::terminal<_>
- , proto::nary_expr<_, proto::vararg<UnwrapReference> >
- >
- {};
-
-[endsect]
-
-[section:call [^call<>]]
-
-[def __CALLABLE__ [~[^Callable]]]
-
- namespace boost { namespace proto
- {
- template<typename Fun>
- struct call;
- }}
-
-The `call<>` transform is used to invoke callable transforms and evaluate
-their arguments. When you use a callable transform as in
-`when< unary_plus<_>, __CALLABLE__(_child) >`, the `call<>` transform is used behind
-the scenes to evaluate `__CALLABLE__(_child)`. In fact, for any callable
-transform, the following short- and long-forms are equivalent:
-
-[table
- [ [Short From]
- [Long Form] ]
- [ [ `proto::when< Grammar, __CALLABLE__(Tran1, Tran2...) >` ]
- [ `proto::when< Grammar, proto::call< __CALLABLE__(Tran1, Tran2...) > >` ] ]
-]
-
-You might decide to use `call<>` explicitly in cases when Proto can't figure out
-that a given transform is callable. (See the discussion on the `is_callable<>` trait
-[link boost_proto.users_guide.expression_transformation.is_callable here].)
-Rather than specialize `proto::is_callable<>` for your transform, you can simply
-wrap its use in `call<>`, instead.
-
-[tip For users of legacy compilers like MSVC 7.1, `call<>` is useful to work
-around compiler bugs. Doubly-nested transforms such as `__CALLABLE__(_child1(_child2))`
-cause older compilers problems, but the equivalent `__CALLABLE__(call<_child1(_child2)>)`
-solves the problem.]
-
-The semantics of `call<>` are described in the table below:
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<proto::call<Fun(A0, A1, ... AN)>(Expr, State, Data)>::type`]
- [``boost::result_of<Fun(
- boost::result_of<proto::when<_, A0>(Expr, State, Data)>::type
- , boost::result_of<proto::when<_, A1>(Expr, State, Data)>::type
- ...
- , boost::result_of<proto::when<_, AN>(Expr, State, Data)>::type
-)>::type``]
- ]
- [ [`proto::call<Fun(A0, A1, ... AN)>()(expr, state, data)`]
- [``Fun()(
- proto::when<_, A0>()(expr, state, data)
- , proto::when<_, A1>()(expr, state, data)
- ...
- , proto::when<_, AN>()(expr, state, data)
-)``]
- ]
-]
-
-The target of a callable transform can be any function object that implements
-the Boost.ResultOf protocol. Function objects that take up to
-`BOOST_PROTO_MAX_ARITY` are handled.
-
-For callable transforms that take 0, 1, or 2 arguments, special handling is done
-to see if the transform actually expects 3 arguments, as Proto's primitive
-transforms do. (This can be detected with meta-programming tricks.) So, even
-though a transform like `_child1` requires three parameters: expression,
-state and data; it can be "called" with just one, like `_child1(_child2)`. Proto
-treats this as if were `call<_child1(_child2, _state, _data)>`.
-
-If no transform arguments are specified at all, as in `call<_child1>`, this is
-the same as `_child1`. For this reason, `call<_child1>(_child2)` is the same as
-`call<_child1(_child2)>`.
-
-Example:
-
-[LazyMakePair2]
-
-[endsect]
-
-[section:make [^make<>]]
-
-[def __OBJECT__ [~[^Object]]]
-
- namespace boost { namespace proto
- {
- template<typename Fun>
- struct make;
- }}
-
-The `make<>` transform is used to construct objects and evaluate
-their constructor arguments. When you use an object transform as in
-`when< unary_plus<_>, __OBJECT__(_child) >`, the `make<>` transform is used behind
-the scenes to evaluate `__OBJECT__(_child)`. In fact, for any object
-transform, the following short- and long-forms are equivalent:
-
-[table
- [ [Short From]
- [Long Form] ]
- [ [ `proto::when< Grammar, __OBJECT__(Tran1, Tran2...) >` ]
- [ `proto::when< Grammar, proto::make< __OBJECT__(Tran1, Tran2...) > >` ] ]
-]
-
-You might decide to use `make<>` to explicitly differentiate object
-transforms from callable transforms. (See `call<>`.)
-
-[tip For users of legacy compilers like MSVC 7.1, `make<>` is useful to work
-around compiler bugs. Doubly-nested transforms such as `Object1(Object2(_child))`
-cause older compilers problems, but the equivalent `Object1(make<Object2(_child)>)`
-solves the problem.]
-
-The `make<>` transform checks to see if the resulting object type is a template.
-If it is, the template type is disassembled to find nested transforms. Proto
-considers the following types to represent transforms:
-
-[def __type__ [~type]]
-[def __X__ X\']
-[def __X0__ X0\']
-[def __X1__ X1\']
-[def __MakeImpl__ [~[^MakeImpl]]]
-
-* Function types
-* Function pointer types
-* Types for which `proto::is_callable<__type__>::value` is `true`
-
-When an object transform with a template type such as
-`Object<X0,X1,...>(Args...)` is evaluated with a given
-`Expr`, `State`, and `Data`, the result type is
-`__MakeImpl__<Object<X0,X1,...>, Expr, State, Data>::type` which is
-defined as follows. For each `X` in `X0,X1,...`, do:
-
-* If `X` is a transform, then let `__X__` be
- `boost::result_of<proto::when<_, X>(Expr, State, Data)>::type`.
- Note that a substitution took place.
-* Otherwise, if `X` is a template like `Object2<Y0,Y1,...>`, then
- let `__X__` be `__MakeImpl__<Object2<Y0,Y1,...>, Expr, State, Data>::type`
- (which evaluates this procedure recursively). Note whether any
- substitutions took place during this operation.
-* Otherwise, let `__X__` be `X`, and note that no substitution
- took place.
-* If any substitutions took place in any of the above steps and
- `Object<__X0__,__X1__,...>` has a nested `::type` typedef, the
- result type is `Object<__X0__,__X1__,...>::type`.
-* Otherwise, the result type is `Object<__X0__,__X1__,...>`.
-
-Note that `when<>` is implemented in terms of `call<>` and `make<>`,
-so the above procedure is evaluated recursively.
-
-Given the above description of the `__MakeImpl__<>` helper, the semantics
-of the `make<>` transform is described as follows:
-
-[def __AN__ A[~N]]
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<proto::make<Object(A0, A1, ... __AN__)>(Expr, State, Data)>::type`]
- [`__MakeImpl__<Object, Expr, State, Data>::type`]
- ]
- [ [`proto::make<Object(A0, A1, ... __AN__)>()(expr, state, data)`]
- [``__MakeImpl__<Object, Expr, State, Data>::type(
- proto::when<_, A0>()(expr, state, data)
- , proto::when<_, A1>()(expr, state, data)
- ...
- , proto::when<_, __AN__>()(expr, state, data)
-)``]
- ]
-]
-
-Objects with constructors that take up to `BOOST_PROTO_MAX_ARITY` are handled.
-Some types are so-called /aggregates/ that do not have constructors; rather,
-they use /aggregate initialization/. For these types, you can specialize
-`proto::is_aggregate<>` and Proto will use a brace initializer list to
-initialize the object rather than a constructor. Proto knows that `proto::expr<>`
-is such an aggregate, so if you use object transforms to "construct" a
-new node in an expression tree, the right thing happens.
-
-If no transform arguments are specified at all, as in `make<Object>`, this is
-the same as `make<Object()>`.
-
-Example:
-
-[LazyMakePair]
-
-[endsect]
-
-[section:lazy [^lazy<>]]
-
- namespace boost { namespace proto
- {
- template<typename Fun>
- struct lazy;
- }}
-
-Sometimes you would like a higher-order transform that returns another
-transform to be evaluated. This can happen when you have a transform
-whose behavior needs to be parameterized on the current state of the
-transformation. For these situations, you can use the `lazy<>` transform,
-which is essentially an invocation of the `make<>` transform (to evaluate
-any nested transforms and create the higher-order transform) followed
-by an invocation of `call<>` (to actually execute the higher-order
-transform).
-
-The behavior of `lazy<>` is easily specified in terms of `make<>` and
-`call<>`.
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<proto::lazy<Object(A0, A1, ... __AN__)>(Expr, State, Data)>::type`]
- [``boost::result_of<proto::call<
- boost::result_of<proto::make<Object>(Expr, State, Data)>::type(A0, A1, ... __AN__)
->(Expr, State, Data)>::type``]
- ]
- [ [`proto::lazy<Object(A0, A1, ... __AN__)>()(expr, state, data)`]
- [``proto::call<
- boost::result_of<proto::make<Object>(Expr, State, Data)>::type(A0, A1, ... __AN__)
->()(expr, state, data)``]
- ]
-]
-
-If no transform arguments are specified at all, as in `lazy<Object>`, this is
-the same as `lazy<Object(_expr, _state, _data)>`.
-
-[endsect]
-
-[section:when [^when<>]]
-
- namespace boost { namespace proto
- {
- template<typename Grammar, typename Transform = Grammar>
- struct when;
- }}
-
-`when<>` associates a grammar rule with a transform. It can be used
-in a grammar in place of the rule; that is, it behaves as a grammar
-rule. Expression tree nodes that match the grammar rule are processed
-with the associated transform; that is, `when<>` also behaves like
-a transform.
-
-When no transform is specified, as with `when< unary_plus<Calculator> >`,
-the grammar is treated as the transform. Every grammar element has
-a default transform. For most, such as `unary_plus<>`, the default transform
-is `pass_through<>`.
-
-The `when<>` transform is easily specified in terms of `call<>`,
-`make<>`, and the `is_callable<>` trait.
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<proto::when<Grammar, R(A0, A1, ... __AN__)>(Expr, State, Data)>::type`]
- [``boost::result_of<boost::mpl::if_<
- proto::is_callable<R>
- , proto::call<R(A0, A1, ... __AN__)>
- , proto::make<R(A0, A1, ... __AN__)>
->::type(Expr, State, Data)>::type``]
- ]
- [ [`proto::when<Grammar, R(A0, A1, ... __AN__)>()(expr, state, data)`]
- [``boost::mpl::if_<
- proto::is_callable<R>
- , proto::call<R(A0, A1, ... __AN__)>
- , proto::make<R(A0, A1, ... __AN__)>
->::type()(expr, state, data)``]
- ]
-]
-
-If no transform arguments are specified, as in `when<Grammar, _child>`, the
-transform is assumed to be callable; that is, it is equivalent to
-`when<Grammar, call<_child> >`.[footnote It is done this way to improve compile
-times.]
-
-[endsect]
-
-[section:fold [^fold<>] and [^reverse_fold<>]]
-
- namespace boost { namespace proto
- {
- template<typename Sequence, typename State0, typename Fun>
- struct fold;
-
- template<typename Sequence, typename State0, typename Fun>
- struct reverse_fold;
- }}
-
-The transforms `fold<>` and `reverse_fold<>` are akin to the
-`std::accumulate()` algorithm in the STL, or the `fold()` algorithm in
-Boost.Fusion. They iterate over some sequence and
-accumulate some state at each element. The `fold<>`
-transform iterates over the children in order, starting with the 0th child.
-The `reverse_fold<>` transform does it in reverse order, starting with the Nth
-child. (Note that for building things like cons lists, you'll often want to
-built it back-to-front with `reverse_fold<>`.)
-
-Both `fold<>` and `reverse_fold<>` are implemented in terms of `fusion::fold<>`.
-The three template parameters must each be Proto transforms. The have the following
-meaning:
-
-* `Sequence`: A Proto transform that returns a Fusion sequence.
-* `State`: A Proto transform that returns the initial state of the fold.
-* `Fun`: A Proto transform representing the operation to perform at each
- iteration of the fold algorithm.
-
-Often, the `Sequence` parameter is `proto::_`, which returns the current node
-in the Proto expression tree. Tree nodes are valid Fusion sequences, where
-the children are the elements of the sequence.
-
-[def __AS_CALLABLE__ [~[^AsCallable]]]
-
-The semantics of the `fold<>` and `reverse_fold<>` transforms can both be
-understood in terms of a helper struct, `__AS_CALLABLE__<>`, which binds the
-data and the `Fun` transform into a binary function object for use by
-`fusion::fold()`. `__AS_CALLABLE__<>` has the following behavior:
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<__AS_CALLABLE__<Fun, Data>(Expr, State)>::type`]
- [`boost::result_of<proto::when<_, Fun>(Expr, State, Data)>::type`]
- ]
- [ [`__AS_CALLABLE__<Fun, Data>(data)(expr, state)`]
- [`proto::when<_, Fun>()(expr, state, data)`]
- ]
-]
-
-With the above `__AS_CALLABLE__<>` adaptor, `fold<>` and `reverse_fold<>`
-can be easily implemented in terms of `fusion::fold<>`:
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [`boost::result_of<proto::fold<Sequence, State0, Fun>(Expr, State, Data)>::type`]
- [``fusion::result_of::fold<
- boost::result_of<proto::when<_, Sequence>(Expr, State, Data)>::type
- , boost::result_of<proto::when<_, State0>(Expr, State, Data)>::type
- , __AS_CALLABLE__<Fun, Data>
->::type``]
- ]
- [ [`proto::fold<Sequence, State0, Fun>()(expr, state, data)`]
- [``fusion::fold(
- proto::when<_, Sequence>()(expr, state, data)
- , proto::when<_, State0>()(expr, state, data)
- , __AS_CALLABLE__<Fun, Data>(data)
-)``]
- ]
- [ [`boost::result_of<proto::reverse_fold<Sequence, State0, Fun>(Expr, State, Data)>::type`]
- [``fusion::result_of::fold<
- fusion::result_of::reverse<
- boost::result_of<proto::when<_, Sequence>(Expr, State, Data)>::type
- >::type
- , boost::result_of<proto::when<_, State0>(Expr, State, Data)>::type
- , __AS_CALLABLE__<Fun, Data>
->::type``]
- ]
- [ [`proto::reverse_fold<Sequence, State0, Fun>()(expr, state, data)`]
- [``fusion::fold(
- fusion::reverse(
- proto::when<_, Sequence>()(expr, state, data)
- )
- , proto::when<_, State0>()(expr, state, data)
- , __AS_CALLABLE__<Fun, Data>(data)
-)``]
- ]
-]
-
-[#reverse_fold_example]Example:
-
-[AsArgList]
-
-[endsect]
-
-[section:fold_tree [^fold_tree<>] and [^reverse_fold_tree<>]]
-
- namespace boost { namespace proto
- {
- template<typename Sequence, typename State0, typename Fun>
- struct fold_tree;
-
- template<typename Sequence, typename State0, typename Fun>
- struct reverse_fold_tree;
- }}
-
-The `fold_tree<>` and `reverse_fold_tree<>` transforms recursively apply the
-`fold<>` and `reverse_fold<>` transforms to sub-trees that all share a common
-tag type. This is useful for flattening trees into lists; for example, you
-might use `reverse_fold_tree<>` to flatten an expression tree like `a | b | c`
-into a Fusion list like `cons(a, cons(b, cons(c)))`.
-
-The `fold_tree<>` and `reverse_fold_tree<>` transforms are unlike the other
-transforms that Proto provides in that they operate on entire sub-trees rather
-than just single nodes within the tree.
-
-[def __FOLD_TREE_IMPL__ [~[^FoldTreeImpl]]]
-[def __REVERSE_FOLD_TREE_IMPL__ [~[^ReverseFoldTreeImpl]]]
-
-These are higher-level transforms, implemented in terms of the `fold<>`
-and `reverse_fold<>` transforms and helper structs `__FOLD_TREE_IMPL__<>` and
-`__REVERSE_FOLD_TREE_IMPL__<>`, one of which is shown below:
-
- // FoldTreeImpl either recurses into the expression, if its Grammar
- // matches, or else ends the recursion by matching Grammar and
- // applying its transform.
- template<typename Grammar, typename Fun>
- struct __FOLD_TREE_IMPL__
- : proto::or_<
- proto::when<Grammar, proto::fold<_, proto::_state, __FOLD_TREE_IMPL__<Grammar, Fun> > >
- , proto::when<_, Fun>
- >
- {};
-
-The `__REVERSE_FOLD_TREE_IMPL__<>` helper is specified similarly, only with
-`reverse_fold<>` instead of `fold<>`. With these two helpers, we can
-specify the behavior of `fold_tree<>` and `reverse_fold_tree<>` as
-follows:
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [``boost::result_of<
- proto::fold_tree<Sequence, State0, Fun>(Expr, State, Data)
->::type``]
- [``boost::result_of<
- proto::fold<
- Sequence
- , State0
- , __FOLD_TREE_IMPL__<
- proto::nary_expr<Expr::proto_tag, proto::vararg<_> >
- , Fun
- >
- >(Expr, State, Data)
->::type``]
- ]
- [ [`proto::fold_tree<Sequence, State0, Fun>()(expr, state, data)`]
- [``proto::fold<
- Sequence
- , State0
- , __FOLD_TREE_IMPL__<
- proto::nary_expr<Expr::proto_tag, proto::vararg<_> >
- , Fun
- >
->()(expr, state, data)``]
- ]
- [ [``boost::result_of<
- proto::reverse_fold_tree<Sequence, State0, Fun>(Expr, State, Data)
->::type``]
- [``boost::result_of<
- proto::reverse_fold<
- Sequence
- , State0
- , __REVERSE_FOLD_TREE_IMPL__<
- proto::nary_expr<Expr::proto_tag, proto::vararg<_> >
- , Fun
- >
- >(Expr, State, Data)
->::type``]
- ]
- [ [`proto::reverse_fold_tree<Sequence, State0, Fun>()(expr, state, data)`]
- [``proto::reverse_fold<
- Sequence
- , State0
- , __REVERSE_FOLD_TREE_IMPL__<
- proto::nary_expr<Expr::proto_tag, proto::vararg<_> >
- , Fun
- >
->()(expr, state, data)``]
- ]
-]
-
-Example:
-
-[FoldTreeToList]
-
-[endsect]
-
-[section:pass_through [^pass_through<>]]
-
- namespace boost { namespace proto
- {
- template<typename Grammar>
- struct pass_through;
- }}
-
-The `pass_through<>` transform iterates over the pairs of
-children in the grammar and the expression, applying the child grammar's
-transform to the corresponding child expression. The resulting transformed
-children expressions are reassembled back into an expression of the same
-type as the parent expression.
-
-As a side-effect, `pass_through<>` transforms all sub-expressions held by
-reference into ones held by value.
-
-Note that all expression generator metafunctions (Eg., `unary_plus<>`,
-`shift_right<>`, `function<>`, `nary_expr<>`, etc.) have a pass-through
-transform by default, so there is rarely any need to use the `pass_through<>`
-transform explicitly.
-
-[table
- [ [Expression]
- [Returns]
- ]
- [ [``boost::result_of<
- proto::pass_through<Grammar>(Expr, State, Data)
->::type``]
- [``proto::nary_expr<
- Expr::proto_tag
- , boost::result_of<Grammar::proto_child0(Expr::proto_child0, State, Data)>::type
- , boost::result_of<Grammar::proto_child1(Expr::proto_child1, State, Data)>::type
- // ...
- , boost::result_of<Grammar::proto_childN(Expr::proto_childN, State, Data)>::type
->::type``]
- ]
- [ [`proto::pass_through<Grammar>()(expr, state, data)`]
- [``proto::make_expr<Expr::proto_tag>(
- Grammar::proto_child0()(proto::child_c<0>(expr), state, data)
- Grammar::proto_child1()(proto::child_c<1>(expr), state, data)
- // ...
- Grammar::proto_childN()(proto::child_c<N>(expr), state, data)
-)``]
- ]
-]
-
-Example:
-
-[Promote]
-
-[endsect]
-
-[endsect]
-
-[/======================================================]
-[section:user_defined_transforms User-Defined Transforms]
-[/======================================================]
-
-In previous sections, we've seen how to compose larger transforms
-out of smaller transforms using function types. The smaller transforms
-from which larger transforms are composed are /primitive transforms/,
-and Proto provides a bunch of common ones such as `_child0` and `_value`.
-In this section we'll see how to author your own primitive transforms.
-
-[note There are a few reasons why you might want to write your own
-primitive transforms. For instance, your transform may be complicated,
-and composing it out of primitives becomes unwieldy. You might also need
-to work around compiler bugs on legacy compilers that makes
-composing transforms using function types problematic. Finally,
-you might also decide to define your own primitive transforms
-to improve compile times. Since Proto can simply invoke a
-primitive transform directly without having to process arguments
-or differentiate callable transforms from object transforms,
-primitive transforms are more efficient.]
-
-[def _N_ [~N]]
-
-Primitive transforms inherit from `proto::transform<>`
-and have a nested `impl<>` template that inherits from
-`proto::transform_impl<>`. For example, this is how Proto
-defines the `_child_c<_N_>` transform, which returns the
-_N_-th child of the current expression:
-
- namespace boost { namespace proto
- {
- // A primitive transform that returns N-th child
- // of the current expression.
- template<int N>
- struct _child_c : transform<_child_c<N> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl : transform_impl<Expr, State, Data>
- {
- typedef
- typename result_of::child_c<Expr, N>::type
- result_type;
-
- result_type operator ()(
- typename impl::expr_param expr
- , typename impl::state_param state
- , typename impl::data_param data
- ) const
- {
- return proto::child_c<N>(expr);
- }
- };
- };
-
- // Note that _child_c<N> is callable, so that
- // it can be used with arguments, as:
- // _child_c<0>(_child_c<1>)
- template<int N>
- struct is_callable<_child_c<N> >
- : mpl::true_
- {};
- }}
-
-The `proto::transform<>` base class provides the `operator()` overloads
-and the nested `result<>` template that make your transform a valid
-function object. These are implemented in terms of the nested `impl<>`
-template you define.
-
-The `proto::transform_impl<>` base class is a convenience. It
-provides some nested typedefs that are generally useful. The are
-specified in the table below:
-
-[table proto::transform_impl<Expr, State, Data> typedefs
-[[typedef][Equivalent To]]
-[[`expr`][`typename remove_reference<Expr>::type`]]
-[[`state`][`typename remove_reference<State>::type`]]
-[[`data`][`typename remove_reference<Data>::type`]]
-[[`expr_param`][`typename add_reference<typename add_const<Expr>::type>::type`]]
-[[`state_param`][`typename add_reference<typename add_const<State>::type>::type`]]
-[[`data_param`][`typename add_reference<typename add_const<Data>::type>::type`]]
-]
-
-You'll notice that `_child_c::impl::operator()` takes arguments of types
-`expr_param`, `state_param`, and `data_param`. The typedefs make it easy to
-accept arguments by reference or const reference accordingly.
-
-The only other interesting bit is the `is_callable<>` specialization, which
-will be described in the
-[link boost_proto.users_guide.expression_transformation.is_callable
-next section].
-
-[endsect]
-
-[/=================================================]
-[section:is_callable Making Your Transform Callable]
-[/=================================================]
-
-Transforms are typically of the form `proto::when< Something, R(A0,A1,...) >`. The
-question is whether `R` represents a function to call or an object to
-construct, and the answer determines how _when_ evaluates the transform.
-_when_ uses the `proto::is_callable<>` trait to disambiguate between the two.
-Proto does its best to guess whether a transform is callable or not, but
-it doesn't always get it right. It's best to know the rules Proto uses,
-so that you know when you need to be more explicit.
-
-For most types `T`, `proto::is_callable<T>` checks for inheritence from
-`proto::callable`. However, if the type `T` is a template specialization,
-Proto assumes that it is /not/ callable ['even if the template inherits from
-`proto::callable`]. We'll see why in a minute. Consider the following erroneous
-callable transform:
-
- // Proto can't tell this defines a
- // callable transform!
- template<typename T>
- struct times2 : proto::callable
- {
- typedef T result_type;
-
- T operator()(T i) const
- {
- return i * 2;
- }
- };
-
- // ERROR! This is not going to
- // multiply the int by 2.
- struct IntTimes2
- : proto::when<
- proto::terminal<int>
- , times2<int>(proto::_value)
- >
- {};
-
-The problem is that Proto doesn't know that `times2<int>` is a callable
-transform. Instead, it assumes it is an object transform and will try to
-construct a `times2<int>` object and initialize it will an `int`. That
-will not compile.
-
-[note Why can't Proto tell that `times2<int>` is callable? After all,
-it inherits from `proto::callable`, and that is detectable, right?
-The problem is that merely asking whether some type `X<Y>` inherits from
-`callable` will cause the template `X<Y>` to be instantiated. That's a
-problem for a type like `std::vector<_value(_child1)>`. `std::vector<>`
-will not suffer to be instantiated with `_value(_child1)` as a template
-parameter. As a result, Proto has to assume that a type `X<Y>` represents
-an object transform and not a callable transform.]
-
-There are a couple of solutions to the `times2<int>` problem. One
-solution is to wrap the transform in `proto::call<>`. This forces Proto
-to treat `times2<int>` as callable:
-
- // OK, calls times2<int>
- struct IntTimes2
- : proto::when<
- proto::terminal<int>
- , proto::call<times2<int>(proto::_value)>
- >
- {};
-
-This can be a bit of a pain, because we need to wrap every use of
-`times2<int>`, which can be tedious and error prone, and makes our
-grammar cluttered and harder to read.
-
-Another solution is to specialize `proto::is_callable<>` on our
-`times2<>` template:
-
- namespace boost { namespace proto
- {
- template<typename T>
- struct is_callable<times2<T> >
- : mpl::true_
- {};
- }}
-
- // OK, times2<> is callable
- struct IntTimes2
- : proto::when<
- proto::terminal<int>
- , times2<int>(proto::_value)
- >
- {};
-
-This is better, but still a pain because of the need to open
-Proto's namespace.
-
-You could simply make sure that the transform is not
-a template specialization. Consider the following:
-
- // No longer a template specialization!
- struct times2int : times2<int> {};
-
- // OK, times2int is callable
- struct IntTimes2
- : proto::when<
- proto::terminal<int>
- , times2int(proto::_value)
- >
- {};
-
-This works because now Proto can tell that `times2int` inherits
-(indirectly) from `proto::callable`. Any non-template types can
-be safely checked for inheritance because, as they are not
-templates, there is no worry about instantiation errors.
-
-There is one last way to tell Proto that `times2<>` is callable.
-You could add an extra dummy template parameter that defaults
-to `proto::callable`:
-
- // Proto will recognize this as callable
- template<typename T, typename Callable = proto::callable>
- struct times2 : proto::callable
- {
- typedef T result_type;
-
- T operator()(T i) const
- {
- return i * 2;
- }
- };
-
- // OK, this works!
- struct IntTimes2
- : proto::when<
- proto::terminal<int>
- , times2<int>(proto::_value)
- >
- {};
-
-Note that in addition to the extra template parameter, `times2<>`
-still inherits from `proto::callable`. That's not necessary in this
-example but it's good style because any types derived from `times2<>`
-(as `times2int` defined above) will still be considered callable.
-
-[endsect]
-
-[endsect]
Deleted: trunk/libs/proto/doc/wave.sh
==============================================================================
--- trunk/libs/proto/doc/wave.sh 2008-11-02 07:20:59 EST (Sun, 02 Nov 2008)
+++ (empty file)
@@ -1,7 +0,0 @@
-../../../../dist/bin/wave\
- -S ../../../..\
- -S "C:\\Program Files\\Microsoft Visual Studio .NET 2003\\vc7\\include"\
- -D _WIN32\
- -D BOOST_PROTO_DOXYGEN_INVOKED\
- -p 1\
- `cygpath -d $1`