]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | }; |