Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / mpl / aux_ / fold_impl_body.hpp
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_/fold_impl_body.hpp,v $
15 // $Date: 2004/10/24 08:18:03 $
16 // $Revision: 1.8 $
17
18 #   include <boost/mpl/limits/unrolling.hpp>
19 #   include <boost/mpl/aux_/preprocessor/repeat.hpp>
20 #   include <boost/mpl/aux_/config/workaround.hpp>
21 #   include <boost/mpl/aux_/config/ctps.hpp>
22 #   include <boost/mpl/aux_/nttp_decl.hpp>
23 #   include <boost/mpl/aux_/config/eti.hpp>
24
25 #   include <boost/preprocessor/iterate.hpp>
26 #   include <boost/preprocessor/dec.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_STEP(unused, i, unused2) \
32     typedef typename apply2< \
33           ForwardOp \
34         , BOOST_PP_CAT(state,i) \
35         , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,i)) \
36         >::type BOOST_PP_CAT(state,BOOST_PP_INC(i)); \
37     typedef typename mpl::next<BOOST_PP_CAT(iter,i)>::type \
38         BOOST_PP_CAT(iter,BOOST_PP_INC(i)); \
39     /**/
40
41 #   define AUX778076_FOLD_IMPL_NAME \
42     BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \
43     /**/
44
45 #   define AUX778076_FOLD_CHUNK_NAME \
46     BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \
47     /**/
48
49 namespace boost { namespace mpl { namespace aux {
50
51 /// forward declaration
52 template<
53       BOOST_MPL_AUX_NTTP_DECL(int, N)
54     , typename First
55     , typename Last
56     , typename State
57     , typename ForwardOp
58     > 
59 struct AUX778076_FOLD_IMPL_NAME;
60
61 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
62
63 #   if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
64
65 #   define BOOST_PP_ITERATION_PARAMS_1 \
66     (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/fold_impl_body.hpp>))
67 #   include BOOST_PP_ITERATE()
68
69 // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
70 template<
71       BOOST_MPL_AUX_NTTP_DECL(int, N)
72     , typename First
73     , typename Last
74     , typename State
75     , typename ForwardOp
76     > 
77 struct AUX778076_FOLD_IMPL_NAME
78 {
79     typedef AUX778076_FOLD_IMPL_NAME<
80           BOOST_MPL_LIMIT_UNROLLING
81         , First
82         , Last
83         , State
84         , ForwardOp
85         > chunk_;
86
87     typedef AUX778076_FOLD_IMPL_NAME<
88           ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )
89         , typename chunk_::iterator
90         , Last
91         , typename chunk_::state
92         , ForwardOp
93         > res_;
94         
95     typedef typename res_::state state;
96     typedef typename res_::iterator iterator;
97 };
98
99 // fallback implementation for sequences of unknown size
100 template<
101       typename First
102     , typename Last
103     , typename State
104     , typename ForwardOp
105     > 
106 struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,ForwardOp>
107     : AUX778076_FOLD_IMPL_NAME<
108           -1
109         , typename mpl::next<First>::type
110         , Last
111         , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
112         , ForwardOp
113         >
114 {
115 };
116
117 template<
118       typename Last
119     , typename State
120     , typename ForwardOp
121     > 
122 struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,ForwardOp>
123 {
124     typedef State state;
125     typedef Last iterator;
126 };
127
128 #   else // BOOST_WORKAROUND(__BORLANDC__, < 0x600)
129
130 // Borland have some serious problems with the unrolled version, so
131 // we always use a basic implementation
132 template<
133       BOOST_MPL_AUX_NTTP_DECL(int, N)
134     , typename First
135     , typename Last
136     , typename State
137     , typename ForwardOp
138     > 
139 struct AUX778076_FOLD_IMPL_NAME
140 {
141     typedef AUX778076_FOLD_IMPL_NAME<
142           -1
143         , typename mpl::next<First>::type
144         , Last
145         , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
146         , ForwardOp
147         > res_;
148
149     typedef typename res_::state state;
150     typedef typename res_::iterator iterator;
151     typedef state type;
152 };
153
154 template<
155       BOOST_MPL_AUX_NTTP_DECL(int, N)
156      , typename Last
157     , typename State
158     , typename ForwardOp
159     > 
160 struct AUX778076_FOLD_IMPL_NAME<N,Last,Last,State,ForwardOp >
161 {
162     typedef State state;
163     typedef Last iterator;
164     typedef state type;
165 };
166
167 #   endif // BOOST_WORKAROUND(__BORLANDC__, < 0x600)
168  
169 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
170
171 template< BOOST_MPL_AUX_NTTP_DECL(int, N) >
172 struct AUX778076_FOLD_CHUNK_NAME;
173
174 #   define BOOST_PP_ITERATION_PARAMS_1 \
175     (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/fold_impl_body.hpp>))
176 #   include BOOST_PP_ITERATE()
177
178 // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
179 template< BOOST_MPL_AUX_NTTP_DECL(int, N) > 
180 struct AUX778076_FOLD_CHUNK_NAME
181 {
182     template<
183           typename First
184         , typename Last
185         , typename State
186         , typename ForwardOp
187         > 
188     struct result_
189     {
190         typedef AUX778076_FOLD_IMPL_NAME<
191               BOOST_MPL_LIMIT_UNROLLING
192             , First
193             , Last
194             , State
195             , ForwardOp
196             > chunk_;
197
198         typedef AUX778076_FOLD_IMPL_NAME<
199               ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )
200             , typename chunk_::iterator
201             , Last
202             , typename chunk_::state
203             , ForwardOp
204             > res_;
205
206         typedef typename res_::state state;
207         typedef typename res_::iterator iterator;
208     };
209 };
210
211 // fallback implementation for sequences of unknown size
212 template<
213       typename First
214     , typename Last
215     , typename State
216     , typename ForwardOp
217     > 
218 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step);
219
220 template<
221       typename Last
222     , typename State
223     >
224 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step)
225 {
226     typedef Last iterator;
227     typedef State state;
228 };
229
230 template<> 
231 struct AUX778076_FOLD_CHUNK_NAME<-1>
232 {
233     template<
234           typename First
235         , typename Last
236         , typename State
237         , typename ForwardOp
238         > 
239     struct result_
240     {
241         typedef typename if_<
242               typename is_same<First,Last>::type
243             , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step)<Last,State>
244             , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step)<First,Last,State,ForwardOp>
245             >::type res_;
246
247         typedef typename res_::state state;
248         typedef typename res_::iterator iterator;
249     };
250
251 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
252     /// ETI workaround
253     template<> struct result_<int,int,int,int>
254     {
255         typedef int state;
256         typedef int iterator;
257     };
258 #endif
259 };
260
261 template<
262       typename First
263     , typename Last
264     , typename State
265     , typename ForwardOp
266     > 
267 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step)
268 {
269     // can't inherit here - it breaks MSVC 7.0
270     typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_<
271           typename mpl::next<First>::type
272         , Last
273         , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
274         , ForwardOp
275         > chunk_;
276
277     typedef typename chunk_::state state;
278     typedef typename chunk_::iterator iterator;
279 };
280
281 template<
282       BOOST_MPL_AUX_NTTP_DECL(int, N)
283     , typename First
284     , typename Last
285     , typename State
286     , typename ForwardOp
287     > 
288 struct AUX778076_FOLD_IMPL_NAME
289     : AUX778076_FOLD_CHUNK_NAME<N>
290         ::template result_<First,Last,State,ForwardOp>
291 {
292 };
293
294 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
295
296 }}}
297
298 #   undef AUX778076_FOLD_IMPL_NAME
299 #   undef AUX778076_FOLD_CHUNK_NAME
300 #   undef AUX778076_ITER_FOLD_STEP
301
302 #undef AUX778076_FOLD_IMPL_OP
303 #undef AUX778076_FOLD_IMPL_NAME_PREFIX
304
305 ///// iteration
306
307 #else
308
309 #   define n_ BOOST_PP_FRAME_ITERATION(1)
310
311 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
312
313 template<
314       typename First
315     , typename Last
316     , typename State
317     , typename ForwardOp
318     >
319 struct AUX778076_FOLD_IMPL_NAME<n_,First,Last,State,ForwardOp>
320 {
321     typedef First iter0;
322     typedef State state0;
323
324     BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused)
325
326     typedef BOOST_PP_CAT(state,n_) state;
327     typedef BOOST_PP_CAT(iter,n_) iterator;
328 };
329
330 #else
331
332 template<> struct AUX778076_FOLD_CHUNK_NAME<n_>
333 {
334     template<
335           typename First
336         , typename Last
337         , typename State
338         , typename ForwardOp
339         >
340     struct result_
341     {
342         typedef First iter0;
343         typedef State state0;
344
345         BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused)
346
347         typedef BOOST_PP_CAT(state,n_) state;
348         typedef BOOST_PP_CAT(iter,n_) iterator;
349     };
350
351 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
352     /// ETI workaround
353     template<> struct result_<int,int,int,int>
354     {
355         typedef int state;
356         typedef int iterator;
357     };
358 #endif
359 };
360
361 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
362
363 #   undef n_
364
365 #endif // BOOST_PP_IS_ITERATING