boost/fusion/container/vector/detail/preprocessed/vector10.hpp

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