Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r50106 - in trunk: boost/proto libs/proto/doc libs/proto/doc/reference
From: eric_at_[hidden]
Date: 2008-12-04 01:14:07


Author: eric_niebler
Date: 2008-12-04 01:14:06 EST (Thu, 04 Dec 2008)
New Revision: 50106
URL: http://svn.boost.org/trac/boost/changeset/50106

Log:
unpack_expr works with Fusion Forward Sequences
Text files modified:
   trunk/boost/proto/make_expr.hpp | 157 +++++++++++++++++++++++++++------------
   trunk/libs/proto/doc/proto.qbk | 2
   trunk/libs/proto/doc/reference/make_expr.xml | 24 +++--
   3 files changed, 121 insertions(+), 62 deletions(-)

Modified: trunk/boost/proto/make_expr.hpp
==============================================================================
--- trunk/boost/proto/make_expr.hpp (original)
+++ trunk/boost/proto/make_expr.hpp 2008-12-04 01:14:06 EST (Thu, 04 Dec 2008)
@@ -47,12 +47,14 @@
     #include <boost/proto/domain.hpp>
     #include <boost/proto/generate.hpp>
     #if BOOST_VERSION >= 103500
- # include <boost/fusion/include/at.hpp>
- # include <boost/fusion/include/value_at.hpp>
+ # include <boost/fusion/include/begin.hpp>
+ # include <boost/fusion/include/next.hpp>
+ # include <boost/fusion/include/value_of.hpp>
     # include <boost/fusion/include/size.hpp>
     #else
- # include <boost/spirit/fusion/sequence/at.hpp>
- # include <boost/spirit/fusion/sequence/value_at.hpp>
+ # include <boost/spirit/fusion/sequence/begin.hpp>
+ # include <boost/spirit/fusion/iterator/next.hpp>
+ # include <boost/spirit/fusion/iterator/value_of.hpp>
     # include <boost/spirit/fusion/sequence/size.hpp>
     #endif
     #include <boost/proto/detail/poly_function.hpp>
@@ -99,37 +101,67 @@
 
     /// INTERNAL ONLY
     ///
- # define BOOST_PROTO_AT_TYPE(Z, N, DATA) \
+ #define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA) \
+ typedef typename fusion::BOOST_PROTO_FUSION_RESULT_OF::next< \
+ BOOST_PP_CAT(fusion_iterator, N)>::type \
+ BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)); \
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_FUSION_ITERATORS_TYPE(N) \
+ typedef \
+ typename fusion::BOOST_PROTO_FUSION_RESULT_OF::begin<Sequence const>::type \
+ fusion_iterator0; \
+ BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator) \
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
         typename add_const< \
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_at_c< \
- BOOST_PP_TUPLE_ELEM(3, 0, DATA) \
- , N \
+ typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_of< \
+ BOOST_PP_CAT(fusion_iterator, N) \
>::type \
>::type \
         /**/
 
     /// INTERNAL ONLY
     ///
- # define BOOST_PROTO_AT(Z, N, DATA) \
- fusion::BOOST_PROTO_FUSION_AT_C(N, BOOST_PP_TUPLE_ELEM(3, 1, DATA)) \
+ #define BOOST_PROTO_FUSION_NEXT_ITERATOR(Z, N, DATA) \
+ BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)) BOOST_PP_CAT(it, BOOST_PP_INC(N)) = \
+ fusion::next(BOOST_PP_CAT(it, N)); \
         /**/
 
     /// INTERNAL ONLY
     ///
- #define BOOST_PROTO_AS_CHILD_AT_TYPE(Z, N, DATA) \
- typename boost::proto::detail::protoify_< \
- BOOST_PROTO_AT_TYPE(Z, N, DATA) \
- , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \
+ #define BOOST_PROTO_FUSION_ITERATORS(N) \
+ fusion_iterator0 it0 = fusion::begin(sequence); \
+ BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR, fusion_iterator) \
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_FUSION_AT(Z, N, DATA) \
+ *BOOST_PP_CAT(it, N) \
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE(Z, N, DATA) \
+ typename detail::protoify_< \
+ BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
+ , Domain \
>::type \
         /**/
 
     /// INTERNAL ONLY
     ///
