34 template <
typename... Ts>
41 template <
typename TupleType>
42 using TupleSize = std::integral_constant<vtkm::IdComponent, TupleType::Size>;
46 template <
typename TupleType>
47 using tuple_size = std::integral_constant<std::size_t, static_cast<std::size_t>(TupleType::Size)>;
52 template <vtkm::IdComponent Index,
typename TupleType>
53 struct TupleElementImpl
55 using type = decltype(TupleType::ElementTypeI(vtkm::internal::IndexTag<Index>{}));
62 template <vtkm::IdComponent Index,
typename TupleType>
63 using TupleElement =
typename detail::TupleElementImpl<Index, TupleType>::type;
67 template <std::
size_t Index,
typename TupleType>
75 template <std::
size_t Index,
typename TupleType>
82 #ifndef VTKM_DOXYGEN_ONLY
84 -> decltype(tuple.template Get<Index>())
87 return tuple.template Get<Index>();
94 #ifndef VTKM_DOXYGEN_ONLY
96 -> decltype(tuple.template Get<Index>())
99 return tuple.template Get<Index>();
104 template <std::size_t
Index,
typename... Ts>
108 return vtkm::Get<static_cast<vtkm::IdComponent>(
Index)>(tuple);
113 template <std::size_t
Index,
typename... Ts>
117 return vtkm::Get<static_cast<vtkm::IdComponent>(
Index)>(tuple);
123 template <
typename... Ts>
132 template <
typename... Ts>
141 struct TupleTransformFunctor
144 template <
typename Function,
typename... Ts>
152 struct TupleForEachFunctor
155 template <
typename Function,
typename... Ts>
158 (void)std::initializer_list<bool>{ (f(std::forward<Ts>(args)),
false)... };
174 template <
typename... Ts,
typename Function,
typename... Args>
176 -> decltype(tuple.Apply(std::forward<Function>(f), std::forward<Args>(args)...))
178 return tuple.Apply(std::forward<Function>(f), std::forward<Args>(args)...);
182 template <
typename... Ts,
typename Function,
typename... Args>
184 -> decltype(tuple.Apply(std::forward<Function>(f), std::forward<Args>(args)...))
186 return tuple.Apply(std::forward<Function>(f), std::forward<Args>(args)...);
192 template <
typename... Ts,
typename Function>
195 return vtkm::Apply(tuple, detail::TupleForEachFunctor{}, std::forward<Function>(f));
199 template <
typename... Ts,
typename Function>
202 return vtkm::Apply(tuple, detail::TupleForEachFunctor{}, std::forward<Function>(f));
212 template <
typename TupleType,
typename Function>
214 -> decltype(
Apply(tuple, detail::TupleTransformFunctor(), std::forward<Function>(f)))
216 return Apply(tuple, detail::TupleTransformFunctor(), std::forward<Function>(f));
219 template <
typename TupleType,
typename Function>
221 -> decltype(
Apply(tuple, detail::TupleTransformFunctor(), std::forward<Function>(f)))
223 return Apply(tuple, detail::TupleTransformFunctor(), std::forward<Function>(f));
234 template <
typename Function,
typename... Args>
236 -> decltype(f(std::forward<Args>(args)...))
238 return f(std::forward<Args>(args)...);
241 template <
typename Function,
typename... Args>
243 -> decltype(f(std::forward<Args>(args)...))
245 return f(std::forward<Args>(args)...);
249 template <
typename Function>
255 template <
typename Function>
264 template<
typename T0>
268 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
280 template <vtkm::IdComponent Index>
281 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
283 template <vtkm::IdComponent,
typename>
284 friend struct detail::TupleElementImpl;
288 template <vtkm::IdComponent Index>
299 template <
typename A0>
301 : Value0(std::forward<A0>(a0))
305 template <vtkm::IdComponent Index>
308 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
311 template <vtkm::IdComponent Index>
314 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
318 template <
typename Function,
typename... Args>
320 auto Apply(Function&& f, Args&&... args)
321 -> decltype(f(std::forward<Args>(args)..., Value0))
323 return f(std::forward<Args>(args)..., Value0);
326 template <
typename Function,
typename... Args>
328 auto Apply(Function&& f, Args&&... args)
const
329 -> decltype(f(std::forward<Args>(args)..., Value0))
331 return f(std::forward<Args>(args)..., Value0);
335 template <
typename Function>
341 template <
typename Function>
348 template <
typename Function>
355 template <
typename Function>
363 template<
typename T0,
typename T1>
367 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
378 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
390 template <vtkm::IdComponent Index>
391 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
393 template <vtkm::IdComponent,
typename>
394 friend struct detail::TupleElementImpl;
398 template <vtkm::IdComponent Index>
409 template <
typename A0,
typename A1>
411 : Value0(std::forward<A0>(a0))
412 , Value1(std::forward<A1>(a1))
416 template <vtkm::IdComponent Index>
419 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
422 template <vtkm::IdComponent Index>
425 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
429 template <
typename Function,
typename... Args>
431 auto Apply(Function&& f, Args&&... args)
432 -> decltype(f(std::forward<Args>(args)..., Value0, Value1))
434 return f(std::forward<Args>(args)..., Value0, Value1);
437 template <
typename Function,
typename... Args>
439 auto Apply(Function&& f, Args&&... args)
const
440 -> decltype(f(std::forward<Args>(args)..., Value0, Value1))
442 return f(std::forward<Args>(args)..., Value0, Value1);
446 template <
typename Function>
452 template <
typename Function>
459 template <
typename Function>
466 template <
typename Function>
474 template<
typename T0,
typename T1,
typename T2>
478 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
489 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
500 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
512 template <vtkm::IdComponent Index>
513 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
515 template <vtkm::IdComponent,
typename>
516 friend struct detail::TupleElementImpl;
520 template <vtkm::IdComponent Index>
531 template <
typename A0,
typename A1,
typename A2>
533 : Value0(std::forward<A0>(a0))
534 , Value1(std::forward<A1>(a1))
535 , Value2(std::forward<A2>(a2))
539 template <vtkm::IdComponent Index>
542 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
545 template <vtkm::IdComponent Index>
548 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
552 template <
typename Function,
typename... Args>
554 auto Apply(Function&& f, Args&&... args)
555 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2))
557 return f(std::forward<Args>(args)..., Value0, Value1, Value2);
560 template <
typename Function,
typename... Args>
562 auto Apply(Function&& f, Args&&... args)
const
563 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2))
565 return f(std::forward<Args>(args)..., Value0, Value1, Value2);
569 template <
typename Function>
575 template <
typename Function>
582 template <
typename Function>
589 template <
typename Function>
597 template<
typename T0,
typename T1,
typename T2,
typename T3>
601 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
612 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
623 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
634 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
646 template <vtkm::IdComponent Index>
647 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
649 template <vtkm::IdComponent,
typename>
650 friend struct detail::TupleElementImpl;
654 template <vtkm::IdComponent Index>
665 template <
typename A0,
typename A1,
typename A2,
typename A3>
667 : Value0(std::forward<A0>(a0))
668 , Value1(std::forward<A1>(a1))
669 , Value2(std::forward<A2>(a2))
670 , Value3(std::forward<A3>(a3))
674 template <vtkm::IdComponent Index>
677 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
680 template <vtkm::IdComponent Index>
683 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
687 template <
typename Function,
typename... Args>
689 auto Apply(Function&& f, Args&&... args)
690 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3))
692 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3);
695 template <
typename Function,
typename... Args>
697 auto Apply(Function&& f, Args&&... args)
const
698 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3))
700 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3);
704 template <
typename Function>
710 template <
typename Function>
717 template <
typename Function>
724 template <
typename Function>
732 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4>
736 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
747 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
758 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
769 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
780 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
792 template <vtkm::IdComponent Index>
793 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
795 template <vtkm::IdComponent,
typename>
796 friend struct detail::TupleElementImpl;
800 template <vtkm::IdComponent Index>
811 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4>
813 : Value0(std::forward<A0>(a0))
814 , Value1(std::forward<A1>(a1))
815 , Value2(std::forward<A2>(a2))
816 , Value3(std::forward<A3>(a3))
817 , Value4(std::forward<A4>(a4))
821 template <vtkm::IdComponent Index>
824 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
827 template <vtkm::IdComponent Index>
830 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
834 template <
typename Function,
typename... Args>
836 auto Apply(Function&& f, Args&&... args)
837 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4))
839 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4);
842 template <
typename Function,
typename... Args>
844 auto Apply(Function&& f, Args&&... args)
const
845 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4))
847 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4);
851 template <
typename Function>
857 template <
typename Function>
864 template <
typename Function>
871 template <
typename Function>
879 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
883 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
894 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
905 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
916 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
927 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
938 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
950 template <vtkm::IdComponent Index>
951 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
953 template <vtkm::IdComponent,
typename>
954 friend struct detail::TupleElementImpl;
958 template <vtkm::IdComponent Index>
969 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
971 : Value0(std::forward<A0>(a0))
972 , Value1(std::forward<A1>(a1))
973 , Value2(std::forward<A2>(a2))
974 , Value3(std::forward<A3>(a3))
975 , Value4(std::forward<A4>(a4))
976 , Value5(std::forward<A5>(a5))
980 template <vtkm::IdComponent Index>
983 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
986 template <vtkm::IdComponent Index>
989 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
993 template <
typename Function,
typename... Args>
995 auto Apply(Function&& f, Args&&... args)
996 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5))
998 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5);
1001 template <
typename Function,
typename... Args>
1003 auto Apply(Function&& f, Args&&... args)
const
1004 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5))
1006 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5);
1010 template <
typename Function>
1016 template <
typename Function>
1023 template <
typename Function>
1030 template <
typename Function>
1038 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6>
1042 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1045 return this->Value0;
1049 return this->Value0;
1053 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1056 return this->Value1;
1060 return this->Value1;
1064 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1067 return this->Value2;
1071 return this->Value2;
1075 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1078 return this->Value3;
1082 return this->Value3;
1086 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1089 return this->Value4;
1093 return this->Value4;
1097 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1100 return this->Value5;
1104 return this->Value5;
1108 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1111 return this->Value6;
1115 return this->Value6;
1120 template <vtkm::IdComponent Index>
1121 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1123 template <vtkm::IdComponent,
typename>
1124 friend struct detail::TupleElementImpl;
1128 template <vtkm::IdComponent Index>
1139 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
1141 : Value0(std::forward<A0>(a0))
1142 , Value1(std::forward<A1>(a1))
1143 , Value2(std::forward<A2>(a2))
1144 , Value3(std::forward<A3>(a3))
1145 , Value4(std::forward<A4>(a4))
1146 , Value5(std::forward<A5>(a5))
1147 , Value6(std::forward<A6>(a6))
1151 template <vtkm::IdComponent Index>
1154 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1157 template <vtkm::IdComponent Index>
1160 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1164 template <
typename Function,
typename... Args>
1166 auto Apply(Function&& f, Args&&... args)
1167 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6))
1169 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6);
1172 template <
typename Function,
typename... Args>
1174 auto Apply(Function&& f, Args&&... args)
const
1175 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6))
1177 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6);
1181 template <
typename Function>
1187 template <
typename Function>
1194 template <
typename Function>
1201 template <
typename Function>
1209 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7>
1210 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7>
1213 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1216 return this->Value0;
1220 return this->Value0;
1224 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1227 return this->Value1;
1231 return this->Value1;
1235 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1238 return this->Value2;
1242 return this->Value2;
1246 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1249 return this->Value3;
1253 return this->Value3;
1257 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1260 return this->Value4;
1264 return this->Value4;
1268 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1271 return this->Value5;
1275 return this->Value5;
1279 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1282 return this->Value6;
1286 return this->Value6;
1290 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1293 return this->Value7;
1297 return this->Value7;
1302 template <vtkm::IdComponent Index>
1303 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1305 template <vtkm::IdComponent,
typename>
1306 friend struct detail::TupleElementImpl;
1310 template <vtkm::IdComponent Index>
1321 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
1323 : Value0(std::forward<A0>(a0))
1324 , Value1(std::forward<A1>(a1))
1325 , Value2(std::forward<A2>(a2))
1326 , Value3(std::forward<A3>(a3))
1327 , Value4(std::forward<A4>(a4))
1328 , Value5(std::forward<A5>(a5))
1329 , Value6(std::forward<A6>(a6))
1330 , Value7(std::forward<A7>(a7))
1334 template <vtkm::IdComponent Index>
1337 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1340 template <vtkm::IdComponent Index>
1343 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1347 template <
typename Function,
typename... Args>
1349 auto Apply(Function&& f, Args&&... args)
1350 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7))
1352 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7);
1355 template <
typename Function,
typename... Args>
1357 auto Apply(Function&& f, Args&&... args)
const
1358 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7))
1360 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7);
1364 template <
typename Function>
1370 template <
typename Function>
1377 template <
typename Function>
1384 template <
typename Function>
1392 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8>
1393 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8>
1396 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1399 return this->Value0;
1403 return this->Value0;
1407 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1410 return this->Value1;
1414 return this->Value1;
1418 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1421 return this->Value2;
1425 return this->Value2;
1429 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1432 return this->Value3;
1436 return this->Value3;
1440 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1443 return this->Value4;
1447 return this->Value4;
1451 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1454 return this->Value5;
1458 return this->Value5;
1462 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1465 return this->Value6;
1469 return this->Value6;
1473 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1476 return this->Value7;
1480 return this->Value7;
1484 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
1487 return this->Value8;
1491 return this->Value8;
1496 template <vtkm::IdComponent Index>
1497 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1499 template <vtkm::IdComponent,
typename>
1500 friend struct detail::TupleElementImpl;
1504 template <vtkm::IdComponent Index>
1515 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8>
1517 : Value0(std::forward<A0>(a0))
1518 , Value1(std::forward<A1>(a1))
1519 , Value2(std::forward<A2>(a2))
1520 , Value3(std::forward<A3>(a3))
1521 , Value4(std::forward<A4>(a4))
1522 , Value5(std::forward<A5>(a5))
1523 , Value6(std::forward<A6>(a6))
1524 , Value7(std::forward<A7>(a7))
1525 , Value8(std::forward<A8>(a8))
1529 template <vtkm::IdComponent Index>
1532 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1535 template <vtkm::IdComponent Index>
1538 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1542 template <
typename Function,
typename... Args>
1544 auto Apply(Function&& f, Args&&... args)
1545 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8))
1547 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8);
1550 template <
typename Function,
typename... Args>
1552 auto Apply(Function&& f, Args&&... args)
const
1553 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8))
1555 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8);
1559 template <
typename Function>
1565 template <
typename Function>
1572 template <
typename Function>
1579 template <
typename Function>
1587 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9>
1588 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
1591 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1594 return this->Value0;
1598 return this->Value0;
1602 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1605 return this->Value1;
1609 return this->Value1;
1613 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1616 return this->Value2;
1620 return this->Value2;
1624 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1627 return this->Value3;
1631 return this->Value3;
1635 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1638 return this->Value4;
1642 return this->Value4;
1646 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1649 return this->Value5;
1653 return this->Value5;
1657 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1660 return this->Value6;
1664 return this->Value6;
1668 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1671 return this->Value7;
1675 return this->Value7;
1679 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
1682 return this->Value8;
1686 return this->Value8;
1690 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
1693 return this->Value9;
1697 return this->Value9;
1702 template <vtkm::IdComponent Index>
1703 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1705 template <vtkm::IdComponent,
typename>
1706 friend struct detail::TupleElementImpl;
1710 template <vtkm::IdComponent Index>
1711 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>;
1721 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9>
1722 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9)
1723 : Value0(std::forward<A0>(a0))
1724 , Value1(std::forward<A1>(a1))
1725 , Value2(std::forward<A2>(a2))
1726 , Value3(std::forward<A3>(a3))
1727 , Value4(std::forward<A4>(a4))
1728 , Value5(std::forward<A5>(a5))
1729 , Value6(std::forward<A6>(a6))
1730 , Value7(std::forward<A7>(a7))
1731 , Value8(std::forward<A8>(a8))
1732 , Value9(std::forward<A9>(a9))
1736 template <vtkm::IdComponent Index>
1739 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1742 template <vtkm::IdComponent Index>
1745 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1749 template <
typename Function,
typename... Args>
1751 auto Apply(Function&& f, Args&&... args)
1752 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9))
1754 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9);
1757 template <
typename Function,
typename... Args>
1759 auto Apply(Function&& f, Args&&... args)
const
1760 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9))
1762 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9);
1766 template <
typename Function>
1772 template <
typename Function>
1779 template <
typename Function>
1786 template <
typename Function>
1794 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10>
1795 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
1798 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1801 return this->Value0;
1805 return this->Value0;
1809 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1812 return this->Value1;
1816 return this->Value1;
1820 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1823 return this->Value2;
1827 return this->Value2;
1831 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1834 return this->Value3;
1838 return this->Value3;
1842 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1845 return this->Value4;
1849 return this->Value4;
1853 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1856 return this->Value5;
1860 return this->Value5;
1864 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1867 return this->Value6;
1871 return this->Value6;
1875 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1878 return this->Value7;
1882 return this->Value7;
1886 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
1889 return this->Value8;
1893 return this->Value8;
1897 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
1900 return this->Value9;
1904 return this->Value9;
1908 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
1911 return this->Value10;
1915 return this->Value10;
1920 template <vtkm::IdComponent Index>
1921 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1923 template <vtkm::IdComponent,
typename>
1924 friend struct detail::TupleElementImpl;
1928 template <vtkm::IdComponent Index>
1929 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>>;
1939 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10>
1940 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10)
1941 : Value0(std::forward<A0>(a0))
1942 , Value1(std::forward<A1>(a1))
1943 , Value2(std::forward<A2>(a2))
1944 , Value3(std::forward<A3>(a3))
1945 , Value4(std::forward<A4>(a4))
1946 , Value5(std::forward<A5>(a5))
1947 , Value6(std::forward<A6>(a6))
1948 , Value7(std::forward<A7>(a7))
1949 , Value8(std::forward<A8>(a8))
1950 , Value9(std::forward<A9>(a9))
1951 , Value10(std::forward<A10>(a10))
1955 template <vtkm::IdComponent Index>
1958 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1961 template <vtkm::IdComponent Index>
1964 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1968 template <
typename Function,
typename... Args>
1970 auto Apply(Function&& f, Args&&... args)
1971 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10))
1973 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10);
1976 template <
typename Function,
typename... Args>
1978 auto Apply(Function&& f, Args&&... args)
const
1979 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10))
1981 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10);
1985 template <
typename Function>
1991 template <
typename Function>
1998 template <
typename Function>
2005 template <
typename Function>
2013 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11>
2014 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
2017 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2020 return this->Value0;
2024 return this->Value0;
2028 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2031 return this->Value1;
2035 return this->Value1;
2039 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2042 return this->Value2;
2046 return this->Value2;
2050 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2053 return this->Value3;
2057 return this->Value3;
2061 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2064 return this->Value4;
2068 return this->Value4;
2072 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2075 return this->Value5;
2079 return this->Value5;
2083 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2086 return this->Value6;
2090 return this->Value6;
2094 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2097 return this->Value7;
2101 return this->Value7;
2105 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2108 return this->Value8;
2112 return this->Value8;
2116 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2119 return this->Value9;
2123 return this->Value9;
2127 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2130 return this->Value10;
2134 return this->Value10;
2138 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2141 return this->Value11;
2145 return this->Value11;
2150 template <vtkm::IdComponent Index>
2151 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2153 template <vtkm::IdComponent,
typename>
2154 friend struct detail::TupleElementImpl;
2158 template <vtkm::IdComponent Index>
2159 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>>;
2169 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11>
2170 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11)
2171 : Value0(std::forward<A0>(a0))
2172 , Value1(std::forward<A1>(a1))
2173 , Value2(std::forward<A2>(a2))
2174 , Value3(std::forward<A3>(a3))
2175 , Value4(std::forward<A4>(a4))
2176 , Value5(std::forward<A5>(a5))
2177 , Value6(std::forward<A6>(a6))
2178 , Value7(std::forward<A7>(a7))
2179 , Value8(std::forward<A8>(a8))
2180 , Value9(std::forward<A9>(a9))
2181 , Value10(std::forward<A10>(a10))
2182 , Value11(std::forward<A11>(a11))
2186 template <vtkm::IdComponent Index>
2189 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2192 template <vtkm::IdComponent Index>
2195 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2199 template <
typename Function,
typename... Args>
2201 auto Apply(Function&& f, Args&&... args)
2202 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11))
2204 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11);
2207 template <
typename Function,
typename... Args>
2209 auto Apply(Function&& f, Args&&... args)
const
2210 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11))
2212 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11);
2216 template <
typename Function>
2222 template <
typename Function>
2229 template <
typename Function>
2236 template <
typename Function>
2244 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12>
2245 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
2248 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2251 return this->Value0;
2255 return this->Value0;
2259 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2262 return this->Value1;
2266 return this->Value1;
2270 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2273 return this->Value2;
2277 return this->Value2;
2281 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2284 return this->Value3;
2288 return this->Value3;
2292 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2295 return this->Value4;
2299 return this->Value4;
2303 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2306 return this->Value5;
2310 return this->Value5;
2314 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2317 return this->Value6;
2321 return this->Value6;
2325 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2328 return this->Value7;
2332 return this->Value7;
2336 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2339 return this->Value8;
2343 return this->Value8;
2347 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2350 return this->Value9;
2354 return this->Value9;
2358 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2361 return this->Value10;
2365 return this->Value10;
2369 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2372 return this->Value11;
2376 return this->Value11;
2380 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
2383 return this->Value12;
2387 return this->Value12;
2392 template <vtkm::IdComponent Index>
2393 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2395 template <vtkm::IdComponent,
typename>
2396 friend struct detail::TupleElementImpl;
2400 template <vtkm::IdComponent Index>
2401 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>>;
2411 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12>
2412 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12)
2413 : Value0(std::forward<A0>(a0))
2414 , Value1(std::forward<A1>(a1))
2415 , Value2(std::forward<A2>(a2))
2416 , Value3(std::forward<A3>(a3))
2417 , Value4(std::forward<A4>(a4))
2418 , Value5(std::forward<A5>(a5))
2419 , Value6(std::forward<A6>(a6))
2420 , Value7(std::forward<A7>(a7))
2421 , Value8(std::forward<A8>(a8))
2422 , Value9(std::forward<A9>(a9))
2423 , Value10(std::forward<A10>(a10))
2424 , Value11(std::forward<A11>(a11))
2425 , Value12(std::forward<A12>(a12))
2429 template <vtkm::IdComponent Index>
2432 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2435 template <vtkm::IdComponent Index>
2438 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2442 template <
typename Function,
typename... Args>
2444 auto Apply(Function&& f, Args&&... args)
2445 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12))
2447 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12);
2450 template <
typename Function,
typename... Args>
2452 auto Apply(Function&& f, Args&&... args)
const
2453 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12))
2455 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12);
2459 template <
typename Function>
2465 template <
typename Function>
2472 template <
typename Function>
2479 template <
typename Function>
2487 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13>
2488 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
2491 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2494 return this->Value0;
2498 return this->Value0;
2502 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2505 return this->Value1;
2509 return this->Value1;
2513 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2516 return this->Value2;
2520 return this->Value2;
2524 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2527 return this->Value3;
2531 return this->Value3;
2535 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2538 return this->Value4;
2542 return this->Value4;
2546 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2549 return this->Value5;
2553 return this->Value5;
2557 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2560 return this->Value6;
2564 return this->Value6;
2568 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2571 return this->Value7;
2575 return this->Value7;
2579 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2582 return this->Value8;
2586 return this->Value8;
2590 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2593 return this->Value9;
2597 return this->Value9;
2601 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2604 return this->Value10;
2608 return this->Value10;
2612 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2615 return this->Value11;
2619 return this->Value11;
2623 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
2626 return this->Value12;
2630 return this->Value12;
2634 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
2637 return this->Value13;
2641 return this->Value13;
2646 template <vtkm::IdComponent Index>
2647 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2649 template <vtkm::IdComponent,
typename>
2650 friend struct detail::TupleElementImpl;
2654 template <vtkm::IdComponent Index>
2655 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>>;
2665 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13>
2666 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13)
2667 : Value0(std::forward<A0>(a0))
2668 , Value1(std::forward<A1>(a1))
2669 , Value2(std::forward<A2>(a2))
2670 , Value3(std::forward<A3>(a3))
2671 , Value4(std::forward<A4>(a4))
2672 , Value5(std::forward<A5>(a5))
2673 , Value6(std::forward<A6>(a6))
2674 , Value7(std::forward<A7>(a7))
2675 , Value8(std::forward<A8>(a8))
2676 , Value9(std::forward<A9>(a9))
2677 , Value10(std::forward<A10>(a10))
2678 , Value11(std::forward<A11>(a11))
2679 , Value12(std::forward<A12>(a12))
2680 , Value13(std::forward<A13>(a13))
2684 template <vtkm::IdComponent Index>
2687 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2690 template <vtkm::IdComponent Index>
2693 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2697 template <
typename Function,
typename... Args>
2699 auto Apply(Function&& f, Args&&... args)
2700 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13))
2702 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13);
2705 template <
typename Function,
typename... Args>
2707 auto Apply(Function&& f, Args&&... args)
const
2708 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13))
2710 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13);
2714 template <
typename Function>
2720 template <
typename Function>
2727 template <
typename Function>
2734 template <
typename Function>
2742 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13,
typename T14>
2743 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
2746 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2749 return this->Value0;
2753 return this->Value0;
2757 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2760 return this->Value1;
2764 return this->Value1;
2768 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2771 return this->Value2;
2775 return this->Value2;
2779 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2782 return this->Value3;
2786 return this->Value3;
2790 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2793 return this->Value4;
2797 return this->Value4;
2801 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2804 return this->Value5;
2808 return this->Value5;
2812 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2815 return this->Value6;
2819 return this->Value6;
2823 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2826 return this->Value7;
2830 return this->Value7;
2834 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2837 return this->Value8;
2841 return this->Value8;
2845 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2848 return this->Value9;
2852 return this->Value9;
2856 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2859 return this->Value10;
2863 return this->Value10;
2867 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2870 return this->Value11;
2874 return this->Value11;
2878 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
2881 return this->Value12;
2885 return this->Value12;
2889 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
2892 return this->Value13;
2896 return this->Value13;
2900 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
2903 return this->Value14;
2907 return this->Value14;
2912 template <vtkm::IdComponent Index>
2913 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2915 template <vtkm::IdComponent,
typename>
2916 friend struct detail::TupleElementImpl;
2920 template <vtkm::IdComponent Index>
2921 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>>;
2931 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14>
2932 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13, A14&& a14)
2933 : Value0(std::forward<A0>(a0))
2934 , Value1(std::forward<A1>(a1))
2935 , Value2(std::forward<A2>(a2))
2936 , Value3(std::forward<A3>(a3))
2937 , Value4(std::forward<A4>(a4))
2938 , Value5(std::forward<A5>(a5))
2939 , Value6(std::forward<A6>(a6))
2940 , Value7(std::forward<A7>(a7))
2941 , Value8(std::forward<A8>(a8))
2942 , Value9(std::forward<A9>(a9))
2943 , Value10(std::forward<A10>(a10))
2944 , Value11(std::forward<A11>(a11))
2945 , Value12(std::forward<A12>(a12))
2946 , Value13(std::forward<A13>(a13))
2947 , Value14(std::forward<A14>(a14))
2951 template <vtkm::IdComponent Index>
2954 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2957 template <vtkm::IdComponent Index>
2960 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2964 template <
typename Function,
typename... Args>
2966 auto Apply(Function&& f, Args&&... args)
2967 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14))
2969 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14);
2972 template <
typename Function,
typename... Args>
2974 auto Apply(Function&& f, Args&&... args)
const
2975 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14))
2977 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14);
2981 template <
typename Function>
2987 template <
typename Function>
2994 template <
typename Function>
3001 template <
typename Function>
3009 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13,
typename T14,
typename T15>
3010 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
3013 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
3016 return this->Value0;
3020 return this->Value0;
3024 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
3027 return this->Value1;
3031 return this->Value1;
3035 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
3038 return this->Value2;
3042 return this->Value2;
3046 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
3049 return this->Value3;
3053 return this->Value3;
3057 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3060 return this->Value4;
3064 return this->Value4;
3068 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3071 return this->Value5;
3075 return this->Value5;
3079 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3082 return this->Value6;
3086 return this->Value6;
3090 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3093 return this->Value7;
3097 return this->Value7;
3101 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3104 return this->Value8;
3108 return this->Value8;
3112 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3115 return this->Value9;
3119 return this->Value9;
3123 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3126 return this->Value10;
3130 return this->Value10;
3134 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
3137 return this->Value11;
3141 return this->Value11;
3145 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
3148 return this->Value12;
3152 return this->Value12;
3156 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
3159 return this->Value13;
3163 return this->Value13;
3167 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
3170 return this->Value14;
3174 return this->Value14;
3178 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
3181 return this->Value15;
3185 return this->Value15;
3190 template <vtkm::IdComponent Index>
3191 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
3193 template <vtkm::IdComponent,
typename>
3194 friend struct detail::TupleElementImpl;
3198 template <vtkm::IdComponent Index>
3199 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>;
3209 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15>
3210 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13, A14&& a14, A15&& a15)
3211 : Value0(std::forward<A0>(a0))
3212 , Value1(std::forward<A1>(a1))
3213 , Value2(std::forward<A2>(a2))
3214 , Value3(std::forward<A3>(a3))
3215 , Value4(std::forward<A4>(a4))
3216 , Value5(std::forward<A5>(a5))
3217 , Value6(std::forward<A6>(a6))
3218 , Value7(std::forward<A7>(a7))
3219 , Value8(std::forward<A8>(a8))
3220 , Value9(std::forward<A9>(a9))
3221 , Value10(std::forward<A10>(a10))
3222 , Value11(std::forward<A11>(a11))
3223 , Value12(std::forward<A12>(a12))
3224 , Value13(std::forward<A13>(a13))
3225 , Value14(std::forward<A14>(a14))
3226 , Value15(std::forward<A15>(a15))
3230 template <vtkm::IdComponent Index>
3233 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3236 template <vtkm::IdComponent Index>
3239 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3243 template <
typename Function,
typename... Args>
3245 auto Apply(Function&& f, Args&&... args)
3246 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15))
3248 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15);
3251 template <
typename Function,
typename... Args>
3253 auto Apply(Function&& f, Args&&... args)
const
3254 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15))
3256 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15);
3260 template <
typename Function>
3266 template <
typename Function>
3273 template <
typename Function>
3280 template <
typename Function>
3288 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13,
typename T14,
typename T15,
typename T16>
3289 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
3292 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
3295 return this->Value0;
3299 return this->Value0;
3303 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
3306 return this->Value1;
3310 return this->Value1;
3314 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
3317 return this->Value2;
3321 return this->Value2;
3325 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
3328 return this->Value3;
3332 return this->Value3;
3336 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3339 return this->Value4;
3343 return this->Value4;
3347 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3350 return this->Value5;
3354 return this->Value5;
3358 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3361 return this->Value6;
3365 return this->Value6;
3369 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3372 return this->Value7;
3376 return this->Value7;
3380 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3383 return this->Value8;
3387 return this->Value8;
3391 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3394 return this->Value9;
3398 return this->Value9;
3402 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3405 return this->Value10;
3409 return this->Value10;
3413 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
3416 return this->Value11;
3420 return this->Value11;
3424 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
3427 return this->Value12;
3431 return this->Value12;
3435 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
3438 return this->Value13;
3442 return this->Value13;
3446 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
3449 return this->Value14;
3453 return this->Value14;
3457 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
3460 return this->Value15;
3464 return this->Value15;
3468 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
3471 return this->Value16;
3475 return this->Value16;
3480 template <vtkm::IdComponent Index>
3481 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
3483 template <vtkm::IdComponent,
typename>
3484 friend struct detail::TupleElementImpl;
3488 template <vtkm::IdComponent Index>
3489 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>>;
3499 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15,
typename A16>
3500 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13, A14&& a14, A15&& a15, A16&& a16)
3501 : Value0(std::forward<A0>(a0))
3502 , Value1(std::forward<A1>(a1))
3503 , Value2(std::forward<A2>(a2))
3504 , Value3(std::forward<A3>(a3))
3505 , Value4(std::forward<A4>(a4))
3506 , Value5(std::forward<A5>(a5))
3507 , Value6(std::forward<A6>(a6))
3508 , Value7(std::forward<A7>(a7))
3509 , Value8(std::forward<A8>(a8))
3510 , Value9(std::forward<A9>(a9))
3511 , Value10(std::forward<A10>(a10))
3512 , Value11(std::forward<A11>(a11))
3513 , Value12(std::forward<A12>(a12))
3514 , Value13(std::forward<A13>(a13))
3515 , Value14(std::forward<A14>(a14))
3516 , Value15(std::forward<A15>(a15))
3517 , Value16(std::forward<A16>(a16))
3521 template <vtkm::IdComponent Index>
3524 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3527 template <vtkm::IdComponent Index>
3530 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3534 template <
typename Function,
typename... Args>
3536 auto Apply(Function&& f, Args&&... args)
3537 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16))
3539 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16);
3542 template <
typename Function,
typename... Args>
3544 auto Apply(Function&& f, Args&&... args)
const
3545 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16))
3547 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16);
3551 template <
typename Function>
3557 template <
typename Function>
3564 template <
typename Function>
3571 template <
typename Function>
3579 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13,
typename T14,
typename T15,
typename T16,
typename T17>
3580 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
3583 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
3586 return this->Value0;
3590 return this->Value0;
3594 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
3597 return this->Value1;
3601 return this->Value1;
3605 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
3608 return this->Value2;
3612 return this->Value2;
3616 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
3619 return this->Value3;
3623 return this->Value3;
3627 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3630 return this->Value4;
3634 return this->Value4;
3638 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3641 return this->Value5;
3645 return this->Value5;
3649 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3652 return this->Value6;
3656 return this->Value6;
3660 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3663 return this->Value7;
3667 return this->Value7;
3671 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3674 return this->Value8;
3678 return this->Value8;
3682 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3685 return this->Value9;
3689 return this->Value9;
3693 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3696 return this->Value10;
3700 return this->Value10;
3704 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
3707 return this->Value11;
3711 return this->Value11;
3715 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
3718 return this->Value12;
3722 return this->Value12;
3726 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
3729 return this->Value13;
3733 return this->Value13;
3737 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
3740 return this->Value14;
3744 return this->Value14;
3748 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
3751 return this->Value15;
3755 return this->Value15;
3759 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
3762 return this->Value16;
3766 return this->Value16;
3770 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
3773 return this->Value17;
3777 return this->Value17;
3782 template <vtkm::IdComponent Index>
3783 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
3785 template <vtkm::IdComponent,
typename>
3786 friend struct detail::TupleElementImpl;
3790 template <vtkm::IdComponent Index>
3791 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>>;
3801 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15,
typename A16,
typename A17>
3802 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13, A14&& a14, A15&& a15, A16&& a16, A17&& a17)
3803 : Value0(std::forward<A0>(a0))
3804 , Value1(std::forward<A1>(a1))
3805 , Value2(std::forward<A2>(a2))
3806 , Value3(std::forward<A3>(a3))
3807 , Value4(std::forward<A4>(a4))
3808 , Value5(std::forward<A5>(a5))
3809 , Value6(std::forward<A6>(a6))
3810 , Value7(std::forward<A7>(a7))
3811 , Value8(std::forward<A8>(a8))
3812 , Value9(std::forward<A9>(a9))
3813 , Value10(std::forward<A10>(a10))
3814 , Value11(std::forward<A11>(a11))
3815 , Value12(std::forward<A12>(a12))
3816 , Value13(std::forward<A13>(a13))
3817 , Value14(std::forward<A14>(a14))
3818 , Value15(std::forward<A15>(a15))
3819 , Value16(std::forward<A16>(a16))
3820 , Value17(std::forward<A17>(a17))
3824 template <vtkm::IdComponent Index>
3827 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3830 template <vtkm::IdComponent Index>
3833 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3837 template <
typename Function,
typename... Args>
3839 auto Apply(Function&& f, Args&&... args)
3840 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17))
3842 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17);
3845 template <
typename Function,
typename... Args>
3847 auto Apply(Function&& f, Args&&... args)
const
3848 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17))
3850 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17);
3854 template <
typename Function>
3860 template <
typename Function>
3867 template <
typename Function>
3874 template <
typename Function>
3882 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13,
typename T14,
typename T15,
typename T16,
typename T17,
typename T18>
3883 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
3886 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
3889 return this->Value0;
3893 return this->Value0;
3897 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
3900 return this->Value1;
3904 return this->Value1;
3908 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
3911 return this->Value2;
3915 return this->Value2;
3919 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
3922 return this->Value3;
3926 return this->Value3;
3930 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3933 return this->Value4;
3937 return this->Value4;
3941 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3944 return this->Value5;
3948 return this->Value5;
3952 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3955 return this->Value6;
3959 return this->Value6;
3963 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3966 return this->Value7;
3970 return this->Value7;
3974 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3977 return this->Value8;
3981 return this->Value8;
3985 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3988 return this->Value9;
3992 return this->Value9;
3996 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3999 return this->Value10;
4003 return this->Value10;
4007 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
4010 return this->Value11;
4014 return this->Value11;
4018 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
4021 return this->Value12;
4025 return this->Value12;
4029 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
4032 return this->Value13;
4036 return this->Value13;
4040 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
4043 return this->Value14;
4047 return this->Value14;
4051 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
4054 return this->Value15;
4058 return this->Value15;
4062 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
4065 return this->Value16;
4069 return this->Value16;
4073 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
4076 return this->Value17;
4080 return this->Value17;
4084 static T18 ElementTypeI(vtkm::internal::IndexTag<18>);
4087 return this->Value18;
4091 return this->Value18;
4096 template <vtkm::IdComponent Index>
4097 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
4099 template <vtkm::IdComponent,
typename>
4100 friend struct detail::TupleElementImpl;
4104 template <vtkm::IdComponent Index>
4105 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>>;
4115 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15,
typename A16,
typename A17,
typename A18>
4116 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13, A14&& a14, A15&& a15, A16&& a16, A17&& a17, A18&& a18)
4117 : Value0(std::forward<A0>(a0))
4118 , Value1(std::forward<A1>(a1))
4119 , Value2(std::forward<A2>(a2))
4120 , Value3(std::forward<A3>(a3))
4121 , Value4(std::forward<A4>(a4))
4122 , Value5(std::forward<A5>(a5))
4123 , Value6(std::forward<A6>(a6))
4124 , Value7(std::forward<A7>(a7))
4125 , Value8(std::forward<A8>(a8))
4126 , Value9(std::forward<A9>(a9))
4127 , Value10(std::forward<A10>(a10))
4128 , Value11(std::forward<A11>(a11))
4129 , Value12(std::forward<A12>(a12))
4130 , Value13(std::forward<A13>(a13))
4131 , Value14(std::forward<A14>(a14))
4132 , Value15(std::forward<A15>(a15))
4133 , Value16(std::forward<A16>(a16))
4134 , Value17(std::forward<A17>(a17))
4135 , Value18(std::forward<A18>(a18))
4139 template <vtkm::IdComponent Index>
4142 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4145 template <vtkm::IdComponent Index>
4148 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4152 template <
typename Function,
typename... Args>
4154 auto Apply(Function&& f, Args&&... args)
4155 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18))
4157 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18);
4160 template <
typename Function,
typename... Args>
4162 auto Apply(Function&& f, Args&&... args)
const
4163 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18))
4165 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18);
4169 template <
typename Function>
4175 template <
typename Function>
4182 template <
typename Function>
4189 template <
typename Function>
4197 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13,
typename T14,
typename T15,
typename T16,
typename T17,
typename T18,
typename T19>
4198 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
4201 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
4204 return this->Value0;
4208 return this->Value0;
4212 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
4215 return this->Value1;
4219 return this->Value1;
4223 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
4226 return this->Value2;
4230 return this->Value2;
4234 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
4237 return this->Value3;
4241 return this->Value3;
4245 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
4248 return this->Value4;
4252 return this->Value4;
4256 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
4259 return this->Value5;
4263 return this->Value5;
4267 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
4270 return this->Value6;
4274 return this->Value6;
4278 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
4281 return this->Value7;
4285 return this->Value7;
4289 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
4292 return this->Value8;
4296 return this->Value8;
4300 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
4303 return this->Value9;
4307 return this->Value9;
4311 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
4314 return this->Value10;
4318 return this->Value10;
4322 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
4325 return this->Value11;
4329 return this->Value11;
4333 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
4336 return this->Value12;
4340 return this->Value12;
4344 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
4347 return this->Value13;
4351 return this->Value13;
4355 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
4358 return this->Value14;
4362 return this->Value14;
4366 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
4369 return this->Value15;
4373 return this->Value15;
4377 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
4380 return this->Value16;
4384 return this->Value16;
4388 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
4391 return this->Value17;
4395 return this->Value17;
4399 static T18 ElementTypeI(vtkm::internal::IndexTag<18>);
4402 return this->Value18;
4406 return this->Value18;
4410 static T19 ElementTypeI(vtkm::internal::IndexTag<19>);
4413 return this->Value19;
4417 return this->Value19;
4422 template <vtkm::IdComponent Index>
4423 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
4425 template <vtkm::IdComponent,
typename>
4426 friend struct detail::TupleElementImpl;
4430 template <vtkm::IdComponent Index>
4431 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>>;
4441 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15,
typename A16,
typename A17,
typename A18,
typename A19>
4442 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13, A14&& a14, A15&& a15, A16&& a16, A17&& a17, A18&& a18, A19&& a19)
4443 : Value0(std::forward<A0>(a0))
4444 , Value1(std::forward<A1>(a1))
4445 , Value2(std::forward<A2>(a2))
4446 , Value3(std::forward<A3>(a3))
4447 , Value4(std::forward<A4>(a4))
4448 , Value5(std::forward<A5>(a5))
4449 , Value6(std::forward<A6>(a6))
4450 , Value7(std::forward<A7>(a7))
4451 , Value8(std::forward<A8>(a8))
4452 , Value9(std::forward<A9>(a9))
4453 , Value10(std::forward<A10>(a10))
4454 , Value11(std::forward<A11>(a11))
4455 , Value12(std::forward<A12>(a12))
4456 , Value13(std::forward<A13>(a13))
4457 , Value14(std::forward<A14>(a14))
4458 , Value15(std::forward<A15>(a15))
4459 , Value16(std::forward<A16>(a16))
4460 , Value17(std::forward<A17>(a17))
4461 , Value18(std::forward<A18>(a18))
4462 , Value19(std::forward<A19>(a19))
4466 template <vtkm::IdComponent Index>
4469 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4472 template <vtkm::IdComponent Index>
4475 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4479 template <
typename Function,
typename... Args>
4481 auto Apply(Function&& f, Args&&... args)
4482 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18, Value19))
4484 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18, Value19);
4487 template <
typename Function,
typename... Args>
4489 auto Apply(Function&& f, Args&&... args)
const
4490 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18, Value19))
4492 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17, Value18, Value19);
4496 template <
typename Function>
4502 template <
typename Function>
4509 template <
typename Function>
4516 template <
typename Function>
4526 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
typename T11,
typename T12,
typename T13,
typename T14,
typename T15,
typename T16,
typename T17,
typename T18,
typename T19,
typename T20,
typename... Ts>
4527 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
4530 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
4533 return this->Value0;
4537 return this->Value0;
4541 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
4544 return this->Value1;
4548 return this->Value1;
4552 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
4555 return this->Value2;
4559 return this->Value2;
4563 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
4566 return this->Value3;
4570 return this->Value3;
4574 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
4577 return this->Value4;
4581 return this->Value4;
4585 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
4588 return this->Value5;
4592 return this->Value5;
4596 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
4599 return this->Value6;
4603 return this->Value6;
4607 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
4610 return this->Value7;
4614 return this->Value7;
4618 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
4621 return this->Value8;
4625 return this->Value8;
4629 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
4632 return this->Value9;
4636 return this->Value9;
4640 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
4643 return this->Value10;
4647 return this->Value10;
4651 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
4654 return this->Value11;
4658 return this->Value11;
4662 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
4665 return this->Value12;
4669 return this->Value12;
4673 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
4676 return this->Value13;
4680 return this->Value13;
4684 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
4687 return this->Value14;
4691 return this->Value14;
4695 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
4698 return this->Value15;
4702 return this->Value15;
4706 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
4709 return this->Value16;
4713 return this->Value16;
4717 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
4720 return this->Value17;
4724 return this->Value17;
4728 static T18 ElementTypeI(vtkm::internal::IndexTag<18>);
4731 return this->Value18;
4735 return this->Value18;
4739 static T19 ElementTypeI(vtkm::internal::IndexTag<19>);
4742 return this->Value19;
4746 return this->Value19;
4754 template <vtkm::IdComponent Index>
4756 ElementTypeI(vtkm::internal::IndexTag<Index>);
4758 template <
typename vtkm::IdComponent Index>
4761 template <
typename vtkm::IdComponent Index>
4765 template <vtkm::IdComponent,
typename>
4766 friend struct detail::TupleElementImpl;
4771 template <vtkm::IdComponent Index>
4772 using ElementType =
vtkm::TupleElement<
Index,
Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>>;
4782 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15,
typename A16,
typename A17,
typename A18,
typename A19,
typename... As>
4783 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9, A10&& a10, A11&& a11, A12&& a12, A13&& a13, A14&& a14, A15&& a15, A16&& a16, A17&& a17, A18&& a18, A19&& a19, As&&... remainingArgs)
4784 : Value0(std::forward<A0>(a0))
4785 , Value1(std::forward<A1>(a1))
4786 , Value2(std::forward<A2>(a2))
4787 , Value3(std::forward<A3>(a3))
4788 , Value4(std::forward<A4>(a4))
4789 , Value5(std::forward<A5>(a5))
4790 , Value6(std::forward<A6>(a6))
4791 , Value7(std::forward<A7>(a7))
4792 , Value8(std::forward<A8>(a8))
4793 , Value9(std::forward<A9>(a9))
4794 , Value10(std::forward<A10>(a10))
4795 , Value11(std::forward<A11>(a11))
4796 , Value12(std::forward<A12>(a12))
4797 , Value13(std::forward<A13>(a13))
4798 , Value14(std::forward<A14>(a14))
4799 , Value15(std::forward<A15>(a15))
4800 , Value16(std::forward<A16>(a16))
4801 , Value17(std::forward<A17>(a17))
4802 , Value18(std::forward<A18>(a18))
4803 , Value19(std::forward<A19>(a19))
4804 , RemainingValues(std::forward<As>(remainingArgs)...)
4808 template <vtkm::IdComponent Index>
4811 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4814 template <vtkm::IdComponent Index>
4817 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4821 template <
typename Function,
typename... Args>
4823 auto Apply(Function&& f, Args&&... args)
4824 -> decltype(this->RemainingValues.Apply(std::forward<Function>(f),
4825 std::forward<Args>(args)...,
4847 return this->RemainingValues.Apply(std::forward<Function>(f),
4848 std::forward<Args>(args)...,
4871 template <
typename Function,
typename... Args>
4873 auto Apply(Function&& f, Args&&... args)
const
4874 -> decltype(this->RemainingValues.Apply(std::forward<Function>(f),
4875 std::forward<Args>(args)...,
4897 return this->RemainingValues.Apply(std::forward<Function>(f),
4898 std::forward<Args>(args)...,
4922 template <
typename Function>
4928 template <
typename Function>
4935 template <
typename Function>
4942 template <
typename Function>
4956 #endif //vtk_m_Tuple_h