Back to home page

EIC code displayed by LXR

 
 

    


File indexing completed on 2025-01-18 09:34:05

0001 /*=============================================================================
0002     Copyright (c) 2001-2011 Joel de Guzman
0003 
0004     Distributed under the Boost Software License, Version 1.0. (See accompanying
0005     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0006 
0007     This is an auto-generated file. Do not edit!
0008 ==============================================================================*/
0009 namespace boost { namespace fusion
0010 {
0011     struct vector_tag;
0012     struct fusion_sequence_tag;
0013     struct random_access_traversal_tag;
0014     template <typename T0>
0015     struct vector_data1
0016     {
0017         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0018         vector_data1()
0019             : m0() {}
0020 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0021         template <typename U0>
0022 # if !defined(BOOST_CLANG)
0023         BOOST_CXX14_CONSTEXPR
0024 # endif
0025         BOOST_FUSION_GPU_ENABLED
0026         vector_data1(U0 && arg0
0027           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
0028         )
0029             : m0(std::forward<U0>( arg0)) {}
0030         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0031         vector_data1(
0032             vector_data1&& other)
0033             : m0(std::forward<T0>( other.m0)) {}
0034 # endif
0035 # if !defined(BOOST_CLANG)
0036     BOOST_CONSTEXPR
0037 # endif
0038         BOOST_FUSION_GPU_ENABLED
0039         vector_data1(
0040             typename detail::call_param<T0 >::type arg0)
0041             : m0(arg0) {}
0042         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0043         vector_data1(
0044             vector_data1 const& other)
0045             : m0(other.m0) {}
0046         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0047         vector_data1&
0048         operator=(vector_data1 const& vec)
0049         {
0050             this->m0 = vec.m0;
0051             return *this;
0052         }
0053         template <typename Sequence>
0054 # if !defined(BOOST_CLANG)
0055     BOOST_CXX14_CONSTEXPR
0056 # endif
0057         BOOST_FUSION_GPU_ENABLED
0058         static vector_data1
0059         init_from_sequence(Sequence const& seq)
0060         {
0061             typedef typename result_of::begin<Sequence const>::type I0;
0062             I0 i0 = fusion::begin(seq);
0063             
0064             return vector_data1(*i0);
0065         }
0066         template <typename Sequence>
0067 # if !defined(BOOST_CLANG)
0068     BOOST_CXX14_CONSTEXPR
0069 # endif
0070         BOOST_FUSION_GPU_ENABLED
0071         static vector_data1
0072         init_from_sequence(Sequence& seq)
0073         {
0074             typedef typename result_of::begin<Sequence>::type I0;
0075             I0 i0 = fusion::begin(seq);
0076             
0077             return vector_data1(*i0);
0078         }
0079         T0 m0;
0080     };
0081     template <typename T0>
0082     struct vector1
0083       : vector_data1<T0>
0084       , sequence_base<vector1<T0> >
0085     {
0086         typedef vector1<T0> this_type;
0087         typedef vector_data1<T0> base_type;
0088         typedef mpl::vector1<T0> types;
0089         typedef vector_tag fusion_tag;
0090         typedef fusion_sequence_tag tag; 
0091         typedef mpl::false_ is_view;
0092         typedef random_access_traversal_tag category;
0093         typedef mpl::int_<1> size;
0094         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0095         vector1() {}
0096 # if !defined(BOOST_CLANG)
0097     BOOST_CONSTEXPR
0098 # endif
0099         BOOST_FUSION_GPU_ENABLED
0100         explicit
0101         vector1(
0102             typename detail::call_param<T0 >::type arg0)
0103             : base_type(arg0) {}
0104 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0105         template <typename U0>
0106 # if !defined(BOOST_CLANG)
0107         BOOST_CXX14_CONSTEXPR
0108 # endif
0109         BOOST_FUSION_GPU_ENABLED
0110         explicit
0111         vector1(U0&& _0
0112           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
0113           )
0114          : base_type(std::forward<U0>( _0)) {}
0115         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0116         vector1(vector1&& rhs)
0117             : base_type(std::forward<base_type>(rhs)) {}
0118         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0119         vector1(vector1 const& rhs)
0120             : base_type(static_cast<base_type const&>(rhs)) {}
0121         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0122         vector1&
0123         operator=(vector1 const& vec)
0124         {
0125             base_type::operator=(vec);
0126             return *this;
0127         }
0128         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0129         vector1&
0130         operator=(vector1&& vec)
0131         {
0132             this->m0 = std::forward< T0>(vec.m0);
0133             return *this;
0134         }
0135 # endif
0136         template <typename U0>
0137 # if !defined(BOOST_CLANG)
0138     BOOST_CXX14_CONSTEXPR
0139 # endif
0140         BOOST_FUSION_GPU_ENABLED
0141         vector1(
0142             vector1<U0> const& vec)
0143             : base_type(vec.m0) {}
0144         template <typename Sequence>
0145 # if !defined(BOOST_CLANG)
0146         BOOST_CXX14_CONSTEXPR
0147 # endif
0148         BOOST_FUSION_GPU_ENABLED
0149         vector1(
0150             Sequence const& seq
0151           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0152           , typename boost::disable_if<is_convertible<Sequence, T0> >::type* = 0
0153             )
0154             : base_type(base_type::init_from_sequence(seq)) {}
0155         template <typename Sequence>
0156 # if !defined(BOOST_CLANG)
0157         BOOST_CXX14_CONSTEXPR
0158 # endif
0159         BOOST_FUSION_GPU_ENABLED
0160         vector1(
0161             Sequence& seq
0162           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0163           , typename boost::disable_if<is_convertible<Sequence, T0> >::type* = 0
0164             )
0165             : base_type(base_type::init_from_sequence(seq)) {}
0166         template <typename U0>
0167         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0168         vector1&
0169         operator=(vector1<U0> const& vec)
0170         {
0171             this->m0 = vec.m0;
0172             return *this;
0173         }
0174         template <typename Sequence>
0175         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0176         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
0177         operator=(Sequence const& seq)
0178         {
0179             typedef typename result_of::begin<Sequence const>::type I0;
0180             I0 i0 = fusion::begin(seq);
0181             
0182             this->m0 = *i0;
0183             return *this;
0184         }
0185         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; }
0186         template<typename I>
0187         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0188         typename add_reference<typename mpl::at<types, I>::type>::type
0189         at_impl(I)
0190         {
0191             return this->at_impl(mpl::int_<I::value>());
0192         }
0193         template<typename I>
0194         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0195         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
0196         at_impl(I) const
0197         {
0198             return this->at_impl(mpl::int_<I::value>());
0199         }
0200     };
0201     template <typename T0 , typename T1>
0202     struct vector_data2
0203     {
0204         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0205         vector_data2()
0206             : m0() , m1() {}
0207 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0208         template <typename U0 , typename U1>
0209 # if !defined(BOOST_CLANG)
0210         BOOST_CXX14_CONSTEXPR
0211 # endif
0212         BOOST_FUSION_GPU_ENABLED
0213         vector_data2(U0 && arg0 , U1 && arg1
0214           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
0215         )
0216             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) {}
0217         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0218         vector_data2(
0219             vector_data2&& other)
0220             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) {}
0221 # endif
0222 # if !defined(BOOST_CLANG)
0223     BOOST_CONSTEXPR
0224 # endif
0225         BOOST_FUSION_GPU_ENABLED
0226         vector_data2(
0227             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1)
0228             : m0(arg0) , m1(arg1) {}
0229         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0230         vector_data2(
0231             vector_data2 const& other)
0232             : m0(other.m0) , m1(other.m1) {}
0233         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0234         vector_data2&
0235         operator=(vector_data2 const& vec)
0236         {
0237             this->m0 = vec.m0; this->m1 = vec.m1;
0238             return *this;
0239         }
0240         template <typename Sequence>
0241 # if !defined(BOOST_CLANG)
0242     BOOST_CXX14_CONSTEXPR
0243 # endif
0244         BOOST_FUSION_GPU_ENABLED
0245         static vector_data2
0246         init_from_sequence(Sequence const& seq)
0247         {
0248             typedef typename result_of::begin<Sequence const>::type I0;
0249             I0 i0 = fusion::begin(seq);
0250             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
0251             return vector_data2(*i0 , *i1);
0252         }
0253         template <typename Sequence>
0254 # if !defined(BOOST_CLANG)
0255     BOOST_CXX14_CONSTEXPR
0256 # endif
0257         BOOST_FUSION_GPU_ENABLED
0258         static vector_data2
0259         init_from_sequence(Sequence& seq)
0260         {
0261             typedef typename result_of::begin<Sequence>::type I0;
0262             I0 i0 = fusion::begin(seq);
0263             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
0264             return vector_data2(*i0 , *i1);
0265         }
0266         T0 m0; T1 m1;
0267     };
0268     template <typename T0 , typename T1>
0269     struct vector2
0270       : vector_data2<T0 , T1>
0271       , sequence_base<vector2<T0 , T1> >
0272     {
0273         typedef vector2<T0 , T1> this_type;
0274         typedef vector_data2<T0 , T1> base_type;
0275         typedef mpl::vector2<T0 , T1> types;
0276         typedef vector_tag fusion_tag;
0277         typedef fusion_sequence_tag tag; 
0278         typedef mpl::false_ is_view;
0279         typedef random_access_traversal_tag category;
0280         typedef mpl::int_<2> size;
0281         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0282         vector2() {}
0283 # if !defined(BOOST_CLANG)
0284     BOOST_CONSTEXPR
0285 # endif
0286         BOOST_FUSION_GPU_ENABLED
0287         vector2(
0288             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1)
0289             : base_type(arg0 , arg1) {}
0290 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0291         template <typename U0 , typename U1>
0292 # if !defined(BOOST_CLANG)
0293         BOOST_CXX14_CONSTEXPR
0294 # endif
0295         BOOST_FUSION_GPU_ENABLED
0296         vector2(U0 && arg0 , U1 && arg1)
0297             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1)) {}
0298         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0299         vector2(vector2&& rhs)
0300             : base_type(std::forward<base_type>(rhs)) {}
0301         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0302         vector2(vector2 const& rhs)
0303             : base_type(static_cast<base_type const&>(rhs)) {}
0304         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0305         vector2&
0306         operator=(vector2 const& vec)
0307         {
0308             base_type::operator=(vec);
0309             return *this;
0310         }
0311         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0312         vector2&
0313         operator=(vector2&& vec)
0314         {
0315             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1);
0316             return *this;
0317         }
0318 # endif
0319         template <typename U0 , typename U1>
0320 # if !defined(BOOST_CLANG)
0321     BOOST_CXX14_CONSTEXPR
0322 # endif
0323         BOOST_FUSION_GPU_ENABLED
0324         vector2(
0325             vector2<U0 , U1> const& vec)
0326             : base_type(vec.m0 , vec.m1) {}
0327         template <typename Sequence>
0328 # if !defined(BOOST_CLANG)
0329         BOOST_CXX14_CONSTEXPR
0330 # endif
0331         BOOST_FUSION_GPU_ENABLED
0332         vector2(
0333             Sequence const& seq
0334           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0335             )
0336             : base_type(base_type::init_from_sequence(seq)) {}
0337         template <typename Sequence>
0338 # if !defined(BOOST_CLANG)
0339         BOOST_CXX14_CONSTEXPR
0340 # endif
0341         BOOST_FUSION_GPU_ENABLED
0342         vector2(
0343             Sequence& seq
0344           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0345             )
0346             : base_type(base_type::init_from_sequence(seq)) {}
0347         template <typename U0 , typename U1>
0348         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0349         vector2&
0350         operator=(vector2<U0 , U1> const& vec)
0351         {
0352             this->m0 = vec.m0; this->m1 = vec.m1;
0353             return *this;
0354         }
0355         template <typename Sequence>
0356         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0357         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
0358         operator=(Sequence const& seq)
0359         {
0360             typedef typename result_of::begin<Sequence const>::type I0;
0361             I0 i0 = fusion::begin(seq);
0362             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
0363             this->m0 = *i0; this->m1 = *i1;
0364             return *this;
0365         }
0366         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; }
0367         template<typename I>
0368         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0369         typename add_reference<typename mpl::at<types, I>::type>::type
0370         at_impl(I)
0371         {
0372             return this->at_impl(mpl::int_<I::value>());
0373         }
0374         template<typename I>
0375         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0376         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
0377         at_impl(I) const
0378         {
0379             return this->at_impl(mpl::int_<I::value>());
0380         }
0381     };
0382     template <typename T0 , typename T1 , typename T2>
0383     struct vector_data3
0384     {
0385         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0386         vector_data3()
0387             : m0() , m1() , m2() {}
0388 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0389         template <typename U0 , typename U1 , typename U2>
0390 # if !defined(BOOST_CLANG)
0391         BOOST_CXX14_CONSTEXPR
0392 # endif
0393         BOOST_FUSION_GPU_ENABLED
0394         vector_data3(U0 && arg0 , U1 && arg1 , U2 && arg2
0395           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
0396         )
0397             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) {}
0398         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0399         vector_data3(
0400             vector_data3&& other)
0401             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) {}
0402 # endif
0403 # if !defined(BOOST_CLANG)
0404     BOOST_CONSTEXPR
0405 # endif
0406         BOOST_FUSION_GPU_ENABLED
0407         vector_data3(
0408             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2)
0409             : m0(arg0) , m1(arg1) , m2(arg2) {}
0410         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0411         vector_data3(
0412             vector_data3 const& other)
0413             : m0(other.m0) , m1(other.m1) , m2(other.m2) {}
0414         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0415         vector_data3&
0416         operator=(vector_data3 const& vec)
0417         {
0418             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2;
0419             return *this;
0420         }
0421         template <typename Sequence>
0422 # if !defined(BOOST_CLANG)
0423     BOOST_CXX14_CONSTEXPR
0424 # endif
0425         BOOST_FUSION_GPU_ENABLED
0426         static vector_data3
0427         init_from_sequence(Sequence const& seq)
0428         {
0429             typedef typename result_of::begin<Sequence const>::type I0;
0430             I0 i0 = fusion::begin(seq);
0431             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);
0432             return vector_data3(*i0 , *i1 , *i2);
0433         }
0434         template <typename Sequence>
0435 # if !defined(BOOST_CLANG)
0436     BOOST_CXX14_CONSTEXPR
0437 # endif
0438         BOOST_FUSION_GPU_ENABLED
0439         static vector_data3
0440         init_from_sequence(Sequence& seq)
0441         {
0442             typedef typename result_of::begin<Sequence>::type I0;
0443             I0 i0 = fusion::begin(seq);
0444             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);
0445             return vector_data3(*i0 , *i1 , *i2);
0446         }
0447         T0 m0; T1 m1; T2 m2;
0448     };
0449     template <typename T0 , typename T1 , typename T2>
0450     struct vector3
0451       : vector_data3<T0 , T1 , T2>
0452       , sequence_base<vector3<T0 , T1 , T2> >
0453     {
0454         typedef vector3<T0 , T1 , T2> this_type;
0455         typedef vector_data3<T0 , T1 , T2> base_type;
0456         typedef mpl::vector3<T0 , T1 , T2> types;
0457         typedef vector_tag fusion_tag;
0458         typedef fusion_sequence_tag tag; 
0459         typedef mpl::false_ is_view;
0460         typedef random_access_traversal_tag category;
0461         typedef mpl::int_<3> size;
0462         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0463         vector3() {}
0464 # if !defined(BOOST_CLANG)
0465     BOOST_CONSTEXPR
0466 # endif
0467         BOOST_FUSION_GPU_ENABLED
0468         vector3(
0469             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2)
0470             : base_type(arg0 , arg1 , arg2) {}
0471 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0472         template <typename U0 , typename U1 , typename U2>
0473 # if !defined(BOOST_CLANG)
0474         BOOST_CXX14_CONSTEXPR
0475 # endif
0476         BOOST_FUSION_GPU_ENABLED
0477         vector3(U0 && arg0 , U1 && arg1 , U2 && arg2)
0478             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2)) {}
0479         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0480         vector3(vector3&& rhs)
0481             : base_type(std::forward<base_type>(rhs)) {}
0482         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0483         vector3(vector3 const& rhs)
0484             : base_type(static_cast<base_type const&>(rhs)) {}
0485         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0486         vector3&
0487         operator=(vector3 const& vec)
0488         {
0489             base_type::operator=(vec);
0490             return *this;
0491         }
0492         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0493         vector3&
0494         operator=(vector3&& vec)
0495         {
0496             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2);
0497             return *this;
0498         }
0499 # endif
0500         template <typename U0 , typename U1 , typename U2>
0501 # if !defined(BOOST_CLANG)
0502     BOOST_CXX14_CONSTEXPR
0503 # endif
0504         BOOST_FUSION_GPU_ENABLED
0505         vector3(
0506             vector3<U0 , U1 , U2> const& vec)
0507             : base_type(vec.m0 , vec.m1 , vec.m2) {}
0508         template <typename Sequence>
0509 # if !defined(BOOST_CLANG)
0510         BOOST_CXX14_CONSTEXPR
0511 # endif
0512         BOOST_FUSION_GPU_ENABLED
0513         vector3(
0514             Sequence const& seq
0515           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0516             )
0517             : base_type(base_type::init_from_sequence(seq)) {}
0518         template <typename Sequence>
0519 # if !defined(BOOST_CLANG)
0520         BOOST_CXX14_CONSTEXPR
0521 # endif
0522         BOOST_FUSION_GPU_ENABLED
0523         vector3(
0524             Sequence& seq
0525           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0526             )
0527             : base_type(base_type::init_from_sequence(seq)) {}
0528         template <typename U0 , typename U1 , typename U2>
0529         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0530         vector3&
0531         operator=(vector3<U0 , U1 , U2> const& vec)
0532         {
0533             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2;
0534             return *this;
0535         }
0536         template <typename Sequence>
0537         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0538         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
0539         operator=(Sequence const& seq)
0540         {
0541             typedef typename result_of::begin<Sequence const>::type I0;
0542             I0 i0 = fusion::begin(seq);
0543             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);
0544             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2;
0545             return *this;
0546         }
0547         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; }
0548         template<typename I>
0549         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0550         typename add_reference<typename mpl::at<types, I>::type>::type
0551         at_impl(I)
0552         {
0553             return this->at_impl(mpl::int_<I::value>());
0554         }
0555         template<typename I>
0556         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0557         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
0558         at_impl(I) const
0559         {
0560             return this->at_impl(mpl::int_<I::value>());
0561         }
0562     };
0563     template <typename T0 , typename T1 , typename T2 , typename T3>
0564     struct vector_data4
0565     {
0566         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0567         vector_data4()
0568             : m0() , m1() , m2() , m3() {}
0569 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0570         template <typename U0 , typename U1 , typename U2 , typename U3>
0571 # if !defined(BOOST_CLANG)
0572         BOOST_CXX14_CONSTEXPR
0573 # endif
0574         BOOST_FUSION_GPU_ENABLED
0575         vector_data4(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3
0576           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
0577         )
0578             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) {}
0579         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0580         vector_data4(
0581             vector_data4&& other)
0582             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) {}
0583 # endif
0584 # if !defined(BOOST_CLANG)
0585     BOOST_CONSTEXPR
0586 # endif
0587         BOOST_FUSION_GPU_ENABLED
0588         vector_data4(
0589             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3)
0590             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) {}
0591         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0592         vector_data4(
0593             vector_data4 const& other)
0594             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) {}
0595         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0596         vector_data4&
0597         operator=(vector_data4 const& vec)
0598         {
0599             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3;
0600             return *this;
0601         }
0602         template <typename Sequence>
0603 # if !defined(BOOST_CLANG)
0604     BOOST_CXX14_CONSTEXPR
0605 # endif
0606         BOOST_FUSION_GPU_ENABLED
0607         static vector_data4
0608         init_from_sequence(Sequence const& seq)
0609         {
0610             typedef typename result_of::begin<Sequence const>::type I0;
0611             I0 i0 = fusion::begin(seq);
0612             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);
0613             return vector_data4(*i0 , *i1 , *i2 , *i3);
0614         }
0615         template <typename Sequence>
0616 # if !defined(BOOST_CLANG)
0617     BOOST_CXX14_CONSTEXPR
0618 # endif
0619         BOOST_FUSION_GPU_ENABLED
0620         static vector_data4
0621         init_from_sequence(Sequence& seq)
0622         {
0623             typedef typename result_of::begin<Sequence>::type I0;
0624             I0 i0 = fusion::begin(seq);
0625             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);
0626             return vector_data4(*i0 , *i1 , *i2 , *i3);
0627         }
0628         T0 m0; T1 m1; T2 m2; T3 m3;
0629     };
0630     template <typename T0 , typename T1 , typename T2 , typename T3>
0631     struct vector4
0632       : vector_data4<T0 , T1 , T2 , T3>
0633       , sequence_base<vector4<T0 , T1 , T2 , T3> >
0634     {
0635         typedef vector4<T0 , T1 , T2 , T3> this_type;
0636         typedef vector_data4<T0 , T1 , T2 , T3> base_type;
0637         typedef mpl::vector4<T0 , T1 , T2 , T3> types;
0638         typedef vector_tag fusion_tag;
0639         typedef fusion_sequence_tag tag; 
0640         typedef mpl::false_ is_view;
0641         typedef random_access_traversal_tag category;
0642         typedef mpl::int_<4> size;
0643         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0644         vector4() {}
0645 # if !defined(BOOST_CLANG)
0646     BOOST_CONSTEXPR
0647 # endif
0648         BOOST_FUSION_GPU_ENABLED
0649         vector4(
0650             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3)
0651             : base_type(arg0 , arg1 , arg2 , arg3) {}
0652 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0653         template <typename U0 , typename U1 , typename U2 , typename U3>
0654 # if !defined(BOOST_CLANG)
0655         BOOST_CXX14_CONSTEXPR
0656 # endif
0657         BOOST_FUSION_GPU_ENABLED
0658         vector4(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3)
0659             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3)) {}
0660         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0661         vector4(vector4&& rhs)
0662             : base_type(std::forward<base_type>(rhs)) {}
0663         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0664         vector4(vector4 const& rhs)
0665             : base_type(static_cast<base_type const&>(rhs)) {}
0666         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0667         vector4&
0668         operator=(vector4 const& vec)
0669         {
0670             base_type::operator=(vec);
0671             return *this;
0672         }
0673         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0674         vector4&
0675         operator=(vector4&& vec)
0676         {
0677             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3);
0678             return *this;
0679         }
0680 # endif
0681         template <typename U0 , typename U1 , typename U2 , typename U3>
0682 # if !defined(BOOST_CLANG)
0683     BOOST_CXX14_CONSTEXPR
0684 # endif
0685         BOOST_FUSION_GPU_ENABLED
0686         vector4(
0687             vector4<U0 , U1 , U2 , U3> const& vec)
0688             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3) {}
0689         template <typename Sequence>
0690 # if !defined(BOOST_CLANG)
0691         BOOST_CXX14_CONSTEXPR
0692 # endif
0693         BOOST_FUSION_GPU_ENABLED
0694         vector4(
0695             Sequence const& seq
0696           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0697             )
0698             : base_type(base_type::init_from_sequence(seq)) {}
0699         template <typename Sequence>
0700 # if !defined(BOOST_CLANG)
0701         BOOST_CXX14_CONSTEXPR
0702 # endif
0703         BOOST_FUSION_GPU_ENABLED
0704         vector4(
0705             Sequence& seq
0706           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0707             )
0708             : base_type(base_type::init_from_sequence(seq)) {}
0709         template <typename U0 , typename U1 , typename U2 , typename U3>
0710         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0711         vector4&
0712         operator=(vector4<U0 , U1 , U2 , U3> const& vec)
0713         {
0714             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3;
0715             return *this;
0716         }
0717         template <typename Sequence>
0718         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0719         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
0720         operator=(Sequence const& seq)
0721         {
0722             typedef typename result_of::begin<Sequence const>::type I0;
0723             I0 i0 = fusion::begin(seq);
0724             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);
0725             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3;
0726             return *this;
0727         }
0728         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; }
0729         template<typename I>
0730         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0731         typename add_reference<typename mpl::at<types, I>::type>::type
0732         at_impl(I)
0733         {
0734             return this->at_impl(mpl::int_<I::value>());
0735         }
0736         template<typename I>
0737         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0738         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
0739         at_impl(I) const
0740         {
0741             return this->at_impl(mpl::int_<I::value>());
0742         }
0743     };
0744     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
0745     struct vector_data5
0746     {
0747         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0748         vector_data5()
0749             : m0() , m1() , m2() , m3() , m4() {}
0750 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0751         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
0752 # if !defined(BOOST_CLANG)
0753         BOOST_CXX14_CONSTEXPR
0754 # endif
0755         BOOST_FUSION_GPU_ENABLED
0756         vector_data5(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4
0757           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
0758         )
0759             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) {}
0760         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0761         vector_data5(
0762             vector_data5&& other)
0763             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) {}
0764 # endif
0765 # if !defined(BOOST_CLANG)
0766     BOOST_CONSTEXPR
0767 # endif
0768         BOOST_FUSION_GPU_ENABLED
0769         vector_data5(
0770             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4)
0771             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) {}
0772         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0773         vector_data5(
0774             vector_data5 const& other)
0775             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) {}
0776         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0777         vector_data5&
0778         operator=(vector_data5 const& vec)
0779         {
0780             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4;
0781             return *this;
0782         }
0783         template <typename Sequence>
0784 # if !defined(BOOST_CLANG)
0785     BOOST_CXX14_CONSTEXPR
0786 # endif
0787         BOOST_FUSION_GPU_ENABLED
0788         static vector_data5
0789         init_from_sequence(Sequence const& seq)
0790         {
0791             typedef typename result_of::begin<Sequence const>::type I0;
0792             I0 i0 = fusion::begin(seq);
0793             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);
0794             return vector_data5(*i0 , *i1 , *i2 , *i3 , *i4);
0795         }
0796         template <typename Sequence>
0797 # if !defined(BOOST_CLANG)
0798     BOOST_CXX14_CONSTEXPR
0799 # endif
0800         BOOST_FUSION_GPU_ENABLED
0801         static vector_data5
0802         init_from_sequence(Sequence& seq)
0803         {
0804             typedef typename result_of::begin<Sequence>::type I0;
0805             I0 i0 = fusion::begin(seq);
0806             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);
0807             return vector_data5(*i0 , *i1 , *i2 , *i3 , *i4);
0808         }
0809         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4;
0810     };
0811     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
0812     struct vector5
0813       : vector_data5<T0 , T1 , T2 , T3 , T4>
0814       , sequence_base<vector5<T0 , T1 , T2 , T3 , T4> >
0815     {
0816         typedef vector5<T0 , T1 , T2 , T3 , T4> this_type;
0817         typedef vector_data5<T0 , T1 , T2 , T3 , T4> base_type;
0818         typedef mpl::vector5<T0 , T1 , T2 , T3 , T4> types;
0819         typedef vector_tag fusion_tag;
0820         typedef fusion_sequence_tag tag; 
0821         typedef mpl::false_ is_view;
0822         typedef random_access_traversal_tag category;
0823         typedef mpl::int_<5> size;
0824         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0825         vector5() {}
0826 # if !defined(BOOST_CLANG)
0827     BOOST_CONSTEXPR
0828 # endif
0829         BOOST_FUSION_GPU_ENABLED
0830         vector5(
0831             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4)
0832             : base_type(arg0 , arg1 , arg2 , arg3 , arg4) {}
0833 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0834         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
0835 # if !defined(BOOST_CLANG)
0836         BOOST_CXX14_CONSTEXPR
0837 # endif
0838         BOOST_FUSION_GPU_ENABLED
0839         vector5(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4)
0840             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4)) {}
0841         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0842         vector5(vector5&& rhs)
0843             : base_type(std::forward<base_type>(rhs)) {}
0844         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0845         vector5(vector5 const& rhs)
0846             : base_type(static_cast<base_type const&>(rhs)) {}
0847         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0848         vector5&
0849         operator=(vector5 const& vec)
0850         {
0851             base_type::operator=(vec);
0852             return *this;
0853         }
0854         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0855         vector5&
0856         operator=(vector5&& vec)
0857         {
0858             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4);
0859             return *this;
0860         }
0861 # endif
0862         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
0863 # if !defined(BOOST_CLANG)
0864     BOOST_CXX14_CONSTEXPR
0865 # endif
0866         BOOST_FUSION_GPU_ENABLED
0867         vector5(
0868             vector5<U0 , U1 , U2 , U3 , U4> const& vec)
0869             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4) {}
0870         template <typename Sequence>
0871 # if !defined(BOOST_CLANG)
0872         BOOST_CXX14_CONSTEXPR
0873 # endif
0874         BOOST_FUSION_GPU_ENABLED
0875         vector5(
0876             Sequence const& seq
0877           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0878             )
0879             : base_type(base_type::init_from_sequence(seq)) {}
0880         template <typename Sequence>
0881 # if !defined(BOOST_CLANG)
0882         BOOST_CXX14_CONSTEXPR
0883 # endif
0884         BOOST_FUSION_GPU_ENABLED
0885         vector5(
0886             Sequence& seq
0887           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
0888             )
0889             : base_type(base_type::init_from_sequence(seq)) {}
0890         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
0891         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0892         vector5&
0893         operator=(vector5<U0 , U1 , U2 , U3 , U4> const& vec)
0894         {
0895             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4;
0896             return *this;
0897         }
0898         template <typename Sequence>
0899         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0900         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
0901         operator=(Sequence const& seq)
0902         {
0903             typedef typename result_of::begin<Sequence const>::type I0;
0904             I0 i0 = fusion::begin(seq);
0905             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);
0906             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4;
0907             return *this;
0908         }
0909         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; }
0910         template<typename I>
0911         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0912         typename add_reference<typename mpl::at<types, I>::type>::type
0913         at_impl(I)
0914         {
0915             return this->at_impl(mpl::int_<I::value>());
0916         }
0917         template<typename I>
0918         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0919         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
0920         at_impl(I) const
0921         {
0922             return this->at_impl(mpl::int_<I::value>());
0923         }
0924     };
0925     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
0926     struct vector_data6
0927     {
0928         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0929         vector_data6()
0930             : m0() , m1() , m2() , m3() , m4() , m5() {}
0931 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0932         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
0933 # if !defined(BOOST_CLANG)
0934         BOOST_CXX14_CONSTEXPR
0935 # endif
0936         BOOST_FUSION_GPU_ENABLED
0937         vector_data6(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5
0938           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
0939         )
0940             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) {}
0941         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0942         vector_data6(
0943             vector_data6&& other)
0944             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) {}
0945 # endif
0946 # if !defined(BOOST_CLANG)
0947     BOOST_CONSTEXPR
0948 # endif
0949         BOOST_FUSION_GPU_ENABLED
0950         vector_data6(
0951             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5)
0952             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) {}
0953         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0954         vector_data6(
0955             vector_data6 const& other)
0956             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) {}
0957         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
0958         vector_data6&
0959         operator=(vector_data6 const& vec)
0960         {
0961             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5;
0962             return *this;
0963         }
0964         template <typename Sequence>
0965 # if !defined(BOOST_CLANG)
0966     BOOST_CXX14_CONSTEXPR
0967 # endif
0968         BOOST_FUSION_GPU_ENABLED
0969         static vector_data6
0970         init_from_sequence(Sequence const& seq)
0971         {
0972             typedef typename result_of::begin<Sequence const>::type I0;
0973             I0 i0 = fusion::begin(seq);
0974             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);
0975             return vector_data6(*i0 , *i1 , *i2 , *i3 , *i4 , *i5);
0976         }
0977         template <typename Sequence>
0978 # if !defined(BOOST_CLANG)
0979     BOOST_CXX14_CONSTEXPR
0980 # endif
0981         BOOST_FUSION_GPU_ENABLED
0982         static vector_data6
0983         init_from_sequence(Sequence& seq)
0984         {
0985             typedef typename result_of::begin<Sequence>::type I0;
0986             I0 i0 = fusion::begin(seq);
0987             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);
0988             return vector_data6(*i0 , *i1 , *i2 , *i3 , *i4 , *i5);
0989         }
0990         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5;
0991     };
0992     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
0993     struct vector6
0994       : vector_data6<T0 , T1 , T2 , T3 , T4 , T5>
0995       , sequence_base<vector6<T0 , T1 , T2 , T3 , T4 , T5> >
0996     {
0997         typedef vector6<T0 , T1 , T2 , T3 , T4 , T5> this_type;
0998         typedef vector_data6<T0 , T1 , T2 , T3 , T4 , T5> base_type;
0999         typedef mpl::vector6<T0 , T1 , T2 , T3 , T4 , T5> types;
1000         typedef vector_tag fusion_tag;
1001         typedef fusion_sequence_tag tag; 
1002         typedef mpl::false_ is_view;
1003         typedef random_access_traversal_tag category;
1004         typedef mpl::int_<6> size;
1005         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1006         vector6() {}
1007 # if !defined(BOOST_CLANG)
1008     BOOST_CONSTEXPR
1009 # endif
1010         BOOST_FUSION_GPU_ENABLED
1011         vector6(
1012             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5)
1013             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5) {}
1014 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1015         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
1016 # if !defined(BOOST_CLANG)
1017         BOOST_CXX14_CONSTEXPR
1018 # endif
1019         BOOST_FUSION_GPU_ENABLED
1020         vector6(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5)
1021             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5)) {}
1022         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1023         vector6(vector6&& rhs)
1024             : base_type(std::forward<base_type>(rhs)) {}
1025         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1026         vector6(vector6 const& rhs)
1027             : base_type(static_cast<base_type const&>(rhs)) {}
1028         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1029         vector6&
1030         operator=(vector6 const& vec)
1031         {
1032             base_type::operator=(vec);
1033             return *this;
1034         }
1035         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1036         vector6&
1037         operator=(vector6&& vec)
1038         {
1039             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5);
1040             return *this;
1041         }
1042 # endif
1043         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
1044 # if !defined(BOOST_CLANG)
1045     BOOST_CXX14_CONSTEXPR
1046 # endif
1047         BOOST_FUSION_GPU_ENABLED
1048         vector6(
1049             vector6<U0 , U1 , U2 , U3 , U4 , U5> const& vec)
1050             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5) {}
1051         template <typename Sequence>
1052 # if !defined(BOOST_CLANG)
1053         BOOST_CXX14_CONSTEXPR
1054 # endif
1055         BOOST_FUSION_GPU_ENABLED
1056         vector6(
1057             Sequence const& seq
1058           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1059             )
1060             : base_type(base_type::init_from_sequence(seq)) {}
1061         template <typename Sequence>
1062 # if !defined(BOOST_CLANG)
1063         BOOST_CXX14_CONSTEXPR
1064 # endif
1065         BOOST_FUSION_GPU_ENABLED
1066         vector6(
1067             Sequence& seq
1068           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1069             )
1070             : base_type(base_type::init_from_sequence(seq)) {}
1071         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
1072         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1073         vector6&
1074         operator=(vector6<U0 , U1 , U2 , U3 , U4 , U5> const& vec)
1075         {
1076             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5;
1077             return *this;
1078         }
1079         template <typename Sequence>
1080         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1081         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1082         operator=(Sequence const& seq)
1083         {
1084             typedef typename result_of::begin<Sequence const>::type I0;
1085             I0 i0 = fusion::begin(seq);
1086             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);
1087             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5;
1088             return *this;
1089         }
1090         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; }
1091         template<typename I>
1092         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1093         typename add_reference<typename mpl::at<types, I>::type>::type
1094         at_impl(I)
1095         {
1096             return this->at_impl(mpl::int_<I::value>());
1097         }
1098         template<typename I>
1099         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1100         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1101         at_impl(I) const
1102         {
1103             return this->at_impl(mpl::int_<I::value>());
1104         }
1105     };
1106     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
1107     struct vector_data7
1108     {
1109         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1110         vector_data7()
1111             : m0() , m1() , m2() , m3() , m4() , m5() , m6() {}
1112 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1113         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1114 # if !defined(BOOST_CLANG)
1115         BOOST_CXX14_CONSTEXPR
1116 # endif
1117         BOOST_FUSION_GPU_ENABLED
1118         vector_data7(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6
1119           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1120         )
1121             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) {}
1122         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1123         vector_data7(
1124             vector_data7&& other)
1125             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) {}
1126 # endif
1127 # if !defined(BOOST_CLANG)
1128     BOOST_CONSTEXPR
1129 # endif
1130         BOOST_FUSION_GPU_ENABLED
1131         vector_data7(
1132             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6)
1133             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) {}
1134         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1135         vector_data7(
1136             vector_data7 const& other)
1137             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) {}
1138         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1139         vector_data7&
1140         operator=(vector_data7 const& vec)
1141         {
1142             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;
1143             return *this;
1144         }
1145         template <typename Sequence>
1146 # if !defined(BOOST_CLANG)
1147     BOOST_CXX14_CONSTEXPR
1148 # endif
1149         BOOST_FUSION_GPU_ENABLED
1150         static vector_data7
1151         init_from_sequence(Sequence const& seq)
1152         {
1153             typedef typename result_of::begin<Sequence const>::type I0;
1154             I0 i0 = fusion::begin(seq);
1155             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);
1156             return vector_data7(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6);
1157         }
1158         template <typename Sequence>
1159 # if !defined(BOOST_CLANG)
1160     BOOST_CXX14_CONSTEXPR
1161 # endif
1162         BOOST_FUSION_GPU_ENABLED
1163         static vector_data7
1164         init_from_sequence(Sequence& seq)
1165         {
1166             typedef typename result_of::begin<Sequence>::type I0;
1167             I0 i0 = fusion::begin(seq);
1168             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);
1169             return vector_data7(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6);
1170         }
1171         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6;
1172     };
1173     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
1174     struct vector7
1175       : vector_data7<T0 , T1 , T2 , T3 , T4 , T5 , T6>
1176       , sequence_base<vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> >
1177     {
1178         typedef vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> this_type;
1179         typedef vector_data7<T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
1180         typedef mpl::vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> types;
1181         typedef vector_tag fusion_tag;
1182         typedef fusion_sequence_tag tag; 
1183         typedef mpl::false_ is_view;
1184         typedef random_access_traversal_tag category;
1185         typedef mpl::int_<7> size;
1186         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1187         vector7() {}
1188 # if !defined(BOOST_CLANG)
1189     BOOST_CONSTEXPR
1190 # endif
1191         BOOST_FUSION_GPU_ENABLED
1192         vector7(
1193             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6)
1194             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6) {}
1195 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1196         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1197 # if !defined(BOOST_CLANG)
1198         BOOST_CXX14_CONSTEXPR
1199 # endif
1200         BOOST_FUSION_GPU_ENABLED
1201         vector7(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6)
1202             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6)) {}
1203         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1204         vector7(vector7&& rhs)
1205             : base_type(std::forward<base_type>(rhs)) {}
1206         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1207         vector7(vector7 const& rhs)
1208             : base_type(static_cast<base_type const&>(rhs)) {}
1209         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1210         vector7&
1211         operator=(vector7 const& vec)
1212         {
1213             base_type::operator=(vec);
1214             return *this;
1215         }
1216         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1217         vector7&
1218         operator=(vector7&& vec)
1219         {
1220             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6);
1221             return *this;
1222         }
1223 # endif
1224         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1225 # if !defined(BOOST_CLANG)
1226     BOOST_CXX14_CONSTEXPR
1227 # endif
1228         BOOST_FUSION_GPU_ENABLED
1229         vector7(
1230             vector7<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& vec)
1231             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6) {}
1232         template <typename Sequence>
1233 # if !defined(BOOST_CLANG)
1234         BOOST_CXX14_CONSTEXPR
1235 # endif
1236         BOOST_FUSION_GPU_ENABLED
1237         vector7(
1238             Sequence const& seq
1239           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1240             )
1241             : base_type(base_type::init_from_sequence(seq)) {}
1242         template <typename Sequence>
1243 # if !defined(BOOST_CLANG)
1244         BOOST_CXX14_CONSTEXPR
1245 # endif
1246         BOOST_FUSION_GPU_ENABLED
1247         vector7(
1248             Sequence& seq
1249           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1250             )
1251             : base_type(base_type::init_from_sequence(seq)) {}
1252         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1253         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1254         vector7&
1255         operator=(vector7<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& vec)
1256         {
1257             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;
1258             return *this;
1259         }
1260         template <typename Sequence>
1261         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1262         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1263         operator=(Sequence const& seq)
1264         {
1265             typedef typename result_of::begin<Sequence const>::type I0;
1266             I0 i0 = fusion::begin(seq);
1267             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);
1268             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6;
1269             return *this;
1270         }
1271         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; }
1272         template<typename I>
1273         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1274         typename add_reference<typename mpl::at<types, I>::type>::type
1275         at_impl(I)
1276         {
1277             return this->at_impl(mpl::int_<I::value>());
1278         }
1279         template<typename I>
1280         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1281         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1282         at_impl(I) const
1283         {
1284             return this->at_impl(mpl::int_<I::value>());
1285         }
1286     };
1287     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
1288     struct vector_data8
1289     {
1290         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1291         vector_data8()
1292             : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() {}
1293 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1294         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1295 # if !defined(BOOST_CLANG)
1296         BOOST_CXX14_CONSTEXPR
1297 # endif
1298         BOOST_FUSION_GPU_ENABLED
1299         vector_data8(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7
1300           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1301         )
1302             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) , m7(std::forward<U7>( arg7)) {}
1303         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1304         vector_data8(
1305             vector_data8&& other)
1306             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) , m7(std::forward<T7>( other.m7)) {}
1307 # endif
1308 # if !defined(BOOST_CLANG)
1309     BOOST_CONSTEXPR
1310 # endif
1311         BOOST_FUSION_GPU_ENABLED
1312         vector_data8(
1313             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7)
1314             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) , m7(arg7) {}
1315         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1316         vector_data8(
1317             vector_data8 const& other)
1318             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) , m7(other.m7) {}
1319         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1320         vector_data8&
1321         operator=(vector_data8 const& vec)
1322         {
1323             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;
1324             return *this;
1325         }
1326         template <typename Sequence>
1327 # if !defined(BOOST_CLANG)
1328     BOOST_CXX14_CONSTEXPR
1329 # endif
1330         BOOST_FUSION_GPU_ENABLED
1331         static vector_data8
1332         init_from_sequence(Sequence const& seq)
1333         {
1334             typedef typename result_of::begin<Sequence const>::type I0;
1335             I0 i0 = fusion::begin(seq);
1336             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);
1337             return vector_data8(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7);
1338         }
1339         template <typename Sequence>
1340 # if !defined(BOOST_CLANG)
1341     BOOST_CXX14_CONSTEXPR
1342 # endif
1343         BOOST_FUSION_GPU_ENABLED
1344         static vector_data8
1345         init_from_sequence(Sequence& seq)
1346         {
1347             typedef typename result_of::begin<Sequence>::type I0;
1348             I0 i0 = fusion::begin(seq);
1349             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);
1350             return vector_data8(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7);
1351         }
1352         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7;
1353     };
1354     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
1355     struct vector8
1356       : vector_data8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
1357       , sequence_base<vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> >
1358     {
1359         typedef vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> this_type;
1360         typedef vector_data8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
1361         typedef mpl::vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> types;
1362         typedef vector_tag fusion_tag;
1363         typedef fusion_sequence_tag tag; 
1364         typedef mpl::false_ is_view;
1365         typedef random_access_traversal_tag category;
1366         typedef mpl::int_<8> size;
1367         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1368         vector8() {}
1369 # if !defined(BOOST_CLANG)
1370     BOOST_CONSTEXPR
1371 # endif
1372         BOOST_FUSION_GPU_ENABLED
1373         vector8(
1374             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7)
1375             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7) {}
1376 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1377         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1378 # if !defined(BOOST_CLANG)
1379         BOOST_CXX14_CONSTEXPR
1380 # endif
1381         BOOST_FUSION_GPU_ENABLED
1382         vector8(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7)
1383             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6) , std::forward<U7>( arg7)) {}
1384         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1385         vector8(vector8&& rhs)
1386             : base_type(std::forward<base_type>(rhs)) {}
1387         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1388         vector8(vector8 const& rhs)
1389             : base_type(static_cast<base_type const&>(rhs)) {}
1390         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1391         vector8&
1392         operator=(vector8 const& vec)
1393         {
1394             base_type::operator=(vec);
1395             return *this;
1396         }
1397         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1398         vector8&
1399         operator=(vector8&& vec)
1400         {
1401             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6); this->m7 = std::forward< T7>(vec.m7);
1402             return *this;
1403         }
1404 # endif
1405         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1406 # if !defined(BOOST_CLANG)
1407     BOOST_CXX14_CONSTEXPR
1408 # endif
1409         BOOST_FUSION_GPU_ENABLED
1410         vector8(
1411             vector8<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& vec)
1412             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7) {}
1413         template <typename Sequence>
1414 # if !defined(BOOST_CLANG)
1415         BOOST_CXX14_CONSTEXPR
1416 # endif
1417         BOOST_FUSION_GPU_ENABLED
1418         vector8(
1419             Sequence const& seq
1420           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1421             )
1422             : base_type(base_type::init_from_sequence(seq)) {}
1423         template <typename Sequence>
1424 # if !defined(BOOST_CLANG)
1425         BOOST_CXX14_CONSTEXPR
1426 # endif
1427         BOOST_FUSION_GPU_ENABLED
1428         vector8(
1429             Sequence& seq
1430           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1431             )
1432             : base_type(base_type::init_from_sequence(seq)) {}
1433         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1434         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1435         vector8&
1436         operator=(vector8<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& vec)
1437         {
1438             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;
1439             return *this;
1440         }
1441         template <typename Sequence>
1442         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1443         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1444         operator=(Sequence const& seq)
1445         {
1446             typedef typename result_of::begin<Sequence const>::type I0;
1447             I0 i0 = fusion::begin(seq);
1448             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);
1449             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6; this->m7 = *i7;
1450             return *this;
1451         }
1452         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; }
1453         template<typename I>
1454         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1455         typename add_reference<typename mpl::at<types, I>::type>::type
1456         at_impl(I)
1457         {
1458             return this->at_impl(mpl::int_<I::value>());
1459         }
1460         template<typename I>
1461         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1462         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1463         at_impl(I) const
1464         {
1465             return this->at_impl(mpl::int_<I::value>());
1466         }
1467     };
1468     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
1469     struct vector_data9
1470     {
1471         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1472         vector_data9()
1473             : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() , m8() {}
1474 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1475         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1476 # if !defined(BOOST_CLANG)
1477         BOOST_CXX14_CONSTEXPR
1478 # endif
1479         BOOST_FUSION_GPU_ENABLED
1480         vector_data9(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8
1481           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1482         )
1483             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) , m7(std::forward<U7>( arg7)) , m8(std::forward<U8>( arg8)) {}
1484         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1485         vector_data9(
1486             vector_data9&& other)
1487             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) , m7(std::forward<T7>( other.m7)) , m8(std::forward<T8>( other.m8)) {}
1488 # endif
1489 # if !defined(BOOST_CLANG)
1490     BOOST_CONSTEXPR
1491 # endif
1492         BOOST_FUSION_GPU_ENABLED
1493         vector_data9(
1494             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8)
1495             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) , m7(arg7) , m8(arg8) {}
1496         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1497         vector_data9(
1498             vector_data9 const& other)
1499             : 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) {}
1500         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1501         vector_data9&
1502         operator=(vector_data9 const& vec)
1503         {
1504             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;
1505             return *this;
1506         }
1507         template <typename Sequence>
1508 # if !defined(BOOST_CLANG)
1509     BOOST_CXX14_CONSTEXPR
1510 # endif
1511         BOOST_FUSION_GPU_ENABLED
1512         static vector_data9
1513         init_from_sequence(Sequence const& seq)
1514         {
1515             typedef typename result_of::begin<Sequence const>::type I0;
1516             I0 i0 = fusion::begin(seq);
1517             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);
1518             return vector_data9(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8);
1519         }
1520         template <typename Sequence>
1521 # if !defined(BOOST_CLANG)
1522     BOOST_CXX14_CONSTEXPR
1523 # endif
1524         BOOST_FUSION_GPU_ENABLED
1525         static vector_data9
1526         init_from_sequence(Sequence& seq)
1527         {
1528             typedef typename result_of::begin<Sequence>::type I0;
1529             I0 i0 = fusion::begin(seq);
1530             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);
1531             return vector_data9(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8);
1532         }
1533         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7; T8 m8;
1534     };
1535     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
1536     struct vector9
1537       : vector_data9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
1538       , sequence_base<vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> >
1539     {
1540         typedef vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> this_type;
1541         typedef vector_data9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
1542         typedef mpl::vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> types;
1543         typedef vector_tag fusion_tag;
1544         typedef fusion_sequence_tag tag; 
1545         typedef mpl::false_ is_view;
1546         typedef random_access_traversal_tag category;
1547         typedef mpl::int_<9> size;
1548         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1549         vector9() {}
1550 # if !defined(BOOST_CLANG)
1551     BOOST_CONSTEXPR
1552 # endif
1553         BOOST_FUSION_GPU_ENABLED
1554         vector9(
1555             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8)
1556             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8) {}
1557 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1558         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1559 # if !defined(BOOST_CLANG)
1560         BOOST_CXX14_CONSTEXPR
1561 # endif
1562         BOOST_FUSION_GPU_ENABLED
1563         vector9(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8)
1564             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6) , std::forward<U7>( arg7) , std::forward<U8>( arg8)) {}
1565         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1566         vector9(vector9&& rhs)
1567             : base_type(std::forward<base_type>(rhs)) {}
1568         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1569         vector9(vector9 const& rhs)
1570             : base_type(static_cast<base_type const&>(rhs)) {}
1571         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1572         vector9&
1573         operator=(vector9 const& vec)
1574         {
1575             base_type::operator=(vec);
1576             return *this;
1577         }
1578         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1579         vector9&
1580         operator=(vector9&& vec)
1581         {
1582             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6); this->m7 = std::forward< T7>(vec.m7); this->m8 = std::forward< T8>(vec.m8);
1583             return *this;
1584         }
1585 # endif
1586         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1587 # if !defined(BOOST_CLANG)
1588     BOOST_CXX14_CONSTEXPR
1589 # endif
1590         BOOST_FUSION_GPU_ENABLED
1591         vector9(
1592             vector9<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& vec)
1593             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7 , vec.m8) {}
1594         template <typename Sequence>
1595 # if !defined(BOOST_CLANG)
1596         BOOST_CXX14_CONSTEXPR
1597 # endif
1598         BOOST_FUSION_GPU_ENABLED
1599         vector9(
1600             Sequence const& seq
1601           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1602             )
1603             : base_type(base_type::init_from_sequence(seq)) {}
1604         template <typename Sequence>
1605 # if !defined(BOOST_CLANG)
1606         BOOST_CXX14_CONSTEXPR
1607 # endif
1608         BOOST_FUSION_GPU_ENABLED
1609         vector9(
1610             Sequence& seq
1611           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1612             )
1613             : base_type(base_type::init_from_sequence(seq)) {}
1614         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1615         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1616         vector9&
1617         operator=(vector9<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& vec)
1618         {
1619             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;
1620             return *this;
1621         }
1622         template <typename Sequence>
1623         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1624         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1625         operator=(Sequence const& seq)
1626         {
1627             typedef typename result_of::begin<Sequence const>::type I0;
1628             I0 i0 = fusion::begin(seq);
1629             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);
1630             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;
1631             return *this;
1632         }
1633         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T8>::type at_impl(mpl::int_<8>) { return this->m8; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T8>::type>::type at_impl(mpl::int_<8>) const { return this->m8; }
1634         template<typename I>
1635         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1636         typename add_reference<typename mpl::at<types, I>::type>::type
1637         at_impl(I)
1638         {
1639             return this->at_impl(mpl::int_<I::value>());
1640         }
1641         template<typename I>
1642         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1643         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1644         at_impl(I) const
1645         {
1646             return this->at_impl(mpl::int_<I::value>());
1647         }
1648     };
1649     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
1650     struct vector_data10
1651     {
1652         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1653         vector_data10()
1654             : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() , m8() , m9() {}
1655 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1656         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1657 # if !defined(BOOST_CLANG)
1658         BOOST_CXX14_CONSTEXPR
1659 # endif
1660         BOOST_FUSION_GPU_ENABLED
1661         vector_data10(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8 , U9 && arg9
1662           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1663         )
1664             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) , m7(std::forward<U7>( arg7)) , m8(std::forward<U8>( arg8)) , m9(std::forward<U9>( arg9)) {}
1665         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1666         vector_data10(
1667             vector_data10&& other)
1668             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) , m7(std::forward<T7>( other.m7)) , m8(std::forward<T8>( other.m8)) , m9(std::forward<T9>( other.m9)) {}
1669 # endif
1670 # if !defined(BOOST_CLANG)
1671     BOOST_CONSTEXPR
1672 # endif
1673         BOOST_FUSION_GPU_ENABLED
1674         vector_data10(
1675             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8 , typename detail::call_param<T9 >::type arg9)
1676             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) , m7(arg7) , m8(arg8) , m9(arg9) {}
1677         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1678         vector_data10(
1679             vector_data10 const& other)
1680             : 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) {}
1681         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1682         vector_data10&
1683         operator=(vector_data10 const& vec)
1684         {
1685             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;
1686             return *this;
1687         }
1688         template <typename Sequence>
1689 # if !defined(BOOST_CLANG)
1690     BOOST_CXX14_CONSTEXPR
1691 # endif
1692         BOOST_FUSION_GPU_ENABLED
1693         static vector_data10
1694         init_from_sequence(Sequence const& seq)
1695         {
1696             typedef typename result_of::begin<Sequence const>::type I0;
1697             I0 i0 = fusion::begin(seq);
1698             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);
1699             return vector_data10(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8 , *i9);
1700         }
1701         template <typename Sequence>
1702 # if !defined(BOOST_CLANG)
1703     BOOST_CXX14_CONSTEXPR
1704 # endif
1705         BOOST_FUSION_GPU_ENABLED
1706         static vector_data10
1707         init_from_sequence(Sequence& seq)
1708         {
1709             typedef typename result_of::begin<Sequence>::type I0;
1710             I0 i0 = fusion::begin(seq);
1711             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);
1712             return vector_data10(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8 , *i9);
1713         }
1714         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7; T8 m8; T9 m9;
1715     };
1716     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
1717     struct vector10
1718       : vector_data10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
1719       , sequence_base<vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> >
1720     {
1721         typedef vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> this_type;
1722         typedef vector_data10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
1723         typedef mpl::vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> types;
1724         typedef vector_tag fusion_tag;
1725         typedef fusion_sequence_tag tag; 
1726         typedef mpl::false_ is_view;
1727         typedef random_access_traversal_tag category;
1728         typedef mpl::int_<10> size;
1729         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1730         vector10() {}
1731 # if !defined(BOOST_CLANG)
1732     BOOST_CONSTEXPR
1733 # endif
1734         BOOST_FUSION_GPU_ENABLED
1735         vector10(
1736             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8 , typename detail::call_param<T9 >::type arg9)
1737             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9) {}
1738 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1739         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1740 # if !defined(BOOST_CLANG)
1741         BOOST_CXX14_CONSTEXPR
1742 # endif
1743         BOOST_FUSION_GPU_ENABLED
1744         vector10(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8 , U9 && arg9)
1745             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6) , std::forward<U7>( arg7) , std::forward<U8>( arg8) , std::forward<U9>( arg9)) {}
1746         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1747         vector10(vector10&& rhs)
1748             : base_type(std::forward<base_type>(rhs)) {}
1749         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1750         vector10(vector10 const& rhs)
1751             : base_type(static_cast<base_type const&>(rhs)) {}
1752         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1753         vector10&
1754         operator=(vector10 const& vec)
1755         {
1756             base_type::operator=(vec);
1757             return *this;
1758         }
1759         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1760         vector10&
1761         operator=(vector10&& vec)
1762         {
1763             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6); this->m7 = std::forward< T7>(vec.m7); this->m8 = std::forward< T8>(vec.m8); this->m9 = std::forward< T9>(vec.m9);
1764             return *this;
1765         }
1766 # endif
1767         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1768 # if !defined(BOOST_CLANG)
1769     BOOST_CXX14_CONSTEXPR
1770 # endif
1771         BOOST_FUSION_GPU_ENABLED
1772         vector10(
1773             vector10<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& vec)
1774             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7 , vec.m8 , vec.m9) {}
1775         template <typename Sequence>
1776 # if !defined(BOOST_CLANG)
1777         BOOST_CXX14_CONSTEXPR
1778 # endif
1779         BOOST_FUSION_GPU_ENABLED
1780         vector10(
1781             Sequence const& seq
1782           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1783             )
1784             : base_type(base_type::init_from_sequence(seq)) {}
1785         template <typename Sequence>
1786 # if !defined(BOOST_CLANG)
1787         BOOST_CXX14_CONSTEXPR
1788 # endif
1789         BOOST_FUSION_GPU_ENABLED
1790         vector10(
1791             Sequence& seq
1792           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1793             )
1794             : base_type(base_type::init_from_sequence(seq)) {}
1795         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1796         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1797         vector10&
1798         operator=(vector10<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& vec)
1799         {
1800             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;
1801             return *this;
1802         }
1803         template <typename Sequence>
1804         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1805         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1806         operator=(Sequence const& seq)
1807         {
1808             typedef typename result_of::begin<Sequence const>::type I0;
1809             I0 i0 = fusion::begin(seq);
1810             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);
1811             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;
1812             return *this;
1813         }
1814         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T8>::type at_impl(mpl::int_<8>) { return this->m8; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T8>::type>::type at_impl(mpl::int_<8>) const { return this->m8; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T9>::type at_impl(mpl::int_<9>) { return this->m9; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T9>::type>::type at_impl(mpl::int_<9>) const { return this->m9; }
1815         template<typename I>
1816         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1817         typename add_reference<typename mpl::at<types, I>::type>::type
1818         at_impl(I)
1819         {
1820             return this->at_impl(mpl::int_<I::value>());
1821         }
1822         template<typename I>
1823         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1824         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1825         at_impl(I) const
1826         {
1827             return this->at_impl(mpl::int_<I::value>());
1828         }
1829     };
1830 }}