preprocessed/no_ctps/vector10.hpp

0001
0002 // Copyright Aleksey Gurtovoy 2000-2004
0003 //
0004 // Distributed under the Boost Software License, Version 1.0.
0005 // (See accompanying file LICENSE_1_0.txt or copy at
0006 // http://www.boost.org/LICENSE_1_0.txt)
0007 //
0008
0009 // Preprocessed version of "boost/mpl/vector/vector10.hpp" header
0010 // -- DO NOT modify by hand!
0011
0012 namespace boost { namespace mpl {
0013
0014 namespace aux {
0015 template<> struct v_at_impl<0>
0016 {
0017     template< typename V_ > struct result_
0018     {
0019         typedef typename V_::item0 type;
0020     };
0021 };
0022
0023 }
0024
0025 template<>
0026 struct at_impl< aux::vector_tag<0> >
0027 {
0028     template< typename V_, typename N > struct apply
0029     {
0030         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0031             ::template result_<V_>::type type;
0032     };
0033 };
0034
0035 template<>
0036 struct size_impl< aux::vector_tag<0> >
0037 {
0038     template< typename Vector > struct apply
0039         : long_<0>
0040     {
0041     };
0042 };
0043
0044 template<>
0045 struct O1_size_impl< aux::vector_tag<0> >
0046     : size_impl< aux::vector_tag<0> >
0047 {
0048 };
0049
0050 template<>
0051 struct clear_impl< aux::vector_tag<0> >
0052 {
0053     template< typename Vector > struct apply
0054     {
0055         typedef vector0<> type;
0056     };
0057 };
0058
0059 template<
0060       typename T0
0061     >
0062 struct vector1
0063 {
0064     typedef aux::vector_tag<1> tag;
0065     typedef vector1 type;
0066     typedef T0 item0;
0067     typedef void_ item1;
0068     typedef T0 back;
0069     typedef v_iter< type,0 > begin;
0070     typedef v_iter< type,1 > end;
0071 };
0072
0073 template<>
0074 struct push_front_impl< aux::vector_tag<0> >
0075 {
0076     template< typename Vector, typename T > struct apply
0077     {
0078         typedef vector1<
0079               T
0080             > type;
0081     };
0082 };
0083
0084 template<>
0085 struct pop_front_impl< aux::vector_tag<1> >
0086 {
0087     template< typename Vector > struct apply
0088     {
0089         typedef vector0<
0090
0091             > type;
0092     };
0093 };
0094
0095 template<>
0096 struct push_back_impl< aux::vector_tag<0> >
0097 {
0098     template< typename Vector, typename T > struct apply
0099     {
0100         typedef vector1<
0101
0102               T
0103             > type;
0104     };
0105 };
0106
0107 template<>
0108 struct pop_back_impl< aux::vector_tag<1> >
0109 {
0110     template< typename Vector > struct apply
0111     {
0112         typedef vector0<
0113
0114             > type;
0115     };
0116 };
0117
0118 namespace aux {
0119 template<> struct v_at_impl<1>
0120 {
0121     template< typename V_ > struct result_
0122     {
0123         typedef typename V_::item1 type;
0124     };
0125 };
0126
0127 }
0128
0129 template<>
0130 struct at_impl< aux::vector_tag<1> >
0131 {
0132     template< typename V_, typename N > struct apply
0133     {
0134         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0135             ::template result_<V_>::type type;
0136     };
0137 };
0138
0139 template<>
0140 struct front_impl< aux::vector_tag<1> >
0141 {
0142     template< typename Vector > struct apply
0143     {
0144         typedef typename Vector::item0 type;
0145     };
0146 };
0147
0148 template<>
0149 struct back_impl< aux::vector_tag<1> >
0150 {
0151     template< typename Vector > struct apply
0152     {
0153         typedef typename Vector::back type;
0154     };
0155 };
0156
0157 template<>
0158 struct empty_impl< aux::vector_tag<1> >
0159 {
0160     template< typename Vector > struct apply
0161         : false_
0162     {
0163     };
0164 };
0165
0166 template<>
0167 struct size_impl< aux::vector_tag<1> >
0168 {
0169     template< typename Vector > struct apply
0170         : long_<1>
0171     {
0172     };
0173 };
0174
0175 template<>
0176 struct O1_size_impl< aux::vector_tag<1> >
0177     : size_impl< aux::vector_tag<1> >
0178 {
0179 };
0180
0181 template<>
0182 struct clear_impl< aux::vector_tag<1> >
0183 {
0184     template< typename Vector > struct apply
0185     {
0186         typedef vector0<> type;
0187     };
0188 };
0189
0190 template<
0191       typename T0, typename T1
0192     >
0193 struct vector2
0194 {
0195     typedef aux::vector_tag<2> tag;
0196     typedef vector2 type;
0197     typedef T0 item0;
0198     typedef T1 item1;
0199
0200
0201     typedef void_ item2;
0202     typedef T1 back;
0203     typedef v_iter< type,0 > begin;
0204     typedef v_iter< type,2 > end;
0205 };
0206
0207 template<>
0208 struct push_front_impl< aux::vector_tag<1> >
0209 {
0210     template< typename Vector, typename T > struct apply
0211     {
0212         typedef vector2<
0213               T
0214               ,
0215               typename Vector::item0
0216             > type;
0217     };
0218 };
0219
0220 template<>
0221 struct pop_front_impl< aux::vector_tag<2> >
0222 {
0223     template< typename Vector > struct apply
0224     {
0225         typedef vector1<
0226               typename Vector::item1
0227             > type;
0228     };
0229 };
0230
0231 template<>
0232 struct push_back_impl< aux::vector_tag<1> >
0233 {
0234     template< typename Vector, typename T > struct apply
0235     {
0236         typedef vector2<
0237               typename Vector::item0
0238               ,
0239               T
0240             > type;
0241     };
0242 };
0243
0244 template<>
0245 struct pop_back_impl< aux::vector_tag<2> >
0246 {
0247     template< typename Vector > struct apply
0248     {
0249         typedef vector1<
0250               typename Vector::item0
0251             > type;
0252     };
0253 };
0254
0255 namespace aux {
0256 template<> struct v_at_impl<2>
0257 {
0258     template< typename V_ > struct result_
0259     {
0260         typedef typename V_::item2 type;
0261     };
0262 };
0263
0264 }
0265
0266 template<>
0267 struct at_impl< aux::vector_tag<2> >
0268 {
0269     template< typename V_, typename N > struct apply
0270     {
0271         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0272             ::template result_<V_>::type type;
0273     };
0274 };
0275
0276 template<>
0277 struct front_impl< aux::vector_tag<2> >
0278 {
0279     template< typename Vector > struct apply
0280     {
0281         typedef typename Vector::item0 type;
0282     };
0283 };
0284
0285 template<>
0286 struct back_impl< aux::vector_tag<2> >
0287 {
0288     template< typename Vector > struct apply
0289     {
0290         typedef typename Vector::back type;
0291     };
0292 };
0293
0294 template<>
0295 struct empty_impl< aux::vector_tag<2> >
0296 {
0297     template< typename Vector > struct apply
0298         : false_
0299     {
0300     };
0301 };
0302
0303 template<>
0304 struct size_impl< aux::vector_tag<2> >
0305 {
0306     template< typename Vector > struct apply
0307         : long_<2>
0308     {
0309     };
0310 };
0311
0312 template<>
0313 struct O1_size_impl< aux::vector_tag<2> >
0314     : size_impl< aux::vector_tag<2> >
0315 {
0316 };
0317
0318 template<>
0319 struct clear_impl< aux::vector_tag<2> >
0320 {
0321     template< typename Vector > struct apply
0322     {
0323         typedef vector0<> type;
0324     };
0325 };
0326
0327 template<
0328       typename T0, typename T1, typename T2
0329     >
0330 struct vector3
0331 {
0332     typedef aux::vector_tag<3> tag;
0333     typedef vector3 type;
0334     typedef T0 item0;
0335     typedef T1 item1;
0336     typedef T2 item2;
0337
0338
0339     typedef void_ item3;
0340     typedef T2 back;
0341     typedef v_iter< type,0 > begin;
0342     typedef v_iter< type,3 > end;
0343 };
0344
0345 template<>
0346 struct push_front_impl< aux::vector_tag<2> >
0347 {
0348     template< typename Vector, typename T > struct apply
0349     {
0350         typedef vector3<
0351               T
0352               ,
0353               typename Vector::item0, typename Vector::item1
0354             > type;
0355     };
0356 };
0357
0358 template<>
0359 struct pop_front_impl< aux::vector_tag<3> >
0360 {
0361     template< typename Vector > struct apply
0362     {
0363         typedef vector2<
0364               typename Vector::item1, typename Vector::item2
0365             > type;
0366     };
0367 };
0368
0369 template<>
0370 struct push_back_impl< aux::vector_tag<2> >
0371 {
0372     template< typename Vector, typename T > struct apply
0373     {
0374         typedef vector3<
0375               typename Vector::item0, typename Vector::item1
0376               ,
0377               T
0378             > type;
0379     };
0380 };
0381
0382 template<>
0383 struct pop_back_impl< aux::vector_tag<3> >
0384 {
0385     template< typename Vector > struct apply
0386     {
0387         typedef vector2<
0388               typename Vector::item0, typename Vector::item1
0389             > type;
0390     };
0391 };
0392
0393 namespace aux {
0394 template<> struct v_at_impl<3>
0395 {
0396     template< typename V_ > struct result_
0397     {
0398         typedef typename V_::item3 type;
0399     };
0400 };
0401
0402 }
0403
0404 template<>
0405 struct at_impl< aux::vector_tag<3> >
0406 {
0407     template< typename V_, typename N > struct apply
0408     {
0409         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0410             ::template result_<V_>::type type;
0411     };
0412 };
0413
0414 template<>
0415 struct front_impl< aux::vector_tag<3> >
0416 {
0417     template< typename Vector > struct apply
0418     {
0419         typedef typename Vector::item0 type;
0420     };
0421 };
0422
0423 template<>
0424 struct back_impl< aux::vector_tag<3> >
0425 {
0426     template< typename Vector > struct apply
0427     {
0428         typedef typename Vector::back type;
0429     };
0430 };
0431
0432 template<>
0433 struct empty_impl< aux::vector_tag<3> >
0434 {
0435     template< typename Vector > struct apply
0436         : false_
0437     {
0438     };
0439 };
0440
0441 template<>
0442 struct size_impl< aux::vector_tag<3> >
0443 {
0444     template< typename Vector > struct apply
0445         : long_<3>
0446     {
0447     };
0448 };
0449
0450 template<>
0451 struct O1_size_impl< aux::vector_tag<3> >
0452     : size_impl< aux::vector_tag<3> >
0453 {
0454 };
0455
0456 template<>
0457 struct clear_impl< aux::vector_tag<3> >
0458 {
0459     template< typename Vector > struct apply
0460     {
0461         typedef vector0<> type;
0462     };
0463 };
0464
0465 template<
0466       typename T0, typename T1, typename T2, typename T3
0467     >
0468 struct vector4
0469 {
0470     typedef aux::vector_tag<4> tag;
0471     typedef vector4 type;
0472     typedef T0 item0;
0473     typedef T1 item1;
0474     typedef T2 item2;
0475     typedef T3 item3;
0476
0477
0478     typedef void_ item4;
0479     typedef T3 back;
0480     typedef v_iter< type,0 > begin;
0481     typedef v_iter< type,4 > end;
0482 };
0483
0484 template<>
0485 struct push_front_impl< aux::vector_tag<3> >
0486 {
0487     template< typename Vector, typename T > struct apply
0488     {
0489         typedef vector4<
0490               T
0491               ,
0492               typename Vector::item0, typename Vector::item1
0493             , typename Vector::item2
0494             > type;
0495     };
0496 };
0497
0498 template<>
0499 struct pop_front_impl< aux::vector_tag<4> >
0500 {
0501     template< typename Vector > struct apply
0502     {
0503         typedef vector3<
0504               typename Vector::item1, typename Vector::item2
0505             , typename Vector::item3
0506             > type;
0507     };
0508 };
0509
0510 template<>
0511 struct push_back_impl< aux::vector_tag<3> >
0512 {
0513     template< typename Vector, typename T > struct apply
0514     {
0515         typedef vector4<
0516               typename Vector::item0, typename Vector::item1
0517             , typename Vector::item2
0518               ,
0519               T
0520             > type;
0521     };
0522 };
0523
0524 template<>
0525 struct pop_back_impl< aux::vector_tag<4> >
0526 {
0527     template< typename Vector > struct apply
0528     {
0529         typedef vector3<
0530               typename Vector::item0, typename Vector::item1
0531             , typename Vector::item2
0532             > type;
0533     };
0534 };
0535
0536 namespace aux {
0537 template<> struct v_at_impl<4>
0538 {
0539     template< typename V_ > struct result_
0540     {
0541         typedef typename V_::item4 type;
0542     };
0543 };
0544
0545 }
0546
0547 template<>
0548 struct at_impl< aux::vector_tag<4> >
0549 {
0550     template< typename V_, typename N > struct apply
0551     {
0552         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0553             ::template result_<V_>::type type;
0554     };
0555 };
0556
0557 template<>
0558 struct front_impl< aux::vector_tag<4> >
0559 {
0560     template< typename Vector > struct apply
0561     {
0562         typedef typename Vector::item0 type;
0563     };
0564 };
0565
0566 template<>
0567 struct back_impl< aux::vector_tag<4> >
0568 {
0569     template< typename Vector > struct apply
0570     {
0571         typedef typename Vector::back type;
0572     };
0573 };
0574
0575 template<>
0576 struct empty_impl< aux::vector_tag<4> >
0577 {
0578     template< typename Vector > struct apply
0579         : false_
0580     {
0581     };
0582 };
0583
0584 template<>
0585 struct size_impl< aux::vector_tag<4> >
0586 {
0587     template< typename Vector > struct apply
0588         : long_<4>
0589     {
0590     };
0591 };
0592
0593 template<>
0594 struct O1_size_impl< aux::vector_tag<4> >
0595     : size_impl< aux::vector_tag<4> >
0596 {
0597 };
0598
0599 template<>
0600 struct clear_impl< aux::vector_tag<4> >
0601 {
0602     template< typename Vector > struct apply
0603     {
0604         typedef vector0<> type;
0605     };
0606 };
0607
0608 template<
0609       typename T0, typename T1, typename T2, typename T3, typename T4
0610     >
0611 struct vector5
0612 {
0613     typedef aux::vector_tag<5> tag;
0614     typedef vector5 type;
0615     typedef T0 item0;
0616     typedef T1 item1;
0617     typedef T2 item2;
0618     typedef T3 item3;
0619     typedef T4 item4;
0620
0621
0622     typedef void_ item5;
0623     typedef T4 back;
0624     typedef v_iter< type,0 > begin;
0625     typedef v_iter< type,5 > end;
0626 };
0627
0628 template<>
0629 struct push_front_impl< aux::vector_tag<4> >
0630 {
0631     template< typename Vector, typename T > struct apply
0632     {
0633         typedef vector5<
0634               T
0635               ,
0636               typename Vector::item0, typename Vector::item1
0637             , typename Vector::item2, typename Vector::item3
0638             > type;
0639     };
0640 };
0641
0642 template<>
0643 struct pop_front_impl< aux::vector_tag<5> >
0644 {
0645     template< typename Vector > struct apply
0646     {
0647         typedef vector4<
0648               typename Vector::item1, typename Vector::item2
0649             , typename Vector::item3, typename Vector::item4
0650             > type;
0651     };
0652 };
0653
0654 template<>
0655 struct push_back_impl< aux::vector_tag<4> >
0656 {
0657     template< typename Vector, typename T > struct apply
0658     {
0659         typedef vector5<
0660               typename Vector::item0, typename Vector::item1
0661             , typename Vector::item2, typename Vector::item3
0662               ,
0663               T
0664             > type;
0665     };
0666 };
0667
0668 template<>
0669 struct pop_back_impl< aux::vector_tag<5> >
0670 {
0671     template< typename Vector > struct apply
0672     {
0673         typedef vector4<
0674               typename Vector::item0, typename Vector::item1
0675             , typename Vector::item2, typename Vector::item3
0676             > type;
0677     };
0678 };
0679
0680 namespace aux {
0681 template<> struct v_at_impl<5>
0682 {
0683     template< typename V_ > struct result_
0684     {
0685         typedef typename V_::item5 type;
0686     };
0687 };
0688
0689 }
0690
0691 template<>
0692 struct at_impl< aux::vector_tag<5> >
0693 {
0694     template< typename V_, typename N > struct apply
0695     {
0696         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0697             ::template result_<V_>::type type;
0698     };
0699 };
0700
0701 template<>
0702 struct front_impl< aux::vector_tag<5> >
0703 {
0704     template< typename Vector > struct apply
0705     {
0706         typedef typename Vector::item0 type;
0707     };
0708 };
0709
0710 template<>
0711 struct back_impl< aux::vector_tag<5> >
0712 {
0713     template< typename Vector > struct apply
0714     {
0715         typedef typename Vector::back type;
0716     };
0717 };
0718
0719 template<>
0720 struct empty_impl< aux::vector_tag<5> >
0721 {
0722     template< typename Vector > struct apply
0723         : false_
0724     {
0725     };
0726 };
0727
0728 template<>
0729 struct size_impl< aux::vector_tag<5> >
0730 {
0731     template< typename Vector > struct apply
0732         : long_<5>
0733     {
0734     };
0735 };
0736
0737 template<>
0738 struct O1_size_impl< aux::vector_tag<5> >
0739     : size_impl< aux::vector_tag<5> >
0740 {
0741 };
0742
0743 template<>
0744 struct clear_impl< aux::vector_tag<5> >
0745 {
0746     template< typename Vector > struct apply
0747     {
0748         typedef vector0<> type;
0749     };
0750 };
0751
0752 template<
0753       typename T0, typename T1, typename T2, typename T3, typename T4
0754     , typename T5
0755     >
0756 struct vector6
0757 {
0758     typedef aux::vector_tag<6> tag;
0759     typedef vector6 type;
0760     typedef T0 item0;
0761     typedef T1 item1;
0762     typedef T2 item2;
0763     typedef T3 item3;
0764     typedef T4 item4;
0765     typedef T5 item5;
0766
0767
0768     typedef void_ item6;
0769     typedef T5 back;
0770     typedef v_iter< type,0 > begin;
0771     typedef v_iter< type,6 > end;
0772 };
0773
0774 template<>
0775 struct push_front_impl< aux::vector_tag<5> >
0776 {
0777     template< typename Vector, typename T > struct apply
0778     {
0779         typedef vector6<
0780               T
0781               ,
0782               typename Vector::item0, typename Vector::item1
0783             , typename Vector::item2, typename Vector::item3
0784             , typename Vector::item4
0785             > type;
0786     };
0787 };
0788
0789 template<>
0790 struct pop_front_impl< aux::vector_tag<6> >
0791 {
0792     template< typename Vector > struct apply
0793     {
0794         typedef vector5<
0795               typename Vector::item1, typename Vector::item2
0796             , typename Vector::item3, typename Vector::item4
0797             , typename Vector::item5
0798             > type;
0799     };
0800 };
0801
0802 template<>
0803 struct push_back_impl< aux::vector_tag<5> >
0804 {
0805     template< typename Vector, typename T > struct apply
0806     {
0807         typedef vector6<
0808               typename Vector::item0, typename Vector::item1
0809             , typename Vector::item2, typename Vector::item3
0810             , typename Vector::item4
0811               ,
0812               T
0813             > type;
0814     };
0815 };
0816
0817 template<>
0818 struct pop_back_impl< aux::vector_tag<6> >
0819 {
0820     template< typename Vector > struct apply
0821     {
0822         typedef vector5<
0823               typename Vector::item0, typename Vector::item1
0824             , typename Vector::item2, typename Vector::item3
0825             , typename Vector::item4
0826             > type;
0827     };
0828 };
0829
0830 namespace aux {
0831 template<> struct v_at_impl<6>
0832 {
0833     template< typename V_ > struct result_
0834     {
0835         typedef typename V_::item6 type;
0836     };
0837 };
0838
0839 }
0840
0841 template<>
0842 struct at_impl< aux::vector_tag<6> >
0843 {
0844     template< typename V_, typename N > struct apply
0845     {
0846         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0847             ::template result_<V_>::type type;
0848     };
0849 };
0850
0851 template<>
0852 struct front_impl< aux::vector_tag<6> >
0853 {
0854     template< typename Vector > struct apply
0855     {
0856         typedef typename Vector::item0 type;
0857     };
0858 };
0859
0860 template<>
0861 struct back_impl< aux::vector_tag<6> >
0862 {
0863     template< typename Vector > struct apply
0864     {
0865         typedef typename Vector::back type;
0866     };
0867 };
0868
0869 template<>
0870 struct empty_impl< aux::vector_tag<6> >
0871 {
0872     template< typename Vector > struct apply
0873         : false_
0874     {
0875     };
0876 };
0877
0878 template<>
0879 struct size_impl< aux::vector_tag<6> >
0880 {
0881     template< typename Vector > struct apply
0882         : long_<6>
0883     {
0884     };
0885 };
0886
0887 template<>
0888 struct O1_size_impl< aux::vector_tag<6> >
0889     : size_impl< aux::vector_tag<6> >
0890 {
0891 };
0892
0893 template<>
0894 struct clear_impl< aux::vector_tag<6> >
0895 {
0896     template< typename Vector > struct apply
0897     {
0898         typedef vector0<> type;
0899     };
0900 };
0901
0902 template<
0903       typename T0, typename T1, typename T2, typename T3, typename T4
0904     , typename T5, typename T6
0905     >
0906 struct vector7
0907 {
0908     typedef aux::vector_tag<7> tag;
0909     typedef vector7 type;
0910     typedef T0 item0;
0911     typedef T1 item1;
0912     typedef T2 item2;
0913     typedef T3 item3;
0914     typedef T4 item4;
0915     typedef T5 item5;
0916     typedef T6 item6;
0917
0918
0919     typedef void_ item7;
0920     typedef T6 back;
0921     typedef v_iter< type,0 > begin;
0922     typedef v_iter< type,7 > end;
0923 };
0924
0925 template<>
0926 struct push_front_impl< aux::vector_tag<6> >
0927 {
0928     template< typename Vector, typename T > struct apply
0929     {
0930         typedef vector7<
0931               T
0932               ,
0933               typename Vector::item0, typename Vector::item1
0934             , typename Vector::item2, typename Vector::item3
0935             , typename Vector::item4, typename Vector::item5
0936             > type;
0937     };
0938 };
0939
0940 template<>
0941 struct pop_front_impl< aux::vector_tag<7> >
0942 {
0943     template< typename Vector > struct apply
0944     {
0945         typedef vector6<
0946               typename Vector::item1, typename Vector::item2
0947             , typename Vector::item3, typename Vector::item4
0948             , typename Vector::item5, typename Vector::item6
0949             > type;
0950     };
0951 };
0952
0953 template<>
0954 struct push_back_impl< aux::vector_tag<6> >
0955 {
0956     template< typename Vector, typename T > struct apply
0957     {
0958         typedef vector7<
0959               typename Vector::item0, typename Vector::item1
0960             , typename Vector::item2, typename Vector::item3
0961             , typename Vector::item4, typename Vector::item5
0962               ,
0963               T
0964             > type;
0965     };
0966 };
0967
0968 template<>
0969 struct pop_back_impl< aux::vector_tag<7> >
0970 {
0971     template< typename Vector > struct apply
0972     {
0973         typedef vector6<
0974               typename Vector::item0, typename Vector::item1
0975             , typename Vector::item2, typename Vector::item3
0976             , typename Vector::item4, typename Vector::item5
0977             > type;
0978     };
0979 };
0980
0981 namespace aux {
0982 template<> struct v_at_impl<7>
0983 {
0984     template< typename V_ > struct result_
0985     {
0986         typedef typename V_::item7 type;
0987     };
0988 };
0989
0990 }
0991
0992 template<>
0993 struct at_impl< aux::vector_tag<7> >
0994 {
0995     template< typename V_, typename N > struct apply
0996     {
0997         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
0998             ::template result_<V_>::type type;
0999     };
1000 };
1001
1002 template<>
1003 struct front_impl< aux::vector_tag<7> >
1004 {
1005     template< typename Vector > struct apply
1006     {
1007         typedef typename Vector::item0 type;
1008     };
1009 };
1010
1011 template<>
1012 struct back_impl< aux::vector_tag<7> >
1013 {
1014     template< typename Vector > struct apply
1015     {
1016         typedef typename Vector::back type;
1017     };
1018 };
1019
1020 template<>
1021 struct empty_impl< aux::vector_tag<7> >
1022 {
1023     template< typename Vector > struct apply
1024         : false_
1025     {
1026     };
1027 };
1028
1029 template<>
1030 struct size_impl< aux::vector_tag<7> >
1031 {
1032     template< typename Vector > struct apply
1033         : long_<7>
1034     {
1035     };
1036 };
1037
1038 template<>
1039 struct O1_size_impl< aux::vector_tag<7> >
1040     : size_impl< aux::vector_tag<7> >
1041 {
1042 };
1043
1044 template<>
1045 struct clear_impl< aux::vector_tag<7> >
1046 {
1047     template< typename Vector > struct apply
1048     {
1049         typedef vector0<> type;
1050     };
1051 };
1052
1053 template<
1054       typename T0, typename T1, typename T2, typename T3, typename T4
1055     , typename T5, typename T6, typename T7
1056     >
1057 struct vector8
1058 {
1059     typedef aux::vector_tag<8> tag;
1060     typedef vector8 type;
1061     typedef T0 item0;
1062     typedef T1 item1;
1063     typedef T2 item2;
1064     typedef T3 item3;
1065     typedef T4 item4;
1066     typedef T5 item5;
1067     typedef T6 item6;
1068     typedef T7 item7;
1069
1070
1071     typedef void_ item8;
1072     typedef T7 back;
1073     typedef v_iter< type,0 > begin;
1074     typedef v_iter< type,8 > end;
1075 };
1076
1077 template<>
1078 struct push_front_impl< aux::vector_tag<7> >
1079 {
1080     template< typename Vector, typename T > struct apply
1081     {
1082         typedef vector8<
1083               T
1084               ,
1085               typename Vector::item0, typename Vector::item1
1086             , typename Vector::item2, typename Vector::item3
1087             , typename Vector::item4, typename Vector::item5
1088             , typename Vector::item6
1089             > type;
1090     };
1091 };
1092
1093 template<>
1094 struct pop_front_impl< aux::vector_tag<8> >
1095 {
1096     template< typename Vector > struct apply
1097     {
1098         typedef vector7<
1099               typename Vector::item1, typename Vector::item2
1100             , typename Vector::item3, typename Vector::item4
1101             , typename Vector::item5, typename Vector::item6
1102             , typename Vector::item7
1103             > type;
1104     };
1105 };
1106
1107 template<>
1108 struct push_back_impl< aux::vector_tag<7> >
1109 {
1110     template< typename Vector, typename T > struct apply
1111     {
1112         typedef vector8<
1113               typename Vector::item0, typename Vector::item1
1114             , typename Vector::item2, typename Vector::item3
1115             , typename Vector::item4, typename Vector::item5
1116             , typename Vector::item6
1117               ,
1118               T
1119             > type;
1120     };
1121 };
1122
1123 template<>
1124 struct pop_back_impl< aux::vector_tag<8> >
1125 {
1126     template< typename Vector > struct apply
1127     {
1128         typedef vector7<
1129               typename Vector::item0, typename Vector::item1
1130             , typename Vector::item2, typename Vector::item3
1131             , typename Vector::item4, typename Vector::item5
1132             , typename Vector::item6
1133             > type;
1134     };
1135 };
1136
1137 namespace aux {
1138 template<> struct v_at_impl<8>
1139 {
1140     template< typename V_ > struct result_
1141     {
1142         typedef typename V_::item8 type;
1143     };
1144 };
1145
1146 }
1147
1148 template<>
1149 struct at_impl< aux::vector_tag<8> >
1150 {
1151     template< typename V_, typename N > struct apply
1152     {
1153         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
1154             ::template result_<V_>::type type;
1155     };
1156 };
1157
1158 template<>
1159 struct front_impl< aux::vector_tag<8> >
1160 {
1161     template< typename Vector > struct apply
1162     {
1163         typedef typename Vector::item0 type;
1164     };
1165 };
1166
1167 template<>
1168 struct back_impl< aux::vector_tag<8> >
1169 {
1170     template< typename Vector > struct apply
1171     {
1172         typedef typename Vector::back type;
1173     };
1174 };
1175
1176 template<>
1177 struct empty_impl< aux::vector_tag<8> >
1178 {
1179     template< typename Vector > struct apply
1180         : false_
1181     {
1182     };
1183 };
1184
1185 template<>
1186 struct size_impl< aux::vector_tag<8> >
1187 {
1188     template< typename Vector > struct apply
1189         : long_<8>
1190     {
1191     };
1192 };
1193
1194 template<>
1195 struct O1_size_impl< aux::vector_tag<8> >
1196     : size_impl< aux::vector_tag<8> >
1197 {
1198 };
1199
1200 template<>
1201 struct clear_impl< aux::vector_tag<8> >
1202 {
1203     template< typename Vector > struct apply
1204     {
1205         typedef vector0<> type;
1206     };
1207 };
1208
1209 template<
1210       typename T0, typename T1, typename T2, typename T3, typename T4
1211     , typename T5, typename T6, typename T7, typename T8
1212     >
1213 struct vector9
1214 {
1215     typedef aux::vector_tag<9> tag;
1216     typedef vector9 type;
1217     typedef T0 item0;
1218     typedef T1 item1;
1219     typedef T2 item2;
1220     typedef T3 item3;
1221     typedef T4 item4;
1222     typedef T5 item5;
1223     typedef T6 item6;
1224     typedef T7 item7;
1225     typedef T8 item8;
1226
1227
1228     typedef void_ item9;
1229     typedef T8 back;
1230     typedef v_iter< type,0 > begin;
1231     typedef v_iter< type,9 > end;
1232 };
1233
1234 template<>
1235 struct push_front_impl< aux::vector_tag<8> >
1236 {
1237     template< typename Vector, typename T > struct apply
1238     {
1239         typedef vector9<
1240               T
1241               ,
1242               typename Vector::item0, typename Vector::item1
1243             , typename Vector::item2, typename Vector::item3
1244             , typename Vector::item4, typename Vector::item5
1245             , typename Vector::item6, typename Vector::item7
1246             > type;
1247     };
1248 };
1249
1250 template<>
1251 struct pop_front_impl< aux::vector_tag<9> >
1252 {
1253     template< typename Vector > struct apply
1254     {
1255         typedef vector8<
1256               typename Vector::item1, typename Vector::item2
1257             , typename Vector::item3, typename Vector::item4
1258             , typename Vector::item5, typename Vector::item6
1259             , typename Vector::item7, typename Vector::item8
1260             > type;
1261     };
1262 };
1263
1264 template<>
1265 struct push_back_impl< aux::vector_tag<8> >
1266 {
1267     template< typename Vector, typename T > struct apply
1268     {
1269         typedef vector9<
1270               typename Vector::item0, typename Vector::item1
1271             , typename Vector::item2, typename Vector::item3
1272             , typename Vector::item4, typename Vector::item5
1273             , typename Vector::item6, typename Vector::item7
1274               ,
1275               T
1276             > type;
1277     };
1278 };
1279
1280 template<>
1281 struct pop_back_impl< aux::vector_tag<9> >
1282 {
1283     template< typename Vector > struct apply
1284     {
1285         typedef vector8<
1286               typename Vector::item0, typename Vector::item1
1287             , typename Vector::item2, typename Vector::item3
1288             , typename Vector::item4, typename Vector::item5
1289             , typename Vector::item6, typename Vector::item7
1290             > type;
1291     };
1292 };
1293
1294 namespace aux {
1295 template<> struct v_at_impl<9>
1296 {
1297     template< typename V_ > struct result_
1298     {
1299         typedef typename V_::item9 type;
1300     };
1301 };
1302
1303 }
1304
1305 template<>
1306 struct at_impl< aux::vector_tag<9> >
1307 {
1308     template< typename V_, typename N > struct apply
1309     {
1310         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
1311             ::template result_<V_>::type type;
1312     };
1313 };
1314
1315 template<>
1316 struct front_impl< aux::vector_tag<9> >
1317 {
1318     template< typename Vector > struct apply
1319     {
1320         typedef typename Vector::item0 type;
1321     };
1322 };
1323
1324 template<>
1325 struct back_impl< aux::vector_tag<9> >
1326 {
1327     template< typename Vector > struct apply
1328     {
1329         typedef typename Vector::back type;
1330     };
1331 };
1332
1333 template<>
1334 struct empty_impl< aux::vector_tag<9> >
1335 {
1336     template< typename Vector > struct apply
1337         : false_
1338     {
1339     };
1340 };
1341
1342 template<>
1343 struct size_impl< aux::vector_tag<9> >
1344 {
1345     template< typename Vector > struct apply
1346         : long_<9>
1347     {
1348     };
1349 };
1350
1351 template<>
1352 struct O1_size_impl< aux::vector_tag<9> >
1353     : size_impl< aux::vector_tag<9> >
1354 {
1355 };
1356
1357 template<>
1358 struct clear_impl< aux::vector_tag<9> >
1359 {
1360     template< typename Vector > struct apply
1361     {
1362         typedef vector0<> type;
1363     };
1364 };
1365
1366 template<
1367       typename T0, typename T1, typename T2, typename T3, typename T4
1368     , typename T5, typename T6, typename T7, typename T8, typename T9
1369     >
1370 struct vector10
1371 {
1372     typedef aux::vector_tag<10> tag;
1373     typedef vector10 type;
1374     typedef T0 item0;
1375     typedef T1 item1;
1376     typedef T2 item2;
1377     typedef T3 item3;
1378     typedef T4 item4;
1379     typedef T5 item5;
1380     typedef T6 item6;
1381     typedef T7 item7;
1382     typedef T8 item8;
1383     typedef T9 item9;
1384
1385
1386     typedef void_ item10;
1387     typedef T9 back;
1388     typedef v_iter< type,0 > begin;
1389     typedef v_iter< type,10 > end;
1390 };
1391
1392 template<>
1393 struct push_front_impl< aux::vector_tag<9> >
1394 {
1395     template< typename Vector, typename T > struct apply
1396     {
1397         typedef vector10<
1398               T
1399               ,
1400               typename Vector::item0, typename Vector::item1
1401             , typename Vector::item2, typename Vector::item3
1402             , typename Vector::item4, typename Vector::item5
1403             , typename Vector::item6, typename Vector::item7
1404             , typename Vector::item8
1405             > type;
1406     };
1407 };
1408
1409 template<>
1410 struct pop_front_impl< aux::vector_tag<10> >
1411 {
1412     template< typename Vector > struct apply
1413     {
1414         typedef vector9<
1415               typename Vector::item1, typename Vector::item2
1416             , typename Vector::item3, typename Vector::item4
1417             , typename Vector::item5, typename Vector::item6
1418             , typename Vector::item7, typename Vector::item8
1419             , typename Vector::item9
1420             > type;
1421     };
1422 };
1423
1424 template<>
1425 struct push_back_impl< aux::vector_tag<9> >
1426 {
1427     template< typename Vector, typename T > struct apply
1428     {
1429         typedef vector10<
1430               typename Vector::item0, typename Vector::item1
1431             , typename Vector::item2, typename Vector::item3
1432             , typename Vector::item4, typename Vector::item5
1433             , typename Vector::item6, typename Vector::item7
1434             , typename Vector::item8
1435               ,
1436               T
1437             > type;
1438     };
1439 };
1440
1441 template<>
1442 struct pop_back_impl< aux::vector_tag<10> >
1443 {
1444     template< typename Vector > struct apply
1445     {
1446         typedef vector9<
1447               typename Vector::item0, typename Vector::item1
1448             , typename Vector::item2, typename Vector::item3
1449             , typename Vector::item4, typename Vector::item5
1450             , typename Vector::item6, typename Vector::item7
1451             , typename Vector::item8
1452             > type;
1453     };
1454 };
1455
1456 namespace aux {
1457 template<> struct v_at_impl<10>
1458 {
1459     template< typename V_ > struct result_
1460     {
1461         typedef typename V_::item10 type;
1462     };
1463 };
1464
1465 }
1466
1467 template<>
1468 struct at_impl< aux::vector_tag<10> >
1469 {
1470     template< typename V_, typename N > struct apply
1471     {
1472         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
1473             ::template result_<V_>::type type;
1474     };
1475 };
1476
1477 template<>
1478 struct front_impl< aux::vector_tag<10> >
1479 {
1480     template< typename Vector > struct apply
1481     {
1482         typedef typename Vector::item0 type;
1483     };
1484 };
1485
1486 template<>
1487 struct back_impl< aux::vector_tag<10> >
1488 {
1489     template< typename Vector > struct apply
1490     {
1491         typedef typename Vector::back type;
1492     };
1493 };
1494
1495 template<>
1496 struct empty_impl< aux::vector_tag<10> >
1497 {
1498     template< typename Vector > struct apply
1499         : false_
1500     {
1501     };
1502 };
1503
1504 template<>
1505 struct size_impl< aux::vector_tag<10> >
1506 {
1507     template< typename Vector > struct apply
1508         : long_<10>
1509     {
1510     };
1511 };
1512
1513 template<>
1514 struct O1_size_impl< aux::vector_tag<10> >
1515     : size_impl< aux::vector_tag<10> >
1516 {
1517 };
1518
1519 template<>
1520 struct clear_impl< aux::vector_tag<10> >
1521 {
1522     template< typename Vector > struct apply
1523     {
1524         typedef vector0<> type;
1525     };
1526 };
1527
1528 }}