← Back to branch summary

~ubuntu-branches/ubuntu/breezy/aqsis/breezy

« back to all changes in this revision

Viewing changes to boost/boost/mpl/aux_/preprocessed/msvc60/iter_fold_backward_impl.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Will Newton
  • Date: 2004-12-07 20:06:49 UTC
  • Revision ID: james.westby@ubuntu.com-20041207200649-fccswkrvp4oc8lmn
Tags: upstream-0.9.3
Import upstream version 0.9.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/boost/mpl/aux_/preprocessed/msvc60/iter_fold_backward_impl.hpp
 
1
// preprocessed version of 'boost/mpl/aux_/iter_fold_backward_impl.hpp' header
 
2
// see the original for copyright information
 
3
 
 
4
namespace boost {
 
5
namespace mpl {
 
6
namespace aux {
 
7
 
 
8
// forward declaration
 
9
template<
 
10
      nttp_long N
 
11
    , typename First
 
12
    , typename Last
 
13
    , typename State
 
14
    , typename BackwardOp
 
15
    , typename ForwardOp
 
16
    > 
 
17
struct iter_fold_backward_impl;
 
18
 
 
19
template< nttp_long N >
 
20
struct iter_fold_backward_chunk;
 
21
 
 
22
template<>
 
23
struct iter_fold_backward_chunk<0>
 
24
{
 
25
    template<
 
26
          typename First
 
27
        , typename Last
 
28
        , typename State
 
29
        , typename BackwardOp
 
30
        , typename ForwardOp
 
31
        >
 
32
    struct result_
 
33
    {
 
34
        typedef First iter0;
 
35
        typedef State fwd_state0;
 
36
        typedef fwd_state0 bkwd_state0;
 
37
        typedef bkwd_state0 state;
 
38
        typedef iter0 iterator;
 
39
    };
 
40
 
 
41
    // ETI workaround
 
42
    template<> struct result_<int, int, int, int, int>
 
43
    {
 
44
        typedef int state;
 
45
        typedef int iterator;
 
46
    };
 
47
 
 
48
};
 
49
 
 
50
template<>
 
51
struct iter_fold_backward_chunk<1>
 
52
{
 
53
    template<
 
54
          typename First
 
55
        , typename Last
 
56
        , typename State
 
57
        , typename BackwardOp
 
58
        , typename ForwardOp
 
59
        >
 
60
    struct result_
 
61
    {
 
62
        typedef First iter0;
 
63
        typedef State fwd_state0;
 
64
        typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
 
65
        typedef typename iter0::next iter1;
 
66
        
 
67
 
 
68
        typedef fwd_state1 bkwd_state1;
 
69
        typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
 
70
        typedef bkwd_state0 state;
 
71
        typedef iter1 iterator;
 
72
    };
 
73
 
 
74
    // ETI workaround
 
75
    template<> struct result_<int, int, int, int, int>
 
76
    {
 
77
        typedef int state;
 
78
        typedef int iterator;
 
79
    };
 
80
 
 
81
};
 
82
 
 
83
template<>
 
84
struct iter_fold_backward_chunk<2>
 
85
{
 
86
    template<
 
87
          typename First
 
88
        , typename Last
 
89
        , typename State
 
90
        , typename BackwardOp
 
91
        , typename ForwardOp
 
92
        >
 
93
    struct result_
 
94
    {
 
95
        typedef First iter0;
 
96
        typedef State fwd_state0;
 
97
        typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
 
98
        typedef typename iter0::next iter1;
 
99
        typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
 
100
        typedef typename iter1::next iter2;
 
101
        
 
102
 
 
103
        typedef fwd_state2 bkwd_state2;
 
104
        typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
 
105
        typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
 
106
        
 
107
 
 
108
        typedef bkwd_state0 state;
 
109
        typedef iter2 iterator;
 
110
    };
 
111
 
 
112
    // ETI workaround
 
113
    template<> struct result_<int, int, int, int, int>
 
114
    {
 
115
        typedef int state;
 
116
        typedef int iterator;
 
117
    };
 
118
 
 
119
};
 
120
 
 
121
template<>
 
122
struct iter_fold_backward_chunk<3>
 
123
{
 
124
    template<
 
125
          typename First
 
126
        , typename Last
 
127
        , typename State
 
128
        , typename BackwardOp
 
129
        , typename ForwardOp
 
130
        >
 
131
    struct result_
 
132
    {
 
133
        typedef First iter0;
 
134
        typedef State fwd_state0;
 
135
        typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
 
136
        typedef typename iter0::next iter1;
 
137
        typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
 
138
        typedef typename iter1::next iter2;
 
139
        typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
 
140
        typedef typename iter2::next iter3;
 
141
        
 
142
 
 
143
        typedef fwd_state3 bkwd_state3;
 
144
        typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
 
145
        typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
 
146
        typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
 
147
        
 
148
 
 
149
        typedef bkwd_state0 state;
 
150
        typedef iter3 iterator;
 
151
    };
 
152
 
 
153
    // ETI workaround
 
154
    template<> struct result_<int, int, int, int, int>
 
155
    {
 
156
        typedef int state;
 
157
        typedef int iterator;
 
158
    };
 
159
 
 
160
};
 
161
 
 
162
template<>
 
163
struct iter_fold_backward_chunk<4>
 
164
{
 
165
    template<
 
166
          typename First
 
167
        , typename Last
 
168
        , typename State
 
169
        , typename BackwardOp
 
170
        , typename ForwardOp
 
171
        >
 
172
    struct result_
 
173
    {
 
174
        typedef First iter0;
 
175
        typedef State fwd_state0;
 
176
        typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
 
177
        typedef typename iter0::next iter1;
 
178
        typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
 
179
        typedef typename iter1::next iter2;
 
180
        typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
 
181
        typedef typename iter2::next iter3;
 
182
        typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
 
183
        typedef typename iter3::next iter4;
 
184
        
 
185
 
 
186
        typedef fwd_state4 bkwd_state4;
 
187
        typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
 
188
        typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
 
189
        typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
 
190
        typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
 
191
        
 
192
 
 
193
        typedef bkwd_state0 state;
 
194
        typedef iter4 iterator;
 
195
    };
 
196
 
 
197
    // ETI workaround
 
198
    template<> struct result_<int, int, int, int, int>
 
199
    {
 
200
        typedef int state;
 
201
        typedef int iterator;
 
202
    };
 
203
 
 
204
};
 
205
 
 
206
template< nttp_long N > 
 
207
struct iter_fold_backward_chunk
 
208
{
 
209
    template<
 
210
          typename First
 
211
        , typename Last
 
212
        , typename State
 
213
        , typename BackwardOp
 
214
        , typename ForwardOp
 
215
        > 
 
216
    struct result_
 
217
    {
 
218
        typedef First iter0;
 
219
        typedef State fwd_state0;
 
220
        typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
 
221
        typedef typename iter0::next iter1;
 
222
        typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
 
223
        typedef typename iter1::next iter2;
 
224
        typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
 
225
        typedef typename iter2::next iter3;
 
226
        typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
 
227
        typedef typename iter3::next iter4;
 
228
        
 
229
 
 
230
        typedef iter_fold_backward_impl<
 
231
              ( (N - 4) < 0 ? 0 : N - 4 )
 
232
            , iter4
 
233
            , Last
 
234
            , fwd_state4
 
235
            , BackwardOp
 
236
            , ForwardOp
 
237
            > nested_chunk;
 
238
            
 
239
        typedef typename nested_chunk::state bkwd_state4;
 
240
        typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
 
241
        typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
 
242
        typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
 
243
        typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
 
244
        
 
245
 
 
246
        typedef bkwd_state0 state;
 
247
        typedef typename nested_chunk::iterator iterator;
 
248
    };
 
249
};
 
250
 
 
251
template<
 
252
      typename First
 
253
    , typename Last
 
254
    , typename State
 
255
    , typename BackwardOp
 
256
    , typename ForwardOp
 
257
    > 
 
258
struct iter_fold_backward_step;
 
259
 
 
260
template<
 
261
      typename Last
 
262
    , typename State
 
263
    >
 
264
struct iter_fold_backward_null_step
 
265
{
 
266
    typedef Last iterator;
 
267
    typedef State state;
 
268
};
 
269
 
 
270
template<> 
 
271
struct iter_fold_backward_chunk< -1 >
 
272
{
 
273
    template<
 
274
          typename First
 
275
        , typename Last
 
276
        , typename State
 
277
        , typename BackwardOp
 
278
        , typename ForwardOp
 
279
        > 
 
280
    struct result_
 
281
    {
 
282
        typedef typename if_<
 
283
              typename is_same< First,Last >::type
 
284
            , iter_fold_backward_null_step< Last,State >
 
285
            , iter_fold_backward_step< First,Last,State,BackwardOp,ForwardOp >
 
286
            >::type res_;
 
287
 
 
288
        typedef typename res_::state state;
 
289
        typedef typename res_::iterator iterator;
 
290
    };
 
291
 
 
292
    // ETI workaround
 
293
    template<> struct result_<int, int, int, int, int>
 
294
    {
 
295
        typedef int state;
 
296
        typedef int iterator;
 
297
    };
 
298
 
 
299
};
 
300
 
 
301
template<
 
302
      typename First
 
303
    , typename Last
 
304
    , typename State
 
305
    , typename BackwardOp
 
306
    , typename ForwardOp
 
307
    > 
 
308
struct iter_fold_backward_step
 
309
{
 
310
    typedef iter_fold_backward_chunk< -1 >::template result_<
 
311
          typename First::next
 
312
        , Last
 
313
        , typename apply2< ForwardOp,State,First >::type
 
314
        , BackwardOp
 
315
        , ForwardOp
 
316
        > nested_step;
 
317
 
 
318
    typedef typename apply2<BackwardOp, typename nested_step::state, First>::type state;
 
319
    typedef typename nested_step::iterator iterator;
 
320
};
 
321
 
 
322
template<
 
323
      nttp_long N
 
324
    , typename First
 
325
    , typename Last
 
326
    , typename State
 
327
    , typename BackwardOp
 
328
    , typename ForwardOp
 
329
    > 
 
330
struct iter_fold_backward_impl
 
331
    : iter_fold_backward_chunk<N>
 
332
        ::template result_< First,Last,State,BackwardOp,ForwardOp >
 
333
{
 
334
};
 
335
 
 
336
} // namespace aux
 
337
} // namespace mpl
 
338
} // namespace boost
 
339