File indexing completed on 2025-01-18 09:34:05
0001
0002
0003
0004
0005
0006
0007
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 }}