boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp

   1
   2 // Copyright Aleksey Gurtovoy 2000-2004
   3 //
   4 // Distributed under the Boost Software License, Version 1.0.
   5 // (See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8
   9 // Preprocessed version of "boost/mpl/vector/vector10.hpp" header
  10 // -- DO NOT modify by hand!
  11
  12 namespace boost { namespace mpl {
  13
  14 namespace aux {
  15 template<> struct v_at_impl<0>
  16 {
  17     template< typename V_ > struct result_
  18     {
  19         typedef typename V_::item0 type;
  20     };
  21 };
  22
  23 }
  24
  25 template<>
  26 struct at_impl< aux::vector_tag<0> >
  27 {
  28     template< typename V_, typename N > struct apply
  29     {
  30         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
  31             ::template result_<V_>::type type;
  32     };
  33 };
  34
  35 template<>
  36 struct size_impl< aux::vector_tag<0> >
  37 {
  38     template< typename Vector > struct apply
  39         : long_<0>
  40     {
  41     };
  42 };
  43
  44 template<>
  45 struct O1_size_impl< aux::vector_tag<0> >
  46     : size_impl< aux::vector_tag<0> >
  47 {
  48 };
  49
  50 template<>
  51 struct clear_impl< aux::vector_tag<0> >
  52 {
  53     template< typename Vector > struct apply
  54     {
  55         typedef vector0<> type;
  56     };
  57 };
  58
  59 template<
  60       typename T0
  61     >
  62 struct vector1
  63 {
  64     typedef aux::vector_tag<1> tag;
  65     typedef vector1 type;
  66     typedef T0 item0;
  67     typedef void_ item1;
  68     typedef T0 back;
  69     typedef v_iter< type,0 > begin;
  70     typedef v_iter< type,1 > end;
  71 };
  72
  73 template<>
  74 struct push_front_impl< aux::vector_tag<0> >
  75 {
  76     template< typename Vector, typename T > struct apply
  77     {
  78         typedef vector1<
  79               T
  80             > type;
  81     };
  82 };
  83
  84 template<>
  85 struct pop_front_impl< aux::vector_tag<1> >
  86 {
  87     template< typename Vector > struct apply
  88     {
  89         typedef vector0<
  90
  91             > type;
  92     };
  93 };
  94
  95 template<>
  96 struct push_back_impl< aux::vector_tag<0> >
  97 {
  98     template< typename Vector, typename T > struct apply
  99     {
 100         typedef vector1<
 101
 102               T
 103             > type;
 104     };
 105 };
 106
 107 template<>
 108 struct pop_back_impl< aux::vector_tag<1> >
 109 {
 110     template< typename Vector > struct apply
 111     {
 112         typedef vector0<
 113
 114             > type;
 115     };
 116 };
 117
 118 namespace aux {
 119 template<> struct v_at_impl<1>
 120 {
 121     template< typename V_ > struct result_
 122     {
 123         typedef typename V_::item1 type;
 124     };
 125 };
 126
 127 }
 128
 129 template<>
 130 struct at_impl< aux::vector_tag<1> >
 131 {
 132     template< typename V_, typename N > struct apply
 133     {
 134         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 135             ::template result_<V_>::type type;
 136     };
 137 };
 138
 139 template<>
 140 struct front_impl< aux::vector_tag<1> >
 141 {
 142     template< typename Vector > struct apply
 143     {
 144         typedef typename Vector::item0 type;
 145     };
 146 };
 147
 148 template<>
 149 struct back_impl< aux::vector_tag<1> >
 150 {
 151     template< typename Vector > struct apply
 152     {
 153         typedef typename Vector::back type;
 154     };
 155 };
 156
 157 template<>
 158 struct empty_impl< aux::vector_tag<1> >
 159 {
 160     template< typename Vector > struct apply
 161         : false_
 162     {
 163     };
 164 };
 165
 166 template<>
 167 struct size_impl< aux::vector_tag<1> >
 168 {
 169     template< typename Vector > struct apply
 170         : long_<1>
 171     {
 172     };
 173 };
 174
 175 template<>
 176 struct O1_size_impl< aux::vector_tag<1> >
 177     : size_impl< aux::vector_tag<1> >
 178 {
 179 };
 180
 181 template<>
 182 struct clear_impl< aux::vector_tag<1> >
 183 {
 184     template< typename Vector > struct apply
 185     {
 186         typedef vector0<> type;
 187     };
 188 };
 189
 190 template<
 191       typename T0, typename T1
 192     >
 193 struct vector2
 194 {
 195     typedef aux::vector_tag<2> tag;
 196     typedef vector2 type;
 197     typedef T0 item0;
 198     typedef T1 item1;
 199
 200
 201     typedef void_ item2;
 202     typedef T1 back;
 203     typedef v_iter< type,0 > begin;
 204     typedef v_iter< type,2 > end;
 205 };
 206
 207 template<>
 208 struct push_front_impl< aux::vector_tag<1> >
 209 {
 210     template< typename Vector, typename T > struct apply
 211     {
 212         typedef vector2<
 213               T
 214               ,
 215               typename Vector::item0
 216             > type;
 217     };
 218 };
 219
 220 template<>
 221 struct pop_front_impl< aux::vector_tag<2> >
 222 {
 223     template< typename Vector > struct apply
 224     {
 225         typedef vector1<
 226               typename Vector::item1
 227             > type;
 228     };
 229 };
 230
 231 template<>
 232 struct push_back_impl< aux::vector_tag<1> >
 233 {
 234     template< typename Vector, typename T > struct apply
 235     {
 236         typedef vector2<
 237               typename Vector::item0
 238               ,
 239               T
 240             > type;
 241     };
 242 };
 243
 244 template<>
 245 struct pop_back_impl< aux::vector_tag<2> >
 246 {
 247     template< typename Vector > struct apply
 248     {
 249         typedef vector1<
 250               typename Vector::item0
 251             > type;
 252     };
 253 };
 254
 255 namespace aux {
 256 template<> struct v_at_impl<2>
 257 {
 258     template< typename V_ > struct result_
 259     {
 260         typedef typename V_::item2 type;
 261     };
 262 };
 263
 264 }
 265
 266 template<>
 267 struct at_impl< aux::vector_tag<2> >
 268 {
 269     template< typename V_, typename N > struct apply
 270     {
 271         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 272             ::template result_<V_>::type type;
 273     };
 274 };
 275
 276 template<>
 277 struct front_impl< aux::vector_tag<2> >
 278 {
 279     template< typename Vector > struct apply
 280     {
 281         typedef typename Vector::item0 type;
 282     };
 283 };
 284
 285 template<>
 286 struct back_impl< aux::vector_tag<2> >
 287 {
 288     template< typename Vector > struct apply
 289     {
 290         typedef typename Vector::back type;
 291     };
 292 };
 293
 294 template<>
 295 struct empty_impl< aux::vector_tag<2> >
 296 {
 297     template< typename Vector > struct apply
 298         : false_
 299     {
 300     };
 301 };
 302
 303 template<>
 304 struct size_impl< aux::vector_tag<2> >
 305 {
 306     template< typename Vector > struct apply
 307         : long_<2>
 308     {
 309     };
 310 };
 311
 312 template<>
 313 struct O1_size_impl< aux::vector_tag<2> >
 314     : size_impl< aux::vector_tag<2> >
 315 {
 316 };
 317
 318 template<>
 319 struct clear_impl< aux::vector_tag<2> >
 320 {
 321     template< typename Vector > struct apply
 322     {
 323         typedef vector0<> type;
 324     };
 325 };
 326
 327 template<
 328       typename T0, typename T1, typename T2
 329     >
 330 struct vector3
 331 {
 332     typedef aux::vector_tag<3> tag;
 333     typedef vector3 type;
 334     typedef T0 item0;
 335     typedef T1 item1;
 336     typedef T2 item2;
 337
 338
 339     typedef void_ item3;
 340     typedef T2 back;
 341     typedef v_iter< type,0 > begin;
 342     typedef v_iter< type,3 > end;
 343 };
 344
 345 template<>
 346 struct push_front_impl< aux::vector_tag<2> >
 347 {
 348     template< typename Vector, typename T > struct apply
 349     {
 350         typedef vector3<
 351               T
 352               ,
 353               typename Vector::item0, typename Vector::item1
 354             > type;
 355     };
 356 };
 357
 358 template<>
 359 struct pop_front_impl< aux::vector_tag<3> >
 360 {
 361     template< typename Vector > struct apply
 362     {
 363         typedef vector2<
 364               typename Vector::item1, typename Vector::item2
 365             > type;
 366     };
 367 };
 368
 369 template<>
 370 struct push_back_impl< aux::vector_tag<2> >
 371 {
 372     template< typename Vector, typename T > struct apply
 373     {
 374         typedef vector3<
 375               typename Vector::item0, typename Vector::item1
 376               ,
 377               T
 378             > type;
 379     };
 380 };
 381
 382 template<>
 383 struct pop_back_impl< aux::vector_tag<3> >
 384 {
 385     template< typename Vector > struct apply
 386     {
 387         typedef vector2<
 388               typename Vector::item0, typename Vector::item1
 389             > type;
 390     };
 391 };
 392
 393 namespace aux {
 394 template<> struct v_at_impl<3>
 395 {
 396     template< typename V_ > struct result_
 397     {
 398         typedef typename V_::item3 type;
 399     };
 400 };
 401
 402 }
 403
 404 template<>
 405 struct at_impl< aux::vector_tag<3> >
 406 {
 407     template< typename V_, typename N > struct apply
 408     {
 409         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 410             ::template result_<V_>::type type;
 411     };
 412 };
 413
 414 template<>
 415 struct front_impl< aux::vector_tag<3> >
 416 {
 417     template< typename Vector > struct apply
 418     {
 419         typedef typename Vector::item0 type;
 420     };
 421 };
 422
 423 template<>
 424 struct back_impl< aux::vector_tag<3> >
 425 {
 426     template< typename Vector > struct apply
 427     {
 428         typedef typename Vector::back type;
 429     };
 430 };
 431
 432 template<>
 433 struct empty_impl< aux::vector_tag<3> >
 434 {
 435     template< typename Vector > struct apply
 436         : false_
 437     {
 438     };
 439 };
 440
 441 template<>
 442 struct size_impl< aux::vector_tag<3> >
 443 {
 444     template< typename Vector > struct apply
 445         : long_<3>
 446     {
 447     };
 448 };
 449
 450 template<>
 451 struct O1_size_impl< aux::vector_tag<3> >
 452     : size_impl< aux::vector_tag<3> >
 453 {
 454 };
 455
 456 template<>
 457 struct clear_impl< aux::vector_tag<3> >
 458 {
 459     template< typename Vector > struct apply
 460     {
 461         typedef vector0<> type;
 462     };
 463 };
 464
 465 template<
 466       typename T0, typename T1, typename T2, typename T3
 467     >
 468 struct vector4
 469 {
 470     typedef aux::vector_tag<4> tag;
 471     typedef vector4 type;
 472     typedef T0 item0;
 473     typedef T1 item1;
 474     typedef T2 item2;
 475     typedef T3 item3;
 476
 477
 478     typedef void_ item4;
 479     typedef T3 back;
 480     typedef v_iter< type,0 > begin;
 481     typedef v_iter< type,4 > end;
 482 };
 483
 484 template<>
 485 struct push_front_impl< aux::vector_tag<3> >
 486 {
 487     template< typename Vector, typename T > struct apply
 488     {
 489         typedef vector4<
 490               T
 491               ,
 492               typename Vector::item0, typename Vector::item1
 493             , typename Vector::item2
 494             > type;
 495     };
 496 };
 497
 498 template<>
 499 struct pop_front_impl< aux::vector_tag<4> >
 500 {
 501     template< typename Vector > struct apply
 502     {
 503         typedef vector3<
 504               typename Vector::item1, typename Vector::item2
 505             , typename Vector::item3
 506             > type;
 507     };
 508 };
 509
 510 template<>
 511 struct push_back_impl< aux::vector_tag<3> >
 512 {
 513     template< typename Vector, typename T > struct apply
 514     {
 515         typedef vector4<
 516               typename Vector::item0, typename Vector::item1
 517             , typename Vector::item2
 518               ,
 519               T
 520             > type;
 521     };
 522 };
 523
 524 template<>
 525 struct pop_back_impl< aux::vector_tag<4> >
 526 {
 527     template< typename Vector > struct apply
 528     {
 529         typedef vector3<
 530               typename Vector::item0, typename Vector::item1
 531             , typename Vector::item2
 532             > type;
 533     };
 534 };
 535
 536 namespace aux {
 537 template<> struct v_at_impl<4>
 538 {
 539     template< typename V_ > struct result_
 540     {
 541         typedef typename V_::item4 type;
 542     };
 543 };
 544
 545 }
 546
 547 template<>
 548 struct at_impl< aux::vector_tag<4> >
 549 {
 550     template< typename V_, typename N > struct apply
 551     {
 552         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 553             ::template result_<V_>::type type;
 554     };
 555 };
 556
 557 template<>
 558 struct front_impl< aux::vector_tag<4> >
 559 {
 560     template< typename Vector > struct apply
 561     {
 562         typedef typename Vector::item0 type;
 563     };
 564 };
 565
 566 template<>
 567 struct back_impl< aux::vector_tag<4> >
 568 {
 569     template< typename Vector > struct apply
 570     {
 571         typedef typename Vector::back type;
 572     };
 573 };
 574
 575 template<>
 576 struct empty_impl< aux::vector_tag<4> >
 577 {
 578     template< typename Vector > struct apply
 579         : false_
 580     {
 581     };
 582 };
 583
 584 template<>
 585 struct size_impl< aux::vector_tag<4> >
 586 {
 587     template< typename Vector > struct apply
 588         : long_<4>
 589     {
 590     };
 591 };
 592
 593 template<>
 594 struct O1_size_impl< aux::vector_tag<4> >
 595     : size_impl< aux::vector_tag<4> >
 596 {
 597 };
 598
 599 template<>
 600 struct clear_impl< aux::vector_tag<4> >
 601 {
 602     template< typename Vector > struct apply
 603     {
 604         typedef vector0<> type;
 605     };
 606 };
 607
 608 template<
 609       typename T0, typename T1, typename T2, typename T3, typename T4
 610     >
 611 struct vector5
 612 {
 613     typedef aux::vector_tag<5> tag;
 614     typedef vector5 type;
 615     typedef T0 item0;
 616     typedef T1 item1;
 617     typedef T2 item2;
 618     typedef T3 item3;
 619     typedef T4 item4;
 620
 621
 622     typedef void_ item5;
 623     typedef T4 back;
 624     typedef v_iter< type,0 > begin;
 625     typedef v_iter< type,5 > end;
 626 };
 627
 628 template<>
 629 struct push_front_impl< aux::vector_tag<4> >
 630 {
 631     template< typename Vector, typename T > struct apply
 632     {
 633         typedef vector5<
 634               T
 635               ,
 636               typename Vector::item0, typename Vector::item1
 637             , typename Vector::item2, typename Vector::item3
 638             > type;
 639     };
 640 };
 641
 642 template<>
 643 struct pop_front_impl< aux::vector_tag<5> >
 644 {
 645     template< typename Vector > struct apply
 646     {
 647         typedef vector4<
 648               typename Vector::item1, typename Vector::item2
 649             , typename Vector::item3, typename Vector::item4
 650             > type;
 651     };
 652 };
 653
 654 template<>
 655 struct push_back_impl< aux::vector_tag<4> >
 656 {
 657     template< typename Vector, typename T > struct apply
 658     {
 659         typedef vector5<
 660               typename Vector::item0, typename Vector::item1
 661             , typename Vector::item2, typename Vector::item3
 662               ,
 663               T
 664             > type;
 665     };
 666 };
 667
 668 template<>
 669 struct pop_back_impl< aux::vector_tag<5> >
 670 {
 671     template< typename Vector > struct apply
 672     {
 673         typedef vector4<
 674               typename Vector::item0, typename Vector::item1
 675             , typename Vector::item2, typename Vector::item3
 676             > type;
 677     };
 678 };
 679
 680 namespace aux {
 681 template<> struct v_at_impl<5>
 682 {
 683     template< typename V_ > struct result_
 684     {
 685         typedef typename V_::item5 type;
 686     };
 687 };
 688
 689 }
 690
 691 template<>
 692 struct at_impl< aux::vector_tag<5> >
 693 {
 694     template< typename V_, typename N > struct apply
 695     {
 696         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 697             ::template result_<V_>::type type;
 698     };
 699 };
 700
 701 template<>
 702 struct front_impl< aux::vector_tag<5> >
 703 {
 704     template< typename Vector > struct apply
 705     {
 706         typedef typename Vector::item0 type;
 707     };
 708 };
 709
 710 template<>
 711 struct back_impl< aux::vector_tag<5> >
 712 {
 713     template< typename Vector > struct apply
 714     {
 715         typedef typename Vector::back type;
 716     };
 717 };
 718
 719 template<>
 720 struct empty_impl< aux::vector_tag<5> >
 721 {
 722     template< typename Vector > struct apply
 723         : false_
 724     {
 725     };
 726 };
 727
 728 template<>
 729 struct size_impl< aux::vector_tag<5> >
 730 {
 731     template< typename Vector > struct apply
 732         : long_<5>
 733     {
 734     };
 735 };
 736
 737 template<>
 738 struct O1_size_impl< aux::vector_tag<5> >
 739     : size_impl< aux::vector_tag<5> >
 740 {
 741 };
 742
 743 template<>
 744 struct clear_impl< aux::vector_tag<5> >
 745 {
 746     template< typename Vector > struct apply
 747     {
 748         typedef vector0<> type;
 749     };
 750 };
 751
 752 template<
 753       typename T0, typename T1, typename T2, typename T3, typename T4
 754     , typename T5
 755     >
 756 struct vector6
 757 {
 758     typedef aux::vector_tag<6> tag;
 759     typedef vector6 type;
 760     typedef T0 item0;
 761     typedef T1 item1;
 762     typedef T2 item2;
 763     typedef T3 item3;
 764     typedef T4 item4;
 765     typedef T5 item5;
 766
 767
 768     typedef void_ item6;
 769     typedef T5 back;
 770     typedef v_iter< type,0 > begin;
 771     typedef v_iter< type,6 > end;
 772 };
 773
 774 template<>
 775 struct push_front_impl< aux::vector_tag<5> >
 776 {
 777     template< typename Vector, typename T > struct apply
 778     {
 779         typedef vector6<
 780               T
 781               ,
 782               typename Vector::item0, typename Vector::item1
 783             , typename Vector::item2, typename Vector::item3
 784             , typename Vector::item4
 785             > type;
 786     };
 787 };
 788
 789 template<>
 790 struct pop_front_impl< aux::vector_tag<6> >
 791 {
 792     template< typename Vector > struct apply
 793     {
 794         typedef vector5<
 795               typename Vector::item1, typename Vector::item2
 796             , typename Vector::item3, typename Vector::item4
 797             , typename Vector::item5
 798             > type;
 799     };
 800 };
 801
 802 template<>
 803 struct push_back_impl< aux::vector_tag<5> >
 804 {
 805     template< typename Vector, typename T > struct apply
 806     {
 807         typedef vector6<
 808               typename Vector::item0, typename Vector::item1
 809             , typename Vector::item2, typename Vector::item3
 810             , typename Vector::item4
 811               ,
 812               T
 813             > type;
 814     };
 815 };
 816
 817 template<>
 818 struct pop_back_impl< aux::vector_tag<6> >
 819 {
 820     template< typename Vector > struct apply
 821     {
 822         typedef vector5<
 823               typename Vector::item0, typename Vector::item1
 824             , typename Vector::item2, typename Vector::item3
 825             , typename Vector::item4
 826             > type;
 827     };
 828 };
 829
 830 namespace aux {
 831 template<> struct v_at_impl<6>
 832 {
 833     template< typename V_ > struct result_
 834     {
 835         typedef typename V_::item6 type;
 836     };
 837 };
 838
 839 }
 840
 841 template<>
 842 struct at_impl< aux::vector_tag<6> >
 843 {
 844     template< typename V_, typename N > struct apply
 845     {
 846         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 847             ::template result_<V_>::type type;
 848     };
 849 };
 850
 851 template<>
 852 struct front_impl< aux::vector_tag<6> >
 853 {
 854     template< typename Vector > struct apply
 855     {
 856         typedef typename Vector::item0 type;
 857     };
 858 };
 859
 860 template<>
 861 struct back_impl< aux::vector_tag<6> >
 862 {
 863     template< typename Vector > struct apply
 864     {
 865         typedef typename Vector::back type;
 866     };
 867 };
 868
 869 template<>
 870 struct empty_impl< aux::vector_tag<6> >
 871 {
 872     template< typename Vector > struct apply
 873         : false_
 874     {
 875     };
 876 };
 877
 878 template<>
 879 struct size_impl< aux::vector_tag<6> >
 880 {
 881     template< typename Vector > struct apply
 882         : long_<6>
 883     {
 884     };
 885 };
 886
 887 template<>
 888 struct O1_size_impl< aux::vector_tag<6> >
 889     : size_impl< aux::vector_tag<6> >
 890 {
 891 };
 892
 893 template<>
 894 struct clear_impl< aux::vector_tag<6> >
 895 {
 896     template< typename Vector > struct apply
 897     {
 898         typedef vector0<> type;
 899     };
 900 };
 901
 902 template<
 903       typename T0, typename T1, typename T2, typename T3, typename T4
 904     , typename T5, typename T6
 905     >
 906 struct vector7
 907 {
 908     typedef aux::vector_tag<7> tag;
 909     typedef vector7 type;
 910     typedef T0 item0;
 911     typedef T1 item1;
 912     typedef T2 item2;
 913     typedef T3 item3;
 914     typedef T4 item4;
 915     typedef T5 item5;
 916     typedef T6 item6;
 917
 918
 919     typedef void_ item7;
 920     typedef T6 back;
 921     typedef v_iter< type,0 > begin;
 922     typedef v_iter< type,7 > end;
 923 };
 924
 925 template<>
 926 struct push_front_impl< aux::vector_tag<6> >
 927 {
 928     template< typename Vector, typename T > struct apply
 929     {
 930         typedef vector7<
 931               T
 932               ,
 933               typename Vector::item0, typename Vector::item1
 934             , typename Vector::item2, typename Vector::item3
 935             , typename Vector::item4, typename Vector::item5
 936             > type;
 937     };
 938 };
 939
 940 template<>
 941 struct pop_front_impl< aux::vector_tag<7> >
 942 {
 943     template< typename Vector > struct apply
 944     {
 945         typedef vector6<
 946               typename Vector::item1, typename Vector::item2
 947             , typename Vector::item3, typename Vector::item4
 948             , typename Vector::item5, typename Vector::item6
 949             > type;
 950     };
 951 };
 952
 953 template<>
 954 struct push_back_impl< aux::vector_tag<6> >
 955 {
 956     template< typename Vector, typename T > struct apply
 957     {
 958         typedef vector7<
 959               typename Vector::item0, typename Vector::item1
 960             , typename Vector::item2, typename Vector::item3
 961             , typename Vector::item4, typename Vector::item5
 962               ,
 963               T
 964             > type;
 965     };
 966 };
 967
 968 template<>
 969 struct pop_back_impl< aux::vector_tag<7> >
 970 {
 971     template< typename Vector > struct apply
 972     {
 973         typedef vector6<
 974               typename Vector::item0, typename Vector::item1
 975             , typename Vector::item2, typename Vector::item3
 976             , typename Vector::item4, typename Vector::item5
 977             > type;
 978     };
 979 };
 980
 981 namespace aux {
 982 template<> struct v_at_impl<7>
 983 {
 984     template< typename V_ > struct result_
 985     {
 986         typedef typename V_::item7 type;
 987     };
 988 };
 989
 990 }
 991
 992 template<>
 993 struct at_impl< aux::vector_tag<7> >
 994 {
 995     template< typename V_, typename N > struct apply
 996     {
 997         typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
 998             ::template result_<V_>::type type;
 999     };
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 }}