|
1 |
|
2 // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! |
|
3 |
|
4 #if !defined(BOOST_PP_IS_ITERATING) |
|
5 |
|
6 // Copyright Aleksey Gurtovoy 2000-2004 |
|
7 // |
|
8 // Distributed under the Boost Software License, Version 1.0. |
|
9 // (See accompanying file LICENSE_1_0.txt or copy at |
|
10 // http://www.boost.org/LICENSE_1_0.txt) |
|
11 // |
|
12 // See http://www.boost.org/libs/mpl for documentation. |
|
13 |
|
14 // $Source: /cvsroot/boost/boost/boost/mpl/aux_/reverse_fold_impl_body.hpp,v $ |
|
15 // $Date: 2004/10/24 08:18:03 $ |
|
16 // $Revision: 1.3 $ |
|
17 |
|
18 # include <boost/mpl/limits/unrolling.hpp> |
|
19 # include <boost/mpl/aux_/preprocessor/repeat.hpp> |
|
20 # include <boost/mpl/aux_/config/ctps.hpp> |
|
21 # include <boost/mpl/aux_/nttp_decl.hpp> |
|
22 |
|
23 # include <boost/preprocessor/arithmetic/sub.hpp> |
|
24 # include <boost/preprocessor/iterate.hpp> |
|
25 # include <boost/preprocessor/dec.hpp> |
|
26 # include <boost/preprocessor/inc.hpp> |
|
27 # include <boost/preprocessor/cat.hpp> |
|
28 |
|
29 // local macros, #undef-ined at the end of the header |
|
30 |
|
31 # define AUX778076_ITER_FOLD_FORWARD_STEP(unused, n_, unused2) \ |
|
32 typedef typename apply2< \ |
|
33 ForwardOp \ |
|
34 , BOOST_PP_CAT(fwd_state,n_) \ |
|
35 , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,n_)) \ |
|
36 >::type BOOST_PP_CAT(fwd_state,BOOST_PP_INC(n_)); \ |
|
37 typedef typename mpl::next<BOOST_PP_CAT(iter,n_)>::type \ |
|
38 BOOST_PP_CAT(iter,BOOST_PP_INC(n_)); \ |
|
39 /**/ |
|
40 |
|
41 # define AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC(n_) \ |
|
42 typedef typename apply2< \ |
|
43 BackwardOp \ |
|
44 , BOOST_PP_CAT(bkwd_state,n_) \ |
|
45 , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,BOOST_PP_DEC(n_))) \ |
|
46 >::type BOOST_PP_CAT(bkwd_state,BOOST_PP_DEC(n_)); \ |
|
47 /**/ |
|
48 |
|
49 # define AUX778076_ITER_FOLD_BACKWARD_STEP(unused, n_, j) \ |
|
50 AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC( \ |
|
51 BOOST_PP_SUB_D(1,j,n_) \ |
|
52 ) \ |
|
53 /**/ |
|
54 |
|
55 # define AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(n_) \ |
|
56 typedef typename nested_chunk::state BOOST_PP_CAT(bkwd_state,n_); |
|
57 /**/ |
|
58 |
|
59 # define AUX778076_FOLD_IMPL_NAME \ |
|
60 BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \ |
|
61 /**/ |
|
62 |
|
63 # define AUX778076_FOLD_CHUNK_NAME \ |
|
64 BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \ |
|
65 /**/ |
|
66 |
|
67 namespace boost { namespace mpl { namespace aux { |
|
68 |
|
69 /// forward declaration |
|
70 template< |
|
71 BOOST_MPL_AUX_NTTP_DECL(long, N) |
|
72 , typename First |
|
73 , typename Last |
|
74 , typename State |
|
75 , typename BackwardOp |
|
76 , typename ForwardOp |
|
77 > |
|
78 struct AUX778076_FOLD_IMPL_NAME; |
|
79 |
|
80 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ |
|
81 && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) |
|
82 |
|
83 # define BOOST_PP_ITERATION_PARAMS_1 \ |
|
84 (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/reverse_fold_impl_body.hpp>)) |
|
85 # include BOOST_PP_ITERATE() |
|
86 |
|
87 // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING |
|
88 template< |
|
89 BOOST_MPL_AUX_NTTP_DECL(long, N) |
|
90 , typename First |
|
91 , typename Last |
|
92 , typename State |
|
93 , typename BackwardOp |
|
94 , typename ForwardOp |
|
95 > |
|
96 struct AUX778076_FOLD_IMPL_NAME |
|
97 { |
|
98 typedef First iter0; |
|
99 typedef State fwd_state0; |
|
100 |
|
101 BOOST_MPL_PP_REPEAT( |
|
102 BOOST_MPL_LIMIT_UNROLLING |
|
103 , AUX778076_ITER_FOLD_FORWARD_STEP |
|
104 , unused |
|
105 ) |
|
106 |
|
107 typedef AUX778076_FOLD_IMPL_NAME< |
|
108 ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) |
|
109 , BOOST_PP_CAT(iter,BOOST_MPL_LIMIT_UNROLLING) |
|
110 , Last |
|
111 , BOOST_PP_CAT(fwd_state,BOOST_MPL_LIMIT_UNROLLING) |
|
112 , BackwardOp |
|
113 , ForwardOp |
|
114 > nested_chunk; |
|
115 |
|
116 AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(BOOST_MPL_LIMIT_UNROLLING) |
|
117 |
|
118 BOOST_MPL_PP_REPEAT( |
|
119 BOOST_MPL_LIMIT_UNROLLING |
|
120 , AUX778076_ITER_FOLD_BACKWARD_STEP |
|
121 , BOOST_MPL_LIMIT_UNROLLING |
|
122 ) |
|
123 |
|
124 typedef bkwd_state0 state; |
|
125 typedef typename nested_chunk::iterator iterator; |
|
126 }; |
|
127 |
|
128 // fallback implementation for sequences of unknown size |
|
129 template< |
|
130 typename First |
|
131 , typename Last |
|
132 , typename State |
|
133 , typename BackwardOp |
|
134 , typename ForwardOp |
|
135 > |
|
136 struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,BackwardOp,ForwardOp> |
|
137 { |
|
138 typedef AUX778076_FOLD_IMPL_NAME< |
|
139 -1 |
|
140 , typename mpl::next<First>::type |
|
141 , Last |
|
142 , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type |
|
143 , BackwardOp |
|
144 , ForwardOp |
|
145 > nested_step; |
|
146 |
|
147 typedef typename apply2< |
|
148 BackwardOp |
|
149 , typename nested_step::state |
|
150 , AUX778076_FOLD_IMPL_OP(First) |
|
151 >::type state; |
|
152 |
|
153 typedef typename nested_step::iterator iterator; |
|
154 }; |
|
155 |
|
156 template< |
|
157 typename Last |
|
158 , typename State |
|
159 , typename BackwardOp |
|
160 , typename ForwardOp |
|
161 > |
|
162 struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,BackwardOp,ForwardOp> |
|
163 { |
|
164 typedef State state; |
|
165 typedef Last iterator; |
|
166 }; |
|
167 |
|
168 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
|
169 |
|
170 template< BOOST_MPL_AUX_NTTP_DECL(long, N) > |
|
171 struct AUX778076_FOLD_CHUNK_NAME; |
|
172 |
|
173 # define BOOST_PP_ITERATION_PARAMS_1 \ |
|
174 (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/reverse_fold_impl_body.hpp>)) |
|
175 # include BOOST_PP_ITERATE() |
|
176 |
|
177 // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING |
|
178 template< BOOST_MPL_AUX_NTTP_DECL(long, N) > |
|
179 struct AUX778076_FOLD_CHUNK_NAME |
|
180 { |
|
181 template< |
|
182 typename First |
|
183 , typename Last |
|
184 , typename State |
|
185 , typename BackwardOp |
|
186 , typename ForwardOp |
|
187 > |
|
188 struct result_ |
|
189 { |
|
190 typedef First iter0; |
|
191 typedef State fwd_state0; |
|
192 |
|
193 BOOST_MPL_PP_REPEAT( |
|
194 BOOST_MPL_LIMIT_UNROLLING |
|
195 , AUX778076_ITER_FOLD_FORWARD_STEP |
|
196 , unused |
|
197 ) |
|
198 |
|
199 typedef AUX778076_FOLD_IMPL_NAME< |
|
200 ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) |
|
201 , BOOST_PP_CAT(iter,BOOST_MPL_LIMIT_UNROLLING) |
|
202 , Last |
|
203 , BOOST_PP_CAT(fwd_state,BOOST_MPL_LIMIT_UNROLLING) |
|
204 , BackwardOp |
|
205 , ForwardOp |
|
206 > nested_chunk; |
|
207 |
|
208 AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(BOOST_MPL_LIMIT_UNROLLING) |
|
209 |
|
210 BOOST_MPL_PP_REPEAT( |
|
211 BOOST_MPL_LIMIT_UNROLLING |
|
212 , AUX778076_ITER_FOLD_BACKWARD_STEP |
|
213 , BOOST_MPL_LIMIT_UNROLLING |
|
214 ) |
|
215 |
|
216 typedef bkwd_state0 state; |
|
217 typedef typename nested_chunk::iterator iterator; |
|
218 }; |
|
219 }; |
|
220 |
|
221 // fallback implementation for sequences of unknown size |
|
222 template< |
|
223 typename First |
|
224 , typename Last |
|
225 , typename State |
|
226 , typename BackwardOp |
|
227 , typename ForwardOp |
|
228 > |
|
229 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step); |
|
230 |
|
231 template< |
|
232 typename Last |
|
233 , typename State |
|
234 > |
|
235 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) |
|
236 { |
|
237 typedef Last iterator; |
|
238 typedef State state; |
|
239 }; |
|
240 |
|
241 template<> |
|
242 struct AUX778076_FOLD_CHUNK_NAME<-1> |
|
243 { |
|
244 template< |
|
245 typename First |
|
246 , typename Last |
|
247 , typename State |
|
248 , typename BackwardOp |
|
249 , typename ForwardOp |
|
250 > |
|
251 struct result_ |
|
252 { |
|
253 typedef typename if_< |
|
254 typename is_same<First,Last>::type |
|
255 , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step)<Last,State> |
|
256 , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step)<First,Last,State,BackwardOp,ForwardOp> |
|
257 >::type res_; |
|
258 |
|
259 typedef typename res_::state state; |
|
260 typedef typename res_::iterator iterator; |
|
261 }; |
|
262 |
|
263 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) |
|
264 /// ETI workaround |
|
265 template<> struct result_<int,int,int,int,int> |
|
266 { |
|
267 typedef int state; |
|
268 typedef int iterator; |
|
269 }; |
|
270 #endif |
|
271 }; |
|
272 |
|
273 template< |
|
274 typename First |
|
275 , typename Last |
|
276 , typename State |
|
277 , typename BackwardOp |
|
278 , typename ForwardOp |
|
279 > |
|
280 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) |
|
281 { |
|
282 typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_< |
|
283 typename mpl::next<First>::type |
|
284 , Last |
|
285 , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type |
|
286 , BackwardOp |
|
287 , ForwardOp |
|
288 > nested_step; |
|
289 |
|
290 typedef typename apply2< |
|
291 BackwardOp |
|
292 , typename nested_step::state |
|
293 , AUX778076_FOLD_IMPL_OP(First) |
|
294 >::type state; |
|
295 |
|
296 typedef typename nested_step::iterator iterator; |
|
297 }; |
|
298 |
|
299 template< |
|
300 BOOST_MPL_AUX_NTTP_DECL(long, N) |
|
301 , typename First |
|
302 , typename Last |
|
303 , typename State |
|
304 , typename BackwardOp |
|
305 , typename ForwardOp |
|
306 > |
|
307 struct AUX778076_FOLD_IMPL_NAME |
|
308 : AUX778076_FOLD_CHUNK_NAME<N> |
|
309 ::template result_<First,Last,State,BackwardOp,ForwardOp> |
|
310 { |
|
311 }; |
|
312 |
|
313 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
|
314 |
|
315 }}} |
|
316 |
|
317 # undef AUX778076_FIRST_BACKWARD_STATE_TYPEDEF |
|
318 # undef AUX778076_ITER_FOLD_BACKWARD_STEP |
|
319 # undef AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC |
|
320 # undef AUX778076_ITER_FOLD_FORWARD_STEP |
|
321 |
|
322 #undef AUX778076_FOLD_IMPL_OP |
|
323 #undef AUX778076_FOLD_IMPL_NAME_PREFIX |
|
324 |
|
325 ///// iteration |
|
326 |
|
327 #else |
|
328 |
|
329 # define n_ BOOST_PP_FRAME_ITERATION(1) |
|
330 |
|
331 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ |
|
332 && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) |
|
333 |
|
334 template< |
|
335 typename First |
|
336 , typename Last |
|
337 , typename State |
|
338 , typename BackwardOp |
|
339 , typename ForwardOp |
|
340 > |
|
341 struct AUX778076_FOLD_IMPL_NAME<n_,First,Last,State,BackwardOp,ForwardOp> |
|
342 { |
|
343 typedef First iter0; |
|
344 typedef State fwd_state0; |
|
345 |
|
346 BOOST_MPL_PP_REPEAT( |
|
347 n_ |
|
348 , AUX778076_ITER_FOLD_FORWARD_STEP |
|
349 , unused |
|
350 ) |
|
351 |
|
352 typedef BOOST_PP_CAT(fwd_state,n_) BOOST_PP_CAT(bkwd_state,n_); |
|
353 |
|
354 BOOST_MPL_PP_REPEAT( |
|
355 n_ |
|
356 , AUX778076_ITER_FOLD_BACKWARD_STEP |
|
357 , n_ |
|
358 ) |
|
359 |
|
360 typedef bkwd_state0 state; |
|
361 typedef BOOST_PP_CAT(iter,n_) iterator; |
|
362 }; |
|
363 |
|
364 #else |
|
365 |
|
366 template<> struct AUX778076_FOLD_CHUNK_NAME<n_> |
|
367 { |
|
368 template< |
|
369 typename First |
|
370 , typename Last |
|
371 , typename State |
|
372 , typename BackwardOp |
|
373 , typename ForwardOp |
|
374 > |
|
375 struct result_ |
|
376 { |
|
377 typedef First iter0; |
|
378 typedef State fwd_state0; |
|
379 |
|
380 BOOST_MPL_PP_REPEAT( |
|
381 n_ |
|
382 , AUX778076_ITER_FOLD_FORWARD_STEP |
|
383 , unused |
|
384 ) |
|
385 |
|
386 typedef BOOST_PP_CAT(fwd_state,n_) BOOST_PP_CAT(bkwd_state,n_); |
|
387 |
|
388 BOOST_MPL_PP_REPEAT( |
|
389 n_ |
|
390 , AUX778076_ITER_FOLD_BACKWARD_STEP |
|
391 , n_ |
|
392 ) |
|
393 |
|
394 typedef bkwd_state0 state; |
|
395 typedef BOOST_PP_CAT(iter,n_) iterator; |
|
396 }; |
|
397 |
|
398 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) |
|
399 /// ETI workaround |
|
400 template<> struct result_<int,int,int,int,int> |
|
401 { |
|
402 typedef int state; |
|
403 typedef int iterator; |
|
404 }; |
|
405 #endif |
|
406 }; |
|
407 |
|
408 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
|
409 |
|
410 # undef n_ |
|
411 |
|
412 #endif // BOOST_PP_IS_ITERATING |