← Back to branch summary

~ubuntu-branches/ubuntu/warty/aqsis/warty

« back to all changes in this revision

Viewing changes to boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2004-08-24 07:25:04 UTC
  • Revision ID: james.westby@ubuntu.com-20040824072504-zf993vnevvisdsvb
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp
 
1
// preprocessed version of 'boost/mpl/vector/vector20.hpp' header
 
2
// see the original for copyright information
 
3
 
 
4
namespace boost {
 
5
namespace mpl {
 
6
 
 
7
template<
 
8
      typename T0, typename T1, typename T2, typename T3, typename T4
 
9
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
10
    , typename T10
 
11
    >
 
12
struct vector11
 
13
{
 
14
    typedef aux::vector_tag<11> tag;
 
15
    typedef vector11 type;
 
16
    typedef T0 item0;
 
17
    typedef T1 item1;
 
18
    typedef T2 item2;
 
19
    typedef T3 item3;
 
20
    typedef T4 item4;
 
21
    typedef T5 item5;
 
22
    typedef T6 item6;
 
23
    typedef T7 item7;
 
24
    typedef T8 item8;
 
25
    typedef T9 item9;
 
26
    typedef T10 item10;
 
27
    
 
28
 
 
29
    typedef void_ item11;
 
30
    typedef T10 back;
 
31
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
32
    typedef vector_iterator< type,integral_c<long,11> > end;
 
33
};
 
34
 
 
35
template<>
 
36
struct push_front_traits< aux::vector_tag< 10> >
 
37
{
 
38
    template< typename Vector, typename T > struct algorithm
 
39
    {
 
40
        typedef vector11<
 
41
              T
 
42
              ,
 
43
              typename Vector::item0, typename Vector::item1
 
44
            , typename Vector::item2, typename Vector::item3
 
45
            , typename Vector::item4, typename Vector::item5
 
46
            , typename Vector::item6, typename Vector::item7
 
47
            , typename Vector::item8, typename Vector::item9
 
48
            > type;
 
49
    };
 
50
};
 
51
 
 
52
template<>
 
53
struct pop_front_traits< aux::vector_tag< 11> >
 
54
{
 
55
    template< typename Vector > struct algorithm
 
56
    {
 
57
        typedef vector10<
 
58
              typename Vector::item1, typename Vector::item2
 
59
            , typename Vector::item3, typename Vector::item4
 
60
            , typename Vector::item5, typename Vector::item6
 
61
            , typename Vector::item7, typename Vector::item8
 
62
            , typename Vector::item9, typename Vector::item10
 
63
            > type;
 
64
    };
 
65
};
 
66
 
 
67
namespace aux {
 
68
template<> struct vector_item_impl<11>
 
69
{
 
70
    template< typename V > struct result_
 
71
    {
 
72
        typedef typename V::item11 type;
 
73
    };
 
74
};
 
75
}
 
76
 
 
77
template<>
 
78
struct at_traits< aux::vector_tag< 11> >
 
79
{
 
80
    template< typename V, typename N > struct algorithm
 
81
    {
 
82
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
83
            ::template result_<V>::type type;
 
84
    };
 
85
};
 
86
 
 
87
template<>
 
88
struct front_traits< aux::vector_tag< 11> >
 
89
{
 
90
    template< typename Vector > struct algorithm
 
91
    {
 
92
        typedef typename Vector::item0 type;
 
93
    };
 
94
};
 
95
 
 
96
template<>
 
97
struct back_traits< aux::vector_tag< 11> >
 
98
{
 
99
    template< typename Vector > struct algorithm
 
100
    {
 
101
        typedef typename Vector::back type;
 
102
    };
 
103
};
 
104
 
 
105
template<>
 
106
struct empty_traits< aux::vector_tag< 11> >
 
107
{
 
108
    template< typename Vector > struct algorithm
 
109
        : false_
 
110
    {
 
111
    };
 
112
};
 
113
 
 
114
template<>
 
115
struct size_traits< aux::vector_tag< 11> >
 
116
{
 
117
    template< typename Vector > struct algorithm
 
118
        : integral_c< int,11 >
 
119
    {
 
120
    };
 
121
};
 
122
 
 
123
template<>
 
124
struct O1_size_traits< aux::vector_tag< 11> >
 
125
    : size_traits< aux::vector_tag< 11> >
 
126
{
 
127
};
 
128
 
 
129
template<>
 
130
struct clear_traits< aux::vector_tag< 11> >
 
131
{
 
132
    template< typename Vector > struct algorithm
 
133
    {
 
134
        typedef vector0<> type;
 
135
    };
 
136
};
 
137
 
 
138
template<
 
139
      typename T0, typename T1, typename T2, typename T3, typename T4
 
140
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
141
    , typename T10, typename T11
 
142
    >
 
143
struct vector12
 
144
{
 
145
    typedef aux::vector_tag<12> tag;
 
146
    typedef vector12 type;
 
147
    typedef T0 item0;
 
148
    typedef T1 item1;
 
149
    typedef T2 item2;
 
150
    typedef T3 item3;
 
151
    typedef T4 item4;
 
152
    typedef T5 item5;
 
153
    typedef T6 item6;
 
154
    typedef T7 item7;
 
155
    typedef T8 item8;
 
156
    typedef T9 item9;
 
157
    typedef T10 item10;
 
158
    typedef T11 item11;
 
159
    
 
160
 
 
161
    typedef void_ item12;
 
162
    typedef T11 back;
 
163
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
164
    typedef vector_iterator< type,integral_c<long,12> > end;
 
165
};
 
166
 
 
167
template<>
 
168
struct push_front_traits< aux::vector_tag< 11> >
 
169
{
 
170
    template< typename Vector, typename T > struct algorithm
 
171
    {
 
172
        typedef vector12<
 
173
              T
 
174
              ,
 
175
              typename Vector::item0, typename Vector::item1
 
176
            , typename Vector::item2, typename Vector::item3
 
177
            , typename Vector::item4, typename Vector::item5
 
178
            , typename Vector::item6, typename Vector::item7
 
179
            , typename Vector::item8, typename Vector::item9
 
180
            , typename Vector::item10
 
181
            > type;
 
182
    };
 
183
};
 
184
 
 
185
template<>
 
186
struct pop_front_traits< aux::vector_tag< 12> >
 
187
{
 
188
    template< typename Vector > struct algorithm
 
189
    {
 
190
        typedef vector11<
 
191
              typename Vector::item1, typename Vector::item2
 
192
            , typename Vector::item3, typename Vector::item4
 
193
            , typename Vector::item5, typename Vector::item6
 
194
            , typename Vector::item7, typename Vector::item8
 
195
            , typename Vector::item9, typename Vector::item10
 
196
            , typename Vector::item11
 
197
            > type;
 
198
    };
 
199
};
 
200
 
 
201
namespace aux {
 
202
template<> struct vector_item_impl<12>
 
203
{
 
204
    template< typename V > struct result_
 
205
    {
 
206
        typedef typename V::item12 type;
 
207
    };
 
208
};
 
209
}
 
210
 
 
211
template<>
 
212
struct at_traits< aux::vector_tag< 12> >
 
213
{
 
214
    template< typename V, typename N > struct algorithm
 
215
    {
 
216
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
217
            ::template result_<V>::type type;
 
218
    };
 
219
};
 
220
 
 
221
template<>
 
222
struct front_traits< aux::vector_tag< 12> >
 
223
{
 
224
    template< typename Vector > struct algorithm
 
225
    {
 
226
        typedef typename Vector::item0 type;
 
227
    };
 
228
};
 
229
 
 
230
template<>
 
231
struct back_traits< aux::vector_tag< 12> >
 
232
{
 
233
    template< typename Vector > struct algorithm
 
234
    {
 
235
        typedef typename Vector::back type;
 
236
    };
 
237
};
 
238
 
 
239
template<>
 
240
struct empty_traits< aux::vector_tag< 12> >
 
241
{
 
242
    template< typename Vector > struct algorithm
 
243
        : false_
 
244
    {
 
245
    };
 
246
};
 
247
 
 
248
template<>
 
249
struct size_traits< aux::vector_tag< 12> >
 
250
{
 
251
    template< typename Vector > struct algorithm
 
252
        : integral_c< int,12 >
 
253
    {
 
254
    };
 
255
};
 
256
 
 
257
template<>
 
258
struct O1_size_traits< aux::vector_tag< 12> >
 
259
    : size_traits< aux::vector_tag< 12> >
 
260
{
 
261
};
 
262
 
 
263
template<>
 
264
struct clear_traits< aux::vector_tag< 12> >
 
265
{
 
266
    template< typename Vector > struct algorithm
 
267
    {
 
268
        typedef vector0<> type;
 
269
    };
 
270
};
 
271
 
 
272
template<
 
273
      typename T0, typename T1, typename T2, typename T3, typename T4
 
274
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
275
    , typename T10, typename T11, typename T12
 
276
    >
 
277
struct vector13
 
278
{
 
279
    typedef aux::vector_tag<13> tag;
 
280
    typedef vector13 type;
 
281
    typedef T0 item0;
 
282
    typedef T1 item1;
 
283
    typedef T2 item2;
 
284
    typedef T3 item3;
 
285
    typedef T4 item4;
 
286
    typedef T5 item5;
 
287
    typedef T6 item6;
 
288
    typedef T7 item7;
 
289
    typedef T8 item8;
 
290
    typedef T9 item9;
 
291
    typedef T10 item10;
 
292
    typedef T11 item11;
 
293
    typedef T12 item12;
 
294
    
 
295
 
 
296
    typedef void_ item13;
 
297
    typedef T12 back;
 
298
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
299
    typedef vector_iterator< type,integral_c<long,13> > end;
 
300
};
 
301
 
 
302
template<>
 
303
struct push_front_traits< aux::vector_tag< 12> >
 
304
{
 
305
    template< typename Vector, typename T > struct algorithm
 
306
    {
 
307
        typedef vector13<
 
308
              T
 
309
              ,
 
310
              typename Vector::item0, typename Vector::item1
 
311
            , typename Vector::item2, typename Vector::item3
 
312
            , typename Vector::item4, typename Vector::item5
 
313
            , typename Vector::item6, typename Vector::item7
 
314
            , typename Vector::item8, typename Vector::item9
 
315
            , typename Vector::item10, typename Vector::item11
 
316
            > type;
 
317
    };
 
318
};
 
319
 
 
320
template<>
 
321
struct pop_front_traits< aux::vector_tag< 13> >
 
322
{
 
323
    template< typename Vector > struct algorithm
 
324
    {
 
325
        typedef vector12<
 
326
              typename Vector::item1, typename Vector::item2
 
327
            , typename Vector::item3, typename Vector::item4
 
328
            , typename Vector::item5, typename Vector::item6
 
329
            , typename Vector::item7, typename Vector::item8
 
330
            , typename Vector::item9, typename Vector::item10
 
331
            , typename Vector::item11, typename Vector::item12
 
332
            > type;
 
333
    };
 
334
};
 
335
 
 
336
namespace aux {
 
337
template<> struct vector_item_impl<13>
 
338
{
 
339
    template< typename V > struct result_
 
340
    {
 
341
        typedef typename V::item13 type;
 
342
    };
 
343
};
 
344
}
 
345
 
 
346
template<>
 
347
struct at_traits< aux::vector_tag< 13> >
 
348
{
 
349
    template< typename V, typename N > struct algorithm
 
350
    {
 
351
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
352
            ::template result_<V>::type type;
 
353
    };
 
354
};
 
355
 
 
356
template<>
 
357
struct front_traits< aux::vector_tag< 13> >
 
358
{
 
359
    template< typename Vector > struct algorithm
 
360
    {
 
361
        typedef typename Vector::item0 type;
 
362
    };
 
363
};
 
364
 
 
365
template<>
 
366
struct back_traits< aux::vector_tag< 13> >
 
367
{
 
368
    template< typename Vector > struct algorithm
 
369
    {
 
370
        typedef typename Vector::back type;
 
371
    };
 
372
};
 
373
 
 
374
template<>
 
375
struct empty_traits< aux::vector_tag< 13> >
 
376
{
 
377
    template< typename Vector > struct algorithm
 
378
        : false_
 
379
    {
 
380
    };
 
381
};
 
382
 
 
383
template<>
 
384
struct size_traits< aux::vector_tag< 13> >
 
385
{
 
386
    template< typename Vector > struct algorithm
 
387
        : integral_c< int,13 >
 
388
    {
 
389
    };
 
390
};
 
391
 
 
392
template<>
 
393
struct O1_size_traits< aux::vector_tag< 13> >
 
394
    : size_traits< aux::vector_tag< 13> >
 
395
{
 
396
};
 
397
 
 
398
template<>
 
399
struct clear_traits< aux::vector_tag< 13> >
 
400
{
 
401
    template< typename Vector > struct algorithm
 
402
    {
 
403
        typedef vector0<> type;
 
404
    };
 
405
};
 
406
 
 
407
template<
 
408
      typename T0, typename T1, typename T2, typename T3, typename T4
 
409
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
410
    , typename T10, typename T11, typename T12, typename T13
 
411
    >
 
412
struct vector14
 
413
{
 
414
    typedef aux::vector_tag<14> tag;
 
415
    typedef vector14 type;
 
416
    typedef T0 item0;
 
417
    typedef T1 item1;
 
418
    typedef T2 item2;
 
419
    typedef T3 item3;
 
420
    typedef T4 item4;
 
421
    typedef T5 item5;
 
422
    typedef T6 item6;
 
423
    typedef T7 item7;
 
424
    typedef T8 item8;
 
425
    typedef T9 item9;
 
426
    typedef T10 item10;
 
427
    typedef T11 item11;
 
428
    typedef T12 item12;
 
429
    typedef T13 item13;
 
430
    
 
431
 
 
432
    typedef void_ item14;
 
433
    typedef T13 back;
 
434
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
435
    typedef vector_iterator< type,integral_c<long,14> > end;
 
436
};
 
437
 
 
438
template<>
 
439
struct push_front_traits< aux::vector_tag< 13> >
 
440
{
 
441
    template< typename Vector, typename T > struct algorithm
 
442
    {
 
443
        typedef vector14<
 
444
              T
 
445
              ,
 
446
              typename Vector::item0, typename Vector::item1
 
447
            , typename Vector::item2, typename Vector::item3
 
448
            , typename Vector::item4, typename Vector::item5
 
449
            , typename Vector::item6, typename Vector::item7
 
450
            , typename Vector::item8, typename Vector::item9
 
451
            , typename Vector::item10, typename Vector::item11
 
452
            , typename Vector::item12
 
453
            > type;
 
454
    };
 
455
};
 
456
 
 
457
template<>
 
458
struct pop_front_traits< aux::vector_tag< 14> >
 
459
{
 
460
    template< typename Vector > struct algorithm
 
461
    {
 
462
        typedef vector13<
 
463
              typename Vector::item1, typename Vector::item2
 
464
            , typename Vector::item3, typename Vector::item4
 
465
            , typename Vector::item5, typename Vector::item6
 
466
            , typename Vector::item7, typename Vector::item8
 
467
            , typename Vector::item9, typename Vector::item10
 
468
            , typename Vector::item11, typename Vector::item12
 
469
            , typename Vector::item13
 
470
            > type;
 
471
    };
 
472
};
 
473
 
 
474
namespace aux {
 
475
template<> struct vector_item_impl<14>
 
476
{
 
477
    template< typename V > struct result_
 
478
    {
 
479
        typedef typename V::item14 type;
 
480
    };
 
481
};
 
482
}
 
483
 
 
484
template<>
 
485
struct at_traits< aux::vector_tag< 14> >
 
486
{
 
487
    template< typename V, typename N > struct algorithm
 
488
    {
 
489
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
490
            ::template result_<V>::type type;
 
491
    };
 
492
};
 
493
 
 
494
template<>
 
495
struct front_traits< aux::vector_tag< 14> >
 
496
{
 
497
    template< typename Vector > struct algorithm
 
498
    {
 
499
        typedef typename Vector::item0 type;
 
500
    };
 
501
};
 
502
 
 
503
template<>
 
504
struct back_traits< aux::vector_tag< 14> >
 
505
{
 
506
    template< typename Vector > struct algorithm
 
507
    {
 
508
        typedef typename Vector::back type;
 
509
    };
 
510
};
 
511
 
 
512
template<>
 
513
struct empty_traits< aux::vector_tag< 14> >
 
514
{
 
515
    template< typename Vector > struct algorithm
 
516
        : false_
 
517
    {
 
518
    };
 
519
};
 
520
 
 
521
template<>
 
522
struct size_traits< aux::vector_tag< 14> >
 
523
{
 
524
    template< typename Vector > struct algorithm
 
525
        : integral_c< int,14 >
 
526
    {
 
527
    };
 
528
};
 
529
 
 
530
template<>
 
531
struct O1_size_traits< aux::vector_tag< 14> >
 
532
    : size_traits< aux::vector_tag< 14> >
 
533
{
 
534
};
 
535
 
 
536
template<>
 
537
struct clear_traits< aux::vector_tag< 14> >
 
538
{
 
539
    template< typename Vector > struct algorithm
 
540
    {
 
541
        typedef vector0<> type;
 
542
    };
 
543
};
 
544
 
 
545
template<
 
546
      typename T0, typename T1, typename T2, typename T3, typename T4
 
547
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
548
    , typename T10, typename T11, typename T12, typename T13, typename T14
 
549
    >
 
550
struct vector15
 
551
{
 
552
    typedef aux::vector_tag<15> tag;
 
553
    typedef vector15 type;
 
554
    typedef T0 item0;
 
555
    typedef T1 item1;
 
556
    typedef T2 item2;
 
557
    typedef T3 item3;
 
558
    typedef T4 item4;
 
559
    typedef T5 item5;
 
560
    typedef T6 item6;
 
561
    typedef T7 item7;
 
562
    typedef T8 item8;
 
563
    typedef T9 item9;
 
564
    typedef T10 item10;
 
565
    typedef T11 item11;
 
566
    typedef T12 item12;
 
567
    typedef T13 item13;
 
568
    typedef T14 item14;
 
569
    
 
570
 
 
571
    typedef void_ item15;
 
572
    typedef T14 back;
 
573
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
574
    typedef vector_iterator< type,integral_c<long,15> > end;
 
575
};
 
576
 
 
577
template<>
 
578
struct push_front_traits< aux::vector_tag< 14> >
 
579
{
 
580
    template< typename Vector, typename T > struct algorithm
 
581
    {
 
582
        typedef vector15<
 
583
              T
 
584
              ,
 
585
              typename Vector::item0, typename Vector::item1
 
586
            , typename Vector::item2, typename Vector::item3
 
587
            , typename Vector::item4, typename Vector::item5
 
588
            , typename Vector::item6, typename Vector::item7
 
589
            , typename Vector::item8, typename Vector::item9
 
590
            , typename Vector::item10, typename Vector::item11
 
591
            , typename Vector::item12, typename Vector::item13
 
592
            > type;
 
593
    };
 
594
};
 
595
 
 
596
template<>
 
597
struct pop_front_traits< aux::vector_tag< 15> >
 
598
{
 
599
    template< typename Vector > struct algorithm
 
600
    {
 
601
        typedef vector14<
 
602
              typename Vector::item1, typename Vector::item2
 
603
            , typename Vector::item3, typename Vector::item4
 
604
            , typename Vector::item5, typename Vector::item6
 
605
            , typename Vector::item7, typename Vector::item8
 
606
            , typename Vector::item9, typename Vector::item10
 
607
            , typename Vector::item11, typename Vector::item12
 
608
            , typename Vector::item13, typename Vector::item14
 
609
            > type;
 
610
    };
 
611
};
 
612
 
 
613
namespace aux {
 
614
template<> struct vector_item_impl<15>
 
615
{
 
616
    template< typename V > struct result_
 
617
    {
 
618
        typedef typename V::item15 type;
 
619
    };
 
620
};
 
621
}
 
622
 
 
623
template<>
 
624
struct at_traits< aux::vector_tag< 15> >
 
625
{
 
626
    template< typename V, typename N > struct algorithm
 
627
    {
 
628
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
629
            ::template result_<V>::type type;
 
630
    };
 
631
};
 
632
 
 
633
template<>
 
634
struct front_traits< aux::vector_tag< 15> >
 
635
{
 
636
    template< typename Vector > struct algorithm
 
637
    {
 
638
        typedef typename Vector::item0 type;
 
639
    };
 
640
};
 
641
 
 
642
template<>
 
643
struct back_traits< aux::vector_tag< 15> >
 
644
{
 
645
    template< typename Vector > struct algorithm
 
646
    {
 
647
        typedef typename Vector::back type;
 
648
    };
 
649
};
 
650
 
 
651
template<>
 
652
struct empty_traits< aux::vector_tag< 15> >
 
653
{
 
654
    template< typename Vector > struct algorithm
 
655
        : false_
 
656
    {
 
657
    };
 
658
};
 
659
 
 
660
template<>
 
661
struct size_traits< aux::vector_tag< 15> >
 
662
{
 
663
    template< typename Vector > struct algorithm
 
664
        : integral_c< int,15 >
 
665
    {
 
666
    };
 
667
};
 
668
 
 
669
template<>
 
670
struct O1_size_traits< aux::vector_tag< 15> >
 
671
    : size_traits< aux::vector_tag< 15> >
 
672
{
 
673
};
 
674
 
 
675
template<>
 
676
struct clear_traits< aux::vector_tag< 15> >
 
677
{
 
678
    template< typename Vector > struct algorithm
 
679
    {
 
680
        typedef vector0<> type;
 
681
    };
 
682
};
 
683
 
 
684
template<
 
685
      typename T0, typename T1, typename T2, typename T3, typename T4
 
686
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
687
    , typename T10, typename T11, typename T12, typename T13, typename T14
 
688
    , typename T15
 
689
    >
 
690
struct vector16
 
691
{
 
692
    typedef aux::vector_tag<16> tag;
 
693
    typedef vector16 type;
 
694
    typedef T0 item0;
 
695
    typedef T1 item1;
 
696
    typedef T2 item2;
 
697
    typedef T3 item3;
 
698
    typedef T4 item4;
 
699
    typedef T5 item5;
 
700
    typedef T6 item6;
 
701
    typedef T7 item7;
 
702
    typedef T8 item8;
 
703
    typedef T9 item9;
 
704
    typedef T10 item10;
 
705
    typedef T11 item11;
 
706
    typedef T12 item12;
 
707
    typedef T13 item13;
 
708
    typedef T14 item14;
 
709
    typedef T15 item15;
 
710
    
 
711
 
 
712
    typedef void_ item16;
 
713
    typedef T15 back;
 
714
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
715
    typedef vector_iterator< type,integral_c<long,16> > end;
 
716
};
 
717
 
 
718
template<>
 
719
struct push_front_traits< aux::vector_tag< 15> >
 
720
{
 
721
    template< typename Vector, typename T > struct algorithm
 
722
    {
 
723
        typedef vector16<
 
724
              T
 
725
              ,
 
726
              typename Vector::item0, typename Vector::item1
 
727
            , typename Vector::item2, typename Vector::item3
 
728
            , typename Vector::item4, typename Vector::item5
 
729
            , typename Vector::item6, typename Vector::item7
 
730
            , typename Vector::item8, typename Vector::item9
 
731
            , typename Vector::item10, typename Vector::item11
 
732
            , typename Vector::item12, typename Vector::item13
 
733
            , typename Vector::item14
 
734
            > type;
 
735
    };
 
736
};
 
737
 
 
738
template<>
 
739
struct pop_front_traits< aux::vector_tag< 16> >
 
740
{
 
741
    template< typename Vector > struct algorithm
 
742
    {
 
743
        typedef vector15<
 
744
              typename Vector::item1, typename Vector::item2
 
745
            , typename Vector::item3, typename Vector::item4
 
746
            , typename Vector::item5, typename Vector::item6
 
747
            , typename Vector::item7, typename Vector::item8
 
748
            , typename Vector::item9, typename Vector::item10
 
749
            , typename Vector::item11, typename Vector::item12
 
750
            , typename Vector::item13, typename Vector::item14
 
751
            , typename Vector::item15
 
752
            > type;
 
753
    };
 
754
};
 
755
 
 
756
namespace aux {
 
757
template<> struct vector_item_impl<16>
 
758
{
 
759
    template< typename V > struct result_
 
760
    {
 
761
        typedef typename V::item16 type;
 
762
    };
 
763
};
 
764
}
 
765
 
 
766
template<>
 
767
struct at_traits< aux::vector_tag< 16> >
 
768
{
 
769
    template< typename V, typename N > struct algorithm
 
770
    {
 
771
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
772
            ::template result_<V>::type type;
 
773
    };
 
774
};
 
775
 
 
776
template<>
 
777
struct front_traits< aux::vector_tag< 16> >
 
778
{
 
779
    template< typename Vector > struct algorithm
 
780
    {
 
781
        typedef typename Vector::item0 type;
 
782
    };
 
783
};
 
784
 
 
785
template<>
 
786
struct back_traits< aux::vector_tag< 16> >
 
787
{
 
788
    template< typename Vector > struct algorithm
 
789
    {
 
790
        typedef typename Vector::back type;
 
791
    };
 
792
};
 
793
 
 
794
template<>
 
795
struct empty_traits< aux::vector_tag< 16> >
 
796
{
 
797
    template< typename Vector > struct algorithm
 
798
        : false_
 
799
    {
 
800
    };
 
801
};
 
802
 
 
803
template<>
 
804
struct size_traits< aux::vector_tag< 16> >
 
805
{
 
806
    template< typename Vector > struct algorithm
 
807
        : integral_c< int,16 >
 
808
    {
 
809
    };
 
810
};
 
811
 
 
812
template<>
 
813
struct O1_size_traits< aux::vector_tag< 16> >
 
814
    : size_traits< aux::vector_tag< 16> >
 
815
{
 
816
};
 
817
 
 
818
template<>
 
819
struct clear_traits< aux::vector_tag< 16> >
 
820
{
 
821
    template< typename Vector > struct algorithm
 
822
    {
 
823
        typedef vector0<> type;
 
824
    };
 
825
};
 
826
 
 
827
template<
 
828
      typename T0, typename T1, typename T2, typename T3, typename T4
 
829
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
830
    , typename T10, typename T11, typename T12, typename T13, typename T14
 
831
    , typename T15, typename T16
 
832
    >
 
833
struct vector17
 
834
{
 
835
    typedef aux::vector_tag<17> tag;
 
836
    typedef vector17 type;
 
837
    typedef T0 item0;
 
838
    typedef T1 item1;
 
839
    typedef T2 item2;
 
840
    typedef T3 item3;
 
841
    typedef T4 item4;
 
842
    typedef T5 item5;
 
843
    typedef T6 item6;
 
844
    typedef T7 item7;
 
845
    typedef T8 item8;
 
846
    typedef T9 item9;
 
847
    typedef T10 item10;
 
848
    typedef T11 item11;
 
849
    typedef T12 item12;
 
850
    typedef T13 item13;
 
851
    typedef T14 item14;
 
852
    typedef T15 item15;
 
853
    typedef T16 item16;
 
854
    
 
855
 
 
856
    typedef void_ item17;
 
857
    typedef T16 back;
 
858
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
859
    typedef vector_iterator< type,integral_c<long,17> > end;
 
860
};
 
861
 
 
862
template<>
 
863
struct push_front_traits< aux::vector_tag< 16> >
 
864
{
 
865
    template< typename Vector, typename T > struct algorithm
 
866
    {
 
867
        typedef vector17<
 
868
              T
 
869
              ,
 
870
              typename Vector::item0, typename Vector::item1
 
871
            , typename Vector::item2, typename Vector::item3
 
872
            , typename Vector::item4, typename Vector::item5
 
873
            , typename Vector::item6, typename Vector::item7
 
874
            , typename Vector::item8, typename Vector::item9
 
875
            , typename Vector::item10, typename Vector::item11
 
876
            , typename Vector::item12, typename Vector::item13
 
877
            , typename Vector::item14, typename Vector::item15
 
878
            > type;
 
879
    };
 
880
};
 
881
 
 
882
template<>
 
883
struct pop_front_traits< aux::vector_tag< 17> >
 
884
{
 
885
    template< typename Vector > struct algorithm
 
886
    {
 
887
        typedef vector16<
 
888
              typename Vector::item1, typename Vector::item2
 
889
            , typename Vector::item3, typename Vector::item4
 
890
            , typename Vector::item5, typename Vector::item6
 
891
            , typename Vector::item7, typename Vector::item8
 
892
            , typename Vector::item9, typename Vector::item10
 
893
            , typename Vector::item11, typename Vector::item12
 
894
            , typename Vector::item13, typename Vector::item14
 
895
            , typename Vector::item15, typename Vector::item16
 
896
            > type;
 
897
    };
 
898
};
 
899
 
 
900
namespace aux {
 
901
template<> struct vector_item_impl<17>
 
902
{
 
903
    template< typename V > struct result_
 
904
    {
 
905
        typedef typename V::item17 type;
 
906
    };
 
907
};
 
908
}
 
909
 
 
910
template<>
 
911
struct at_traits< aux::vector_tag< 17> >
 
912
{
 
913
    template< typename V, typename N > struct algorithm
 
914
    {
 
915
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
916
            ::template result_<V>::type type;
 
917
    };
 
918
};
 
919
 
 
920
template<>
 
921
struct front_traits< aux::vector_tag< 17> >
 
922
{
 
923
    template< typename Vector > struct algorithm
 
924
    {
 
925
        typedef typename Vector::item0 type;
 
926
    };
 
927
};
 
928
 
 
929
template<>
 
930
struct back_traits< aux::vector_tag< 17> >
 
931
{
 
932
    template< typename Vector > struct algorithm
 
933
    {
 
934
        typedef typename Vector::back type;
 
935
    };
 
936
};
 
937
 
 
938
template<>
 
939
struct empty_traits< aux::vector_tag< 17> >
 
940
{
 
941
    template< typename Vector > struct algorithm
 
942
        : false_
 
943
    {
 
944
    };
 
945
};
 
946
 
 
947
template<>
 
948
struct size_traits< aux::vector_tag< 17> >
 
949
{
 
950
    template< typename Vector > struct algorithm
 
951
        : integral_c< int,17 >
 
952
    {
 
953
    };
 
954
};
 
955
 
 
956
template<>
 
957
struct O1_size_traits< aux::vector_tag< 17> >
 
958
    : size_traits< aux::vector_tag< 17> >
 
959
{
 
960
};
 
961
 
 
962
template<>
 
963
struct clear_traits< aux::vector_tag< 17> >
 
964
{
 
965
    template< typename Vector > struct algorithm
 
966
    {
 
967
        typedef vector0<> type;
 
968
    };
 
969
};
 
970
 
 
971
template<
 
972
      typename T0, typename T1, typename T2, typename T3, typename T4
 
973
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
974
    , typename T10, typename T11, typename T12, typename T13, typename T14
 
975
    , typename T15, typename T16, typename T17
 
976
    >
 
977
struct vector18
 
978
{
 
979
    typedef aux::vector_tag<18> tag;
 
980
    typedef vector18 type;
 
981
    typedef T0 item0;
 
982
    typedef T1 item1;
 
983
    typedef T2 item2;
 
984
    typedef T3 item3;
 
985
    typedef T4 item4;
 
986
    typedef T5 item5;
 
987
    typedef T6 item6;
 
988
    typedef T7 item7;
 
989
    typedef T8 item8;
 
990
    typedef T9 item9;
 
991
    typedef T10 item10;
 
992
    typedef T11 item11;
 
993
    typedef T12 item12;
 
994
    typedef T13 item13;
 
995
    typedef T14 item14;
 
996
    typedef T15 item15;
 
997
    typedef T16 item16;
 
998
    typedef T17 item17;
 
999
    
 
1000
 
 
1001
    typedef void_ item18;
 
1002
    typedef T17 back;
 
1003
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
1004
    typedef vector_iterator< type,integral_c<long,18> > end;
 
1005
};
 
1006
 
 
1007
template<>
 
1008
struct push_front_traits< aux::vector_tag< 17> >
 
1009
{
 
1010
    template< typename Vector, typename T > struct algorithm
 
1011
    {
 
1012
        typedef vector18<
 
1013
              T
 
1014
              ,
 
1015
              typename Vector::item0, typename Vector::item1
 
1016
            , typename Vector::item2, typename Vector::item3
 
1017
            , typename Vector::item4, typename Vector::item5
 
1018
            , typename Vector::item6, typename Vector::item7
 
1019
            , typename Vector::item8, typename Vector::item9
 
1020
            , typename Vector::item10, typename Vector::item11
 
1021
            , typename Vector::item12, typename Vector::item13
 
1022
            , typename Vector::item14, typename Vector::item15
 
1023
            , typename Vector::item16
 
1024
            > type;
 
1025
    };
 
1026
};
 
1027
 
 
1028
template<>
 
1029
struct pop_front_traits< aux::vector_tag< 18> >
 
1030
{
 
1031
    template< typename Vector > struct algorithm
 
1032
    {
 
1033
        typedef vector17<
 
1034
              typename Vector::item1, typename Vector::item2
 
1035
            , typename Vector::item3, typename Vector::item4
 
1036
            , typename Vector::item5, typename Vector::item6
 
1037
            , typename Vector::item7, typename Vector::item8
 
1038
            , typename Vector::item9, typename Vector::item10
 
1039
            , typename Vector::item11, typename Vector::item12
 
1040
            , typename Vector::item13, typename Vector::item14
 
1041
            , typename Vector::item15, typename Vector::item16
 
1042
            , typename Vector::item17
 
1043
            > type;
 
1044
    };
 
1045
};
 
1046
 
 
1047
namespace aux {
 
1048
template<> struct vector_item_impl<18>
 
1049
{
 
1050
    template< typename V > struct result_
 
1051
    {
 
1052
        typedef typename V::item18 type;
 
1053
    };
 
1054
};
 
1055
}
 
1056
 
 
1057
template<>
 
1058
struct at_traits< aux::vector_tag< 18> >
 
1059
{
 
1060
    template< typename V, typename N > struct algorithm
 
1061
    {
 
1062
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
1063
            ::template result_<V>::type type;
 
1064
    };
 
1065
};
 
1066
 
 
1067
template<>
 
1068
struct front_traits< aux::vector_tag< 18> >
 
1069
{
 
1070
    template< typename Vector > struct algorithm
 
1071
    {
 
1072
        typedef typename Vector::item0 type;
 
1073
    };
 
1074
};
 
1075
 
 
1076
template<>
 
1077
struct back_traits< aux::vector_tag< 18> >
 
1078
{
 
1079
    template< typename Vector > struct algorithm
 
1080
    {
 
1081
        typedef typename Vector::back type;
 
1082
    };
 
1083
};
 
1084
 
 
1085
template<>
 
1086
struct empty_traits< aux::vector_tag< 18> >
 
1087
{
 
1088
    template< typename Vector > struct algorithm
 
1089
        : false_
 
1090
    {
 
1091
    };
 
1092
};
 
1093
 
 
1094
template<>
 
1095
struct size_traits< aux::vector_tag< 18> >
 
1096
{
 
1097
    template< typename Vector > struct algorithm
 
1098
        : integral_c< int,18 >
 
1099
    {
 
1100
    };
 
1101
};
 
1102
 
 
1103
template<>
 
1104
struct O1_size_traits< aux::vector_tag< 18> >
 
1105
    : size_traits< aux::vector_tag< 18> >
 
1106
{
 
1107
};
 
1108
 
 
1109
template<>
 
1110
struct clear_traits< aux::vector_tag< 18> >
 
1111
{
 
1112
    template< typename Vector > struct algorithm
 
1113
    {
 
1114
        typedef vector0<> type;
 
1115
    };
 
1116
};
 
1117
 
 
1118
template<
 
1119
      typename T0, typename T1, typename T2, typename T3, typename T4
 
1120
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
1121
    , typename T10, typename T11, typename T12, typename T13, typename T14
 
1122
    , typename T15, typename T16, typename T17, typename T18
 
1123
    >
 
1124
struct vector19
 
1125
{
 
1126
    typedef aux::vector_tag<19> tag;
 
1127
    typedef vector19 type;
 
1128
    typedef T0 item0;
 
1129
    typedef T1 item1;
 
1130
    typedef T2 item2;
 
1131
    typedef T3 item3;
 
1132
    typedef T4 item4;
 
1133
    typedef T5 item5;
 
1134
    typedef T6 item6;
 
1135
    typedef T7 item7;
 
1136
    typedef T8 item8;
 
1137
    typedef T9 item9;
 
1138
    typedef T10 item10;
 
1139
    typedef T11 item11;
 
1140
    typedef T12 item12;
 
1141
    typedef T13 item13;
 
1142
    typedef T14 item14;
 
1143
    typedef T15 item15;
 
1144
    typedef T16 item16;
 
1145
    typedef T17 item17;
 
1146
    typedef T18 item18;
 
1147
    
 
1148
 
 
1149
    typedef void_ item19;
 
1150
    typedef T18 back;
 
1151
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
1152
    typedef vector_iterator< type,integral_c<long,19> > end;
 
1153
};
 
1154
 
 
1155
template<>
 
1156
struct push_front_traits< aux::vector_tag< 18> >
 
1157
{
 
1158
    template< typename Vector, typename T > struct algorithm
 
1159
    {
 
1160
        typedef vector19<
 
1161
              T
 
1162
              ,
 
1163
              typename Vector::item0, typename Vector::item1
 
1164
            , typename Vector::item2, typename Vector::item3
 
1165
            , typename Vector::item4, typename Vector::item5
 
1166
            , typename Vector::item6, typename Vector::item7
 
1167
            , typename Vector::item8, typename Vector::item9
 
1168
            , typename Vector::item10, typename Vector::item11
 
1169
            , typename Vector::item12, typename Vector::item13
 
1170
            , typename Vector::item14, typename Vector::item15
 
1171
            , typename Vector::item16, typename Vector::item17
 
1172
            > type;
 
1173
    };
 
1174
};
 
1175
 
 
1176
template<>
 
1177
struct pop_front_traits< aux::vector_tag< 19> >
 
1178
{
 
1179
    template< typename Vector > struct algorithm
 
1180
    {
 
1181
        typedef vector18<
 
1182
              typename Vector::item1, typename Vector::item2
 
1183
            , typename Vector::item3, typename Vector::item4
 
1184
            , typename Vector::item5, typename Vector::item6
 
1185
            , typename Vector::item7, typename Vector::item8
 
1186
            , typename Vector::item9, typename Vector::item10
 
1187
            , typename Vector::item11, typename Vector::item12
 
1188
            , typename Vector::item13, typename Vector::item14
 
1189
            , typename Vector::item15, typename Vector::item16
 
1190
            , typename Vector::item17, typename Vector::item18
 
1191
            > type;
 
1192
    };
 
1193
};
 
1194
 
 
1195
namespace aux {
 
1196
template<> struct vector_item_impl<19>
 
1197
{
 
1198
    template< typename V > struct result_
 
1199
    {
 
1200
        typedef typename V::item19 type;
 
1201
    };
 
1202
};
 
1203
}
 
1204
 
 
1205
template<>
 
1206
struct at_traits< aux::vector_tag< 19> >
 
1207
{
 
1208
    template< typename V, typename N > struct algorithm
 
1209
    {
 
1210
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
1211
            ::template result_<V>::type type;
 
1212
    };
 
1213
};
 
1214
 
 
1215
template<>
 
1216
struct front_traits< aux::vector_tag< 19> >
 
1217
{
 
1218
    template< typename Vector > struct algorithm
 
1219
    {
 
1220
        typedef typename Vector::item0 type;
 
1221
    };
 
1222
};
 
1223
 
 
1224
template<>
 
1225
struct back_traits< aux::vector_tag< 19> >
 
1226
{
 
1227
    template< typename Vector > struct algorithm
 
1228
    {
 
1229
        typedef typename Vector::back type;
 
1230
    };
 
1231
};
 
1232
 
 
1233
template<>
 
1234
struct empty_traits< aux::vector_tag< 19> >
 
1235
{
 
1236
    template< typename Vector > struct algorithm
 
1237
        : false_
 
1238
    {
 
1239
    };
 
1240
};
 
1241
 
 
1242
template<>
 
1243
struct size_traits< aux::vector_tag< 19> >
 
1244
{
 
1245
    template< typename Vector > struct algorithm
 
1246
        : integral_c< int,19 >
 
1247
    {
 
1248
    };
 
1249
};
 
1250
 
 
1251
template<>
 
1252
struct O1_size_traits< aux::vector_tag< 19> >
 
1253
    : size_traits< aux::vector_tag< 19> >
 
1254
{
 
1255
};
 
1256
 
 
1257
template<>
 
1258
struct clear_traits< aux::vector_tag< 19> >
 
1259
{
 
1260
    template< typename Vector > struct algorithm
 
1261
    {
 
1262
        typedef vector0<> type;
 
1263
    };
 
1264
};
 
1265
 
 
1266
template<
 
1267
      typename T0, typename T1, typename T2, typename T3, typename T4
 
1268
    , typename T5, typename T6, typename T7, typename T8, typename T9
 
1269
    , typename T10, typename T11, typename T12, typename T13, typename T14
 
1270
    , typename T15, typename T16, typename T17, typename T18, typename T19
 
1271
    >
 
1272
struct vector20
 
1273
{
 
1274
    typedef aux::vector_tag<20> tag;
 
1275
    typedef vector20 type;
 
1276
    typedef T0 item0;
 
1277
    typedef T1 item1;
 
1278
    typedef T2 item2;
 
1279
    typedef T3 item3;
 
1280
    typedef T4 item4;
 
1281
    typedef T5 item5;
 
1282
    typedef T6 item6;
 
1283
    typedef T7 item7;
 
1284
    typedef T8 item8;
 
1285
    typedef T9 item9;
 
1286
    typedef T10 item10;
 
1287
    typedef T11 item11;
 
1288
    typedef T12 item12;
 
1289
    typedef T13 item13;
 
1290
    typedef T14 item14;
 
1291
    typedef T15 item15;
 
1292
    typedef T16 item16;
 
1293
    typedef T17 item17;
 
1294
    typedef T18 item18;
 
1295
    typedef T19 item19;
 
1296
    
 
1297
 
 
1298
    typedef void_ item20;
 
1299
    typedef T19 back;
 
1300
    typedef vector_iterator< type,integral_c<long,0> > begin;
 
1301
    typedef vector_iterator< type,integral_c<long,20> > end;
 
1302
};
 
1303
 
 
1304
template<>
 
1305
struct push_front_traits< aux::vector_tag< 19> >
 
1306
{
 
1307
    template< typename Vector, typename T > struct algorithm
 
1308
    {
 
1309
        typedef vector20<
 
1310
              T
 
1311
              ,
 
1312
              typename Vector::item0, typename Vector::item1
 
1313
            , typename Vector::item2, typename Vector::item3
 
1314
            , typename Vector::item4, typename Vector::item5
 
1315
            , typename Vector::item6, typename Vector::item7
 
1316
            , typename Vector::item8, typename Vector::item9
 
1317
            , typename Vector::item10, typename Vector::item11
 
1318
            , typename Vector::item12, typename Vector::item13
 
1319
            , typename Vector::item14, typename Vector::item15
 
1320
            , typename Vector::item16, typename Vector::item17
 
1321
            , typename Vector::item18
 
1322
            > type;
 
1323
    };
 
1324
};
 
1325
 
 
1326
template<>
 
1327
struct pop_front_traits< aux::vector_tag< 20> >
 
1328
{
 
1329
    template< typename Vector > struct algorithm
 
1330
    {
 
1331
        typedef vector19<
 
1332
              typename Vector::item1, typename Vector::item2
 
1333
            , typename Vector::item3, typename Vector::item4
 
1334
            , typename Vector::item5, typename Vector::item6
 
1335
            , typename Vector::item7, typename Vector::item8
 
1336
            , typename Vector::item9, typename Vector::item10
 
1337
            , typename Vector::item11, typename Vector::item12
 
1338
            , typename Vector::item13, typename Vector::item14
 
1339
            , typename Vector::item15, typename Vector::item16
 
1340
            , typename Vector::item17, typename Vector::item18
 
1341
            , typename Vector::item19
 
1342
            > type;
 
1343
    };
 
1344
};
 
1345
 
 
1346
namespace aux {
 
1347
template<> struct vector_item_impl<20>
 
1348
{
 
1349
    template< typename V > struct result_
 
1350
    {
 
1351
        typedef typename V::item20 type;
 
1352
    };
 
1353
};
 
1354
}
 
1355
 
 
1356
template<>
 
1357
struct at_traits< aux::vector_tag< 20> >
 
1358
{
 
1359
    template< typename V, typename N > struct algorithm
 
1360
    {
 
1361
        typedef typename aux::vector_item_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 
1362
            ::template result_<V>::type type;
 
1363
    };
 
1364
};
 
1365
 
 
1366
template<>
 
1367
struct front_traits< aux::vector_tag< 20> >
 
1368
{
 
1369
    template< typename Vector > struct algorithm
 
1370
    {
 
1371
        typedef typename Vector::item0 type;
 
1372
    };
 
1373
};
 
1374
 
 
1375
template<>
 
1376
struct back_traits< aux::vector_tag< 20> >
 
1377
{
 
1378
    template< typename Vector > struct algorithm
 
1379
    {
 
1380
        typedef typename Vector::back type;
 
1381
    };
 
1382
};
 
1383
 
 
1384
template<>
 
1385
struct empty_traits< aux::vector_tag< 20> >
 
1386
{
 
1387
    template< typename Vector > struct algorithm
 
1388
        : false_
 
1389
    {
 
1390
    };
 
1391
};
 
1392
 
 
1393
template<>
 
1394
struct size_traits< aux::vector_tag< 20> >
 
1395
{
 
1396
    template< typename Vector > struct algorithm
 
1397
        : integral_c< int,20 >
 
1398
    {
 
1399
    };
 
1400
};
 
1401
 
 
1402
template<>
 
1403
struct O1_size_traits< aux::vector_tag< 20> >
 
1404
    : size_traits< aux::vector_tag< 20> >
 
1405
{
 
1406
};
 
1407
 
 
1408
template<>
 
1409
struct clear_traits< aux::vector_tag< 20> >
 
1410
{
 
1411
    template< typename Vector > struct algorithm
 
1412
    {
 
1413
        typedef vector0<> type;
 
1414
    };
 
1415
};
 
1416
 
 
1417
} // namespace mpl
 
1418
} // namespace boost
 
1419