Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: /// \file fold.hpp
Chris@16: /// Contains definition of the fold<> and reverse_fold<> transforms.
Chris@16: //
Chris@16: //  Copyright 2008 Eric Niebler. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #ifndef BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
Chris@16: #define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
Chris@16: 
Chris@16: #include <boost/preprocessor/cat.hpp>
Chris@16: #include <boost/preprocessor/iteration/iterate.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/inc.hpp>
Chris@16: #include <boost/preprocessor/arithmetic/sub.hpp>
Chris@16: #include <boost/preprocessor/repetition/repeat.hpp>
Chris@16: #include <boost/fusion/include/fold.hpp>
Chris@16: #include <boost/fusion/include/reverse_fold.hpp>
Chris@16: #include <boost/proto/proto_fwd.hpp>
Chris@16: #include <boost/proto/traits.hpp>
Chris@16: #include <boost/proto/transform/impl.hpp>
Chris@16: #include <boost/proto/transform/when.hpp>
Chris@16: 
Chris@16: namespace boost { namespace proto
Chris@16: {
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         template<typename Transform, typename Data>
Chris@16:         struct as_callable
Chris@16:         {
Chris@16:             as_callable(Data d)
Chris@16:               : d_(d)
Chris@16:             {}
Chris@16: 
Chris@16:             template<typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template<typename This, typename State, typename Expr>
Chris@16:             struct result<This(State, Expr)>
Chris@16:             {
Chris@16:                 typedef
Chris@16:                     typename when<_, Transform>::template impl<Expr, State, Data>::result_type
Chris@16:                 type;
Chris@16:             };
Chris@16: 
Chris@16:             template<typename State, typename Expr>
Chris@16:             typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type
Chris@16:             operator ()(State const &s, Expr &e) const
Chris@16:             {
Chris@16:                 return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_);
Chris@16:             }
Chris@16: 
Chris@16:         private:
Chris@16:             Data d_;
Chris@16:         };
Chris@16: 
Chris@16:         template<
Chris@16:             typename State0
Chris@16:           , typename Fun
Chris@16:           , typename Expr
Chris@16:           , typename State
Chris@16:           , typename Data
Chris@16:           , long Arity = arity_of<Expr>::value
Chris@16:         >
Chris@16:         struct fold_impl
Chris@16:         {};
Chris@16: 
Chris@16:         template<
Chris@16:             typename State0
Chris@16:           , typename Fun
Chris@16:           , typename Expr
Chris@16:           , typename State
Chris@16:           , typename Data
Chris@16:           , long Arity = arity_of<Expr>::value
Chris@16:         >
Chris@16:         struct reverse_fold_impl
Chris@16:         {};
Chris@16: 
Chris@16:         #include <boost/proto/transform/detail/fold_impl.hpp>
Chris@16: 
Chris@16:     } // namespace detail
Chris@16: 
Chris@16:     /// \brief A PrimitiveTransform that invokes the <tt>fusion::fold\<\></tt>
Chris@16:     /// algorithm to accumulate
Chris@16:     template<typename Sequence, typename State0, typename Fun>
Chris@16:     struct fold : transform<fold<Sequence, State0, Fun> >
Chris@16:     {
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl : transform_impl<Expr, State, Data>
Chris@16:         {
Chris@16:             /// \brief A Fusion sequence.
Chris@16:             typedef
Chris@16:                 typename remove_reference<
Chris@16:                     typename when<_, Sequence>::template impl<Expr, State, Data>::result_type
Chris@16:                 >::type
Chris@16:             sequence;
Chris@16: 
Chris@16:             /// \brief An initial state for the fold.
Chris@16:             typedef
Chris@16:                 typename remove_reference<
Chris@16:                     typename when<_, State0>::template impl<Expr, State, Data>::result_type
Chris@16:                 >::type
Chris@16:             state0;
Chris@16: 
Chris@16:             /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt>
Chris@16:             typedef
Chris@16:                 detail::as_callable<Fun, Data>
Chris@16:             fun;
Chris@16: 
Chris@16:             typedef
Chris@16:                 typename fusion::result_of::fold<
Chris@16:                     sequence
Chris@16:                   , state0
Chris@16:                   , fun
Chris@16:                 >::type
Chris@16:             result_type;
Chris@16: 
Chris@16:             /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let
Chris@16:             /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and
Chris@16:             /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt>
Chris@16:             /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this
Chris@16:             /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>.
Chris@16:             ///
Chris@16:             /// \param e The current expression
Chris@16:             /// \param s The current state
Chris@16:             /// \param d An arbitrary data
Chris@16:             result_type operator ()(
Chris@16:                 typename impl::expr_param   e
Chris@16:               , typename impl::state_param  s
Chris@16:               , typename impl::data_param   d
Chris@16:             ) const
Chris@16:             {
Chris@16:                 typename when<_, Sequence>::template impl<Expr, State, Data> seq;
Chris@16:                 detail::as_callable<Fun, Data> f(d);
Chris@16:                 return fusion::fold(
Chris@16:                     seq(e, s, d)
Chris@16:                   , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
Chris@16:                   , f
Chris@16:                 );
Chris@16:             }
Chris@16:         };
Chris@16:     };
Chris@16: 
Chris@16:     /// \brief A PrimitiveTransform that is the same as the
Chris@16:     /// <tt>fold\<\></tt> transform, except that it folds
Chris@16:     /// back-to-front instead of front-to-back.
Chris@16:     template<typename Sequence, typename State0, typename Fun>
Chris@16:     struct reverse_fold  : transform<reverse_fold<Sequence, State0, Fun> >
Chris@16:     {
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl : transform_impl<Expr, State, Data>
Chris@16:         {
Chris@16:             /// \brief A Fusion sequence.
Chris@16:             typedef
Chris@16:                 typename remove_reference<
Chris@16:                     typename when<_, Sequence>::template impl<Expr, State, Data>::result_type
Chris@16:                 >::type
Chris@16:             sequence;
Chris@16: 
Chris@16:             /// \brief An initial state for the fold.
Chris@16:             typedef
Chris@16:                 typename remove_reference<
Chris@16:                     typename when<_, State0>::template impl<Expr, State, Data>::result_type
Chris@16:                 >::type
Chris@16:             state0;
Chris@16: 
Chris@16:             /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt>
Chris@16:             typedef
Chris@16:                 detail::as_callable<Fun, Data>
Chris@16:             fun;
Chris@16: 
Chris@16:             typedef
Chris@16:                 typename fusion::result_of::reverse_fold<
Chris@16:                     sequence
Chris@16:                   , state0
Chris@16:                   , fun
Chris@16:                 >::type
Chris@16:             result_type;
Chris@16: 
Chris@16:             /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let
Chris@16:             /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and
Chris@16:             /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt>
Chris@16:             /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this
Chris@16:             /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>.
Chris@16:             ///
Chris@16:             /// \param e The current expression
Chris@16:             /// \param s The current state
Chris@16:             /// \param d An arbitrary data
Chris@16:             result_type operator ()(
Chris@16:                 typename impl::expr_param   e
Chris@16:               , typename impl::state_param  s
Chris@16:               , typename impl::data_param   d
Chris@16:             ) const
Chris@16:             {
Chris@16:                 typename when<_, Sequence>::template impl<Expr, State, Data> seq;
Chris@16:                 detail::as_callable<Fun, Data> f(d);
Chris@16:                 return fusion::reverse_fold(
Chris@16:                     seq(e, s, d)
Chris@16:                   , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
Chris@16:                   , f
Chris@16:                 );
Chris@16:             }
Chris@16:         };
Chris@16:     };
Chris@16: 
Chris@16:     // This specialization is only for improved compile-time performance
Chris@16:     // in the commom case when the Sequence transform is \c proto::_.
Chris@16:     //
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename State0, typename Fun>
Chris@16:     struct fold<_, State0, Fun> : transform<fold<_, State0, Fun> >
Chris@16:     {
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl
Chris@16:           : detail::fold_impl<State0, Fun, Expr, State, Data>
Chris@16:         {};
Chris@16:     };
Chris@16: 
Chris@16:     // This specialization is only for improved compile-time performance
Chris@16:     // in the commom case when the Sequence transform is \c proto::_.
Chris@16:     //
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename State0, typename Fun>
Chris@16:     struct reverse_fold<_, State0, Fun> : transform<reverse_fold<_, State0, Fun> >
Chris@16:     {
Chris@16:         template<typename Expr, typename State, typename Data>
Chris@16:         struct impl
Chris@16:           : detail::reverse_fold_impl<State0, Fun, Expr, State, Data>
Chris@16:         {};
Chris@16:     };
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Sequence, typename State, typename Fun>
Chris@16:     struct is_callable<fold<Sequence, State, Fun> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16:     /// INTERNAL ONLY
Chris@16:     ///
Chris@16:     template<typename Sequence, typename State, typename Fun>
Chris@16:     struct is_callable<reverse_fold<Sequence, State, Fun> >
Chris@16:       : mpl::true_
Chris@16:     {};
Chris@16: 
Chris@16: }}
Chris@16: 
Chris@16: #endif