- #define BOOST_PROTO_AS_CHILD_AT(Z, N, DATA) \
- boost::proto::detail::protoify_< \
- BOOST_PROTO_AT_TYPE(Z, N, DATA) \
- , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \
- >::call(BOOST_PROTO_AT(Z, N, DATA)) \
+ #define BOOST_PROTO_FUSION_AS_CHILD_AT(Z, N, DATA) \
+ detail::protoify_< \
+ BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
+ , Domain \
+ >::call(BOOST_PROTO_FUSION_AT(Z, N, DATA)) \
         /**/
 
         namespace detail
@@ -222,9 +254,8 @@
             {
                 typedef
                     typename add_const<
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_at_c<
- Sequence
- , 0
+ typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_of<
+ typename fusion::BOOST_PROTO_FUSION_RESULT_OF::begin<Sequence>::type
>::type
>::type
                 terminal_type;
@@ -449,7 +480,7 @@
             /// Use the <tt>result_of::unpack_expr\<\></tt> metafunction to
             /// compute the return type of the \c unpack_expr() function.
             ///
- /// \c Sequence is a Fusion Random Access Sequence.
+ /// \c Sequence is a Fusion Forward Sequence.
             ///
             /// In this specialization, the domain is deduced from the
             /// domains of the child types. (If
@@ -463,10 +494,12 @@
>
             struct unpack_expr
             {
- /// Same as <tt>result_of::make_expr\<Tag,
- /// fusion::value_at\<Sequence, 0\>::::type, ...
- /// fusion::value_at\<Sequence, N-1\>::::type\>::::type</tt>,
- /// where \c N is the size of \c Sequence.
+ /// Let \c S be the type of a Fusion Random Access Sequence
+ /// equivalent to \c Sequence. Then \c type is the
+ /// same as <tt>result_of::make_expr\<Tag,
+ /// fusion::result_of::value_at_c\<S, 0\>::::type, ...
+ /// fusion::result_of::value_at_c\<S, N-1\>::::type\>::::type</tt>,
+ /// where \c N is the size of \c S.
                 typedef
                     typename detail::unpack_expr_<
                         Tag
@@ -485,10 +518,12 @@
             template<typename Tag, typename Domain, typename Sequence>
             struct unpack_expr<Tag, Domain, Sequence, typename Domain::proto_is_domain_>
             {
- /// Same as <tt>result_of::make_expr\<Tag, Domain,
- /// fusion::value_at\<Sequence, 0\>::::type, ...
- /// fusion::value_at\<Sequence, N-1\>::::type\>::::type</tt>,
- /// where \c N is the size of \c Sequence.
+ /// Let \c S be the type of a Fusion Random Access Sequence
+ /// equivalent to \c Sequence. Then \c type is the
+ /// same as <tt>result_of::make_expr\<Tag, Domain,
+ /// fusion::result_of::value_at_c\<S, 0\>::::type, ...
+ /// fusion::result_of::value_at_c\<S, N-1\>::::type\>::::type</tt>,
+ /// where \c N is the size of \c S.
                 typedef
                     typename detail::unpack_expr_<
                         Tag
@@ -608,7 +643,7 @@
                 /// Construct an expression node with tag type \c Tag
                 /// and in the domain \c Domain.
                 ///
- /// \param sequence A Fusion Random Access Sequence
+ /// \param sequence A Fusion Forward Sequence
                 /// \return <tt>proto::unpack_expr\<Tag, Domain\>(sequence)</tt>
                 template<typename Sequence>
                 typename result_of::unpack_expr<Tag, Domain, Sequence const>::type
@@ -734,7 +769,7 @@
 
         /// \brief Construct an expression of the requested tag type
         /// with a domain and with childres from the specified Fusion
- /// Random Access Sequence.
+ /// Forward Sequence.
         ///
         /// This function template may be invoked either with or without
         /// specifying a \c Domain argument. If no domain is specified,
@@ -743,9 +778,10 @@
         /// \c default_domain, if any such domain exists, or
         /// \c default_domain otherwise.
         ///
+ /// Let \c s be a Fusion Random Access Sequence equivalent to \c sequence.
         /// Let <tt>wrap_\<N\>(s)</tt>, where \c s has type \c S, be defined
         /// such that:
- /// \li If <tt>fusion::value_at\<S,N\>::::type</tt> is a reference,
+ /// \li If <tt>fusion::result_of::value_at_c\<S,N\>::::type</tt> is a reference,
         /// <tt>wrap_\<N\>(s)</tt> is equivalent to
         /// <tt>as_child\<Domain\>(fusion::at_c\<N\>(s))</tt>.
         /// \li Otherwise, <tt>wrap_\<N\>(s)</tt> is equivalent to
@@ -755,8 +791,8 @@
         /// <tt>expr\<Tag, listN\<B0,...BN\> \>::::make(b0,...bN)</tt>
         /// where \c Bx is the type of \c bx.
         ///
- /// \param sequence a Fusion Random Access Sequence.
- /// \return <tt>Domain()(make_\<Tag\>(wrap_\<0\>(s),...wrap_\<N-1\>(S)))</tt>,
+ /// \param sequence a Fusion Forward Sequence.
+ /// \return <tt>Domain()(make_\<Tag\>(wrap_\<0\>(s),...wrap_\<N-1\>(s)))</tt>,
         /// where N is the size of \c Sequence.
         template<typename Tag, typename Sequence>
         typename lazy_disable_if<
@@ -832,10 +868,14 @@
     # pragma warning(pop)
     #endif
 
- #undef BOOST_PROTO_AT
- #undef BOOST_PROTO_AT_TYPE
- #undef BOOST_PROTO_AS_CHILD_AT
- #undef BOOST_PROTO_AS_CHILD_AT_TYPE
+ #undef BOOST_PROTO_FUSION_AT
+ #undef BOOST_PROTO_FUSION_AT_TYPE
+ #undef BOOST_PROTO_FUSION_AS_CHILD_AT
+ #undef BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE
+ #undef BOOST_PROTO_FUSION_NEXT_ITERATOR
+ #undef BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE
+ #undef BOOST_PROTO_FUSION_ITERATORS
+ #undef BOOST_PROTO_FUSION_ITERATORS_TYPE
 
     #endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
 
@@ -962,10 +1002,12 @@
         template<typename Tag, typename Domain, typename Sequence>
         struct unpack_expr_<Tag, Domain, Sequence, N>
         {
+ BOOST_PROTO_FUSION_ITERATORS_TYPE(N)
+
             typedef proto::expr<
                 Tag
               , BOOST_PP_CAT(list, N)<
- BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_AT_TYPE, (Sequence const, ~, Domain))
+ BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE, ~)
>
> expr_type;
 
@@ -973,8 +1015,9 @@
 
             static type const call(Sequence const &sequence)
             {
+ BOOST_PROTO_FUSION_ITERATORS(N)
                 expr_type that = {
- BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_AT, (Sequence const, sequence, Domain))
+ BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT, ~)
                 };
                 return Domain()(that);
             }
@@ -982,15 +1025,27 @@
 
         template<typename Tag, typename Sequence>
         struct unpack_expr_<Tag, deduce_domain, Sequence, N>
- : unpack_expr_<
- Tag
- , typename BOOST_PP_CAT(deduce_domain, N)<
- BOOST_PP_ENUM(N, BOOST_PROTO_AT_TYPE, (Sequence const, ~, ~))
- >::type
- , Sequence
- , N
- >
- {};
+ {
+ BOOST_PROTO_FUSION_ITERATORS_TYPE(N)
+
+ typedef
+ unpack_expr_<
+ Tag
+ , typename BOOST_PP_CAT(deduce_domain, N)<
+ BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AT_TYPE, ~)
+ >::type
+ , Sequence
+ , N
+ >
+ other;
+
+ typedef typename other::type type;
+
+ static type const call(Sequence const &sequence)
+ {
+ return other::call(sequence);
+ }
+ };
 
     #undef N
     #undef M

Modified: trunk/libs/proto/doc/proto.qbk
==============================================================================
--- trunk/libs/proto/doc/proto.qbk (original)
+++ trunk/libs/proto/doc/proto.qbk 2008-12-04 01:14:06 EST (Thu, 04 Dec 2008)
@@ -51,6 +51,8 @@
   [funcref boost::proto::deep_copy `proto::deep_copy()`]]
 [def _domain_
   [classref boost::proto::domain `proto::domain<>`]]
+[def _domain_
+ [classref boost::proto::default_domain `proto::default_domain`]]
 [def _extends_
   [classref boost::proto::extends `proto::extends<>`]]
 [def _as_expr_

Modified: trunk/libs/proto/doc/reference/make_expr.xml
==============================================================================
--- trunk/libs/proto/doc/reference/make_expr.xml (original)
+++ trunk/libs/proto/doc/reference/make_expr.xml 2008-12-04 01:14:06 EST (Thu, 04 Dec 2008)
@@ -122,7 +122,7 @@
               <parameter name="sequence">
                 <paramtype>Sequence const &amp;</paramtype>
                 <description>
- <para>A Fusion Random Access Sequence </para>
+ <para>A Fusion Forward Sequence </para>
                 </description>
               </parameter>
               <description>
@@ -243,7 +243,7 @@
               function.
             </para>
             <para>
- <computeroutput>Sequence</computeroutput> is a Fusion Random Access Sequence.
+ <computeroutput>Sequence</computeroutput> is a Fusion Forward Sequence.
             </para>
             <para>
               In this specialization, the domain is deduced from the domains of the child types.
@@ -252,13 +252,13 @@
             </para>
           </description>
           <typedef name="type">
- <purpose>Where N is the size of Sequence.</purpose>
+ <purpose>Where S is a RandomAccessSequence equivalent to Sequence, and N is the size of S.</purpose>
             <type>
     typename <classname>proto::result_of::make_expr</classname>&lt;
       Tag,
- typename fusion::value_at&lt;Sequence, 0&gt;::type,
+ typename fusion::result_of::value_at_c&lt;<replaceable>S</replaceable>, 0&gt;::type,
       ...
- typename fusion::value_at&lt;Sequence, <replaceable>N</replaceable>-1&gt;::type
+ typename fusion::result_of::value_at_c&lt;<replaceable>S</replaceable>, <replaceable>N</replaceable>-1&gt;::type
     &gt;::type
   </type>
           </typedef>
@@ -286,14 +286,14 @@
             </para>
           </description>
           <typedef name="type">
- <purpose>Where N is the size of Sequence.</purpose>
+ <purpose>Where S is a RandomAccessSequence equivalent to Sequence, and N is the size of S.</purpose>
             <type>
     typename <classname>proto::result_of::make_expr</classname>&lt;
       Tag,
       Domain,
- typename fusion::value_at&lt;Sequence, 0&gt;::type,
+ typename fusion::result_of::value_at_c&lt;<replaceable>S</replaceable>, 0&gt;::type,
       ...
- typename fusion::value_at&lt;Sequence, <replaceable>N</replaceable>-1&gt;::type
+ typename fusion::result_of::value_at_c&lt;<replaceable>S</replaceable>, <replaceable>N</replaceable>-1&gt;::type
     &gt;::type
   </type>
           </typedef>
@@ -379,7 +379,7 @@
           <parameter name="sequence">
             <paramtype>Sequence const &amp;</paramtype>
             <description>
- <para>A Fusion Random Access Sequence.</para>
+ <para>A Fusion Forward Sequence.</para>
             </description>
           </parameter>
         </signature>
@@ -395,7 +395,7 @@
           </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>
+ from the specified Fusion Forward Sequence.</purpose>
         <description>
           <para>
             This function template may be invoked either with or without specifying a
@@ -406,12 +406,14 @@
             exists, or <computeroutput><classname>proto::default_domain</classname></computeroutput> otherwise.
           </para>
           <para>
+ Let <computeroutput>s</computeroutput> be a Fusion Random Access Sequence equivalent to
+ <computeroutput>sequence</computeroutput>.
             Let <computeroutput><replaceable>WRAP</replaceable>&lt;N&gt;(s)</computeroutput>, where
             <computeroutput>s</computeroutput> has type <computeroutput>S</computeroutput>, be defined such that:
             <itemizedlist>
               <listitem>
                 <para>
- If <computeroutput>fusion::value_at&lt;S,N&gt;::type</computeroutput> is a reference,
+ If <computeroutput>fusion::result_of::value_at_c&lt;S,N&gt;::type</computeroutput> is a reference,
                   <computeroutput><replaceable>WRAP</replaceable>&lt;N&gt;(s)</computeroutput> is equivalent to
                   <computeroutput><functionname>proto::as_child</functionname>&lt;Domain&gt;(fusion::at_c&lt;N&gt;(s))</computeroutput>.
                 </para>


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk