ceph/src/boost/libs/proto/include/boost/proto/transform/detail/preprocessed/fold_impl.hpp

   1     ///////////////////////////////////////////////////////////////////////////////
   2     /// \file fold_impl.hpp
   3     /// Contains definition of fold_impl<> and reverse_fold_impl<> templates.
   4     //
   5     //  Copyright 2008 Eric Niebler. Distributed under the Boost
   6     //  Software License, Version 1.0. (See accompanying file
   7     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
   9     struct fold_impl<State0, Fun, Expr, State, Data, 1>
  10       : transform_impl<Expr, State, Data>
  11     {
  12         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
  13         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1;
  14         typedef state1 result_type;
  15         result_type operator ()(
  16             typename fold_impl::expr_param e
  17           , typename fold_impl::state_param s
  18           , typename fold_impl::data_param d
  19         ) const
  20         {
  21             state0 s0 =
  22                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
  23             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d );
  24             return s1;
  25         }
  26     };
  27     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
  28     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 1>
  29       : transform_impl<Expr, State, Data>
  30     {
  31         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state1;
  32         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
  33         typedef state0 result_type;
  34         result_type operator ()(
  35             typename reverse_fold_impl::expr_param e
  36           , typename reverse_fold_impl::state_param s
  37           , typename reverse_fold_impl::data_param d
  38         ) const
  39         {
  40             state1 s1 =
  41                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
  42             state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
  43             return s0;
  44         }
  45     };
  46     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
  47     struct fold_impl<State0, Fun, Expr, State, Data, 2>
  48       : transform_impl<Expr, State, Data>
  49     {
  50         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
  51         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2;
  52         typedef state2 result_type;
  53         result_type operator ()(
  54             typename fold_impl::expr_param e
  55           , typename fold_impl::state_param s
  56           , typename fold_impl::data_param d
  57         ) const
  58         {
  59             state0 s0 =
  60                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
  61             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d );
  62             return s2;
  63         }
  64     };
  65     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
  66     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 2>
  67       : transform_impl<Expr, State, Data>
  68     {
  69         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state2;
  70         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
  71         typedef state0 result_type;
  72         result_type operator ()(
  73             typename reverse_fold_impl::expr_param e
  74           , typename reverse_fold_impl::state_param s
  75           , typename reverse_fold_impl::data_param d
  76         ) const
  77         {
  78             state2 s2 =
  79                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
  80             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
  81             return s0;
  82         }
  83     };
  84     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
  85     struct fold_impl<State0, Fun, Expr, State, Data, 3>
  86       : transform_impl<Expr, State, Data>
  87     {
  88         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
  89         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3;
  90         typedef state3 result_type;
  91         result_type operator ()(
  92             typename fold_impl::expr_param e
  93           , typename fold_impl::state_param s
  94           , typename fold_impl::data_param d
  95         ) const
  96         {
  97             state0 s0 =
  98                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
  99             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d );
 100             return s3;
 101         }
 102     };
 103     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 104     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 3>
 105       : transform_impl<Expr, State, Data>
 106     {
 107         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state3;
 108         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 109         typedef state0 result_type;
 110         result_type operator ()(
 111             typename reverse_fold_impl::expr_param e
 112           , typename reverse_fold_impl::state_param s
 113           , typename reverse_fold_impl::data_param d
 114         ) const
 115         {
 116             state3 s3 =
 117                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 118             state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 119             return s0;
 120         }
 121     };
 122     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 123     struct fold_impl<State0, Fun, Expr, State, Data, 4>
 124       : transform_impl<Expr, State, Data>
 125     {
 126         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
 127         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4;
 128         typedef state4 result_type;
 129         result_type operator ()(
 130             typename fold_impl::expr_param e
 131           , typename fold_impl::state_param s
 132           , typename fold_impl::data_param d
 133         ) const
 134         {
 135             state0 s0 =
 136                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 137             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d );
 138             return s4;
 139         }
 140     };
 141     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 142     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 4>
 143       : transform_impl<Expr, State, Data>
 144     {
 145         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state4;
 146         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 147         typedef state0 result_type;
 148         result_type operator ()(
 149             typename reverse_fold_impl::expr_param e
 150           , typename reverse_fold_impl::state_param s
 151           , typename reverse_fold_impl::data_param d
 152         ) const
 153         {
 154             state4 s4 =
 155                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 156             state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 157             return s0;
 158         }
 159     };
 160     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 161     struct fold_impl<State0, Fun, Expr, State, Data, 5>
 162       : transform_impl<Expr, State, Data>
 163     {
 164         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
 165         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5;
 166         typedef state5 result_type;
 167         result_type operator ()(
 168             typename fold_impl::expr_param e
 169           , typename fold_impl::state_param s
 170           , typename fold_impl::data_param d
 171         ) const
 172         {
 173             state0 s0 =
 174                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 175             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d );
 176             return s5;
 177         }
 178     };
 179     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 180     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 5>
 181       : transform_impl<Expr, State, Data>
 182     {
 183         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state5;
 184         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 185         typedef state0 result_type;
 186         result_type operator ()(
 187             typename reverse_fold_impl::expr_param e
 188           , typename reverse_fold_impl::state_param s
 189           , typename reverse_fold_impl::data_param d
 190         ) const
 191         {
 192             state5 s5 =
 193                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 194             state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 195             return s0;
 196         }
 197     };
 198     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 199     struct fold_impl<State0, Fun, Expr, State, Data, 6>
 200       : transform_impl<Expr, State, Data>
 201     {
 202         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
 203         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6;
 204         typedef state6 result_type;
 205         result_type operator ()(
 206             typename fold_impl::expr_param e
 207           , typename fold_impl::state_param s
 208           , typename fold_impl::data_param d
 209         ) const
 210         {
 211             state0 s0 =
 212                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 213             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d );
 214             return s6;
 215         }
 216     };
 217     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 218     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 6>
 219       : transform_impl<Expr, State, Data>
 220     {
 221         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state6;
 222         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 223         typedef state0 result_type;
 224         result_type operator ()(
 225             typename reverse_fold_impl::expr_param e
 226           , typename reverse_fold_impl::state_param s
 227           , typename reverse_fold_impl::data_param d
 228         ) const
 229         {
 230             state6 s6 =
 231                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 232             state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 233             return s0;
 234         }
 235     };
 236     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 237     struct fold_impl<State0, Fun, Expr, State, Data, 7>
 238       : transform_impl<Expr, State, Data>
 239     {
 240         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
 241         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7;
 242         typedef state7 result_type;
 243         result_type operator ()(
 244             typename fold_impl::expr_param e
 245           , typename fold_impl::state_param s
 246           , typename fold_impl::data_param d
 247         ) const
 248         {
 249             state0 s0 =
 250                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 251             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d );
 252             return s7;
 253         }
 254     };
 255     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 256     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 7>
 257       : transform_impl<Expr, State, Data>
 258     {
 259         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state7;
 260         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 261         typedef state0 result_type;
 262         result_type operator ()(
 263             typename reverse_fold_impl::expr_param e
 264           , typename reverse_fold_impl::state_param s
 265           , typename reverse_fold_impl::data_param d
 266         ) const
 267         {
 268             state7 s7 =
 269                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 270             state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 271             return s0;
 272         }
 273     };
 274     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 275     struct fold_impl<State0, Fun, Expr, State, Data, 8>
 276       : transform_impl<Expr, State, Data>
 277     {
 278         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
 279         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8;
 280         typedef state8 result_type;
 281         result_type operator ()(
 282             typename fold_impl::expr_param e
 283           , typename fold_impl::state_param s
 284           , typename fold_impl::data_param d
 285         ) const
 286         {
 287             state0 s0 =
 288                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 289             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d );
 290             return s8;
 291         }
 292     };
 293     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 294     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 8>
 295       : transform_impl<Expr, State, Data>
 296     {
 297         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state8;
 298         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 299         typedef state0 result_type;
 300         result_type operator ()(
 301             typename reverse_fold_impl::expr_param e
 302           , typename reverse_fold_impl::state_param s
 303           , typename reverse_fold_impl::data_param d
 304         ) const
 305         {
 306             state8 s8 =
 307                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 308             state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 309             return s0;
 310         }
 311     };
 312     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 313     struct fold_impl<State0, Fun, Expr, State, Data, 9>
 314       : transform_impl<Expr, State, Data>
 315     {
 316         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
 317         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9;
 318         typedef state9 result_type;
 319         result_type operator ()(
 320             typename fold_impl::expr_param e
 321           , typename fold_impl::state_param s
 322           , typename fold_impl::data_param d
 323         ) const
 324         {
 325             state0 s0 =
 326                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 327             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d );
 328             return s9;
 329         }
 330     };
 331     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 332     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 9>
 333       : transform_impl<Expr, State, Data>
 334     {
 335         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state9;
 336         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 337         typedef state0 result_type;
 338         result_type operator ()(
 339             typename reverse_fold_impl::expr_param e
 340           , typename reverse_fold_impl::state_param s
 341           , typename reverse_fold_impl::data_param d
 342         ) const
 343         {
 344             state9 s9 =
 345                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 346             state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 347             return s0;
 348         }
 349     };
 350     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 351     struct fold_impl<State0, Fun, Expr, State, Data, 10>
 352       : transform_impl<Expr, State, Data>
 353     {
 354         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
 355         typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >::result_type state10;
 356         typedef state10 result_type;
 357         result_type operator ()(
 358             typename fold_impl::expr_param e
 359           , typename fold_impl::state_param s
 360           , typename fold_impl::data_param d
 361         ) const
 362         {
 363             state0 s0 =
 364                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 365             state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); state10 s10 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >()( proto::child_c< 9>(e) , s9 , d );
 366             return s10;
 367         }
 368     };
 369     template<typename State0, typename Fun, typename Expr, typename State, typename Data>
 370     struct reverse_fold_impl<State0, Fun, Expr, State, Data, 10>
 371       : transform_impl<Expr, State, Data>
 372     {
 373         typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state10;
 374         typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
 375         typedef state0 result_type;
 376         result_type operator ()(
 377             typename reverse_fold_impl::expr_param e
 378           , typename reverse_fold_impl::state_param s
 379           , typename reverse_fold_impl::data_param d
 380         ) const
 381         {
 382             state10 s10 =
 383                 typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
 384             state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >()( proto::child_c<9>(e) , s10 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
 385             return s0;
 386         }
 387     };