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