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>
85 return tuple.template Get<Index>();
92 return tuple.template Get<Index>();
100 template <std::size_t
Index,
typename... Ts>
104 return vtkm::Get<static_cast<vtkm::IdComponent>(
Index)>(tuple);
108 template <std::size_t
Index,
typename... Ts>
112 return vtkm::Get<static_cast<vtkm::IdComponent>(
Index)>(tuple);
119 template <
typename... Ts>
128 template <
typename... Ts>
137 struct TupleTransformFunctor
140 template <
typename Function,
typename... Ts>
149 template <
typename TupleType,
typename Function>
150 VTKM_EXEC_CONT auto TupleTransform(TupleType&& tuple, Function&& f)
151 -> decltype(tuple.Apply(TupleTransformFunctor{}, std::forward<Function>(f)))
153 return tuple.Apply(TupleTransformFunctor{}, std::forward<Function>(f));
156 struct TupleForEachFunctor
159 template <
typename Function,
typename... Ts>
162 (void)std::initializer_list<bool>{ (f(std::forward<Ts>(args)),
false)... };
167 template <
typename TupleType,
typename Function>
169 -> decltype(tuple.Apply(TupleForEachFunctor{}, std::forward<Function>(f)))
171 return tuple.Apply(TupleForEachFunctor{}, std::forward<Function>(f));
184 template <
typename Function,
typename... Args>
186 -> decltype(f(std::forward<Args>(args)...))
188 return f(std::forward<Args>(args)...);
191 template <
typename Function,
typename... Args>
193 -> decltype(f(std::forward<Args>(args)...))
195 return f(std::forward<Args>(args)...);
199 template <
typename Function>
205 template <
typename Function>
214 template<
typename T0>
218 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
230 template <vtkm::IdComponent Index>
231 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
233 template <vtkm::IdComponent,
typename>
234 friend struct detail::TupleElementImpl;
238 template <vtkm::IdComponent Index>
249 template <
typename A0>
251 : Value0(std::forward<A0>(a0))
255 template <vtkm::IdComponent Index>
258 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
261 template <vtkm::IdComponent Index>
264 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
268 template <
typename Function,
typename... Args>
270 auto Apply(Function&& f, Args&&... args)
271 -> decltype(f(std::forward<Args>(args)..., Value0))
273 return f(std::forward<Args>(args)..., Value0);
276 template <
typename Function,
typename... Args>
278 auto Apply(Function&& f, Args&&... args)
const
279 -> decltype(f(std::forward<Args>(args)..., Value0))
281 return f(std::forward<Args>(args)..., Value0);
285 template <
typename Function>
288 detail::TupleForEach(*
this, std::forward<Function>(f));
291 template <
typename Function>
294 detail::TupleForEach(*
this, std::forward<Function>(f));
298 template <
typename Function>
300 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
302 return detail::TupleTransform(*
this, std::forward<Function>(f));
305 template <
typename Function>
307 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
309 return detail::TupleTransform(*
this, std::forward<Function>(f));
313 template<
typename T0,
typename T1>
317 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
328 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
340 template <vtkm::IdComponent Index>
341 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
343 template <vtkm::IdComponent,
typename>
344 friend struct detail::TupleElementImpl;
348 template <vtkm::IdComponent Index>
359 template <
typename A0,
typename A1>
361 : Value0(std::forward<A0>(a0))
362 , Value1(std::forward<A1>(a1))
366 template <vtkm::IdComponent Index>
369 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
372 template <vtkm::IdComponent Index>
375 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
379 template <
typename Function,
typename... Args>
381 auto Apply(Function&& f, Args&&... args)
382 -> decltype(f(std::forward<Args>(args)..., Value0, Value1))
384 return f(std::forward<Args>(args)..., Value0, Value1);
387 template <
typename Function,
typename... Args>
389 auto Apply(Function&& f, Args&&... args)
const
390 -> decltype(f(std::forward<Args>(args)..., Value0, Value1))
392 return f(std::forward<Args>(args)..., Value0, Value1);
396 template <
typename Function>
399 detail::TupleForEach(*
this, std::forward<Function>(f));
402 template <
typename Function>
405 detail::TupleForEach(*
this, std::forward<Function>(f));
409 template <
typename Function>
411 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
413 return detail::TupleTransform(*
this, std::forward<Function>(f));
416 template <
typename Function>
418 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
420 return detail::TupleTransform(*
this, std::forward<Function>(f));
424 template<
typename T0,
typename T1,
typename T2>
428 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
439 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
450 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
462 template <vtkm::IdComponent Index>
463 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
465 template <vtkm::IdComponent,
typename>
466 friend struct detail::TupleElementImpl;
470 template <vtkm::IdComponent Index>
481 template <
typename A0,
typename A1,
typename A2>
483 : Value0(std::forward<A0>(a0))
484 , Value1(std::forward<A1>(a1))
485 , Value2(std::forward<A2>(a2))
489 template <vtkm::IdComponent Index>
492 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
495 template <vtkm::IdComponent Index>
498 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
502 template <
typename Function,
typename... Args>
504 auto Apply(Function&& f, Args&&... args)
505 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2))
507 return f(std::forward<Args>(args)..., Value0, Value1, Value2);
510 template <
typename Function,
typename... Args>
512 auto Apply(Function&& f, Args&&... args)
const
513 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2))
515 return f(std::forward<Args>(args)..., Value0, Value1, Value2);
519 template <
typename Function>
522 detail::TupleForEach(*
this, std::forward<Function>(f));
525 template <
typename Function>
528 detail::TupleForEach(*
this, std::forward<Function>(f));
532 template <
typename Function>
534 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
536 return detail::TupleTransform(*
this, std::forward<Function>(f));
539 template <
typename Function>
541 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
543 return detail::TupleTransform(*
this, std::forward<Function>(f));
547 template<
typename T0,
typename T1,
typename T2,
typename T3>
551 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
562 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
573 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
584 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
596 template <vtkm::IdComponent Index>
597 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
599 template <vtkm::IdComponent,
typename>
600 friend struct detail::TupleElementImpl;
604 template <vtkm::IdComponent Index>
615 template <
typename A0,
typename A1,
typename A2,
typename A3>
617 : Value0(std::forward<A0>(a0))
618 , Value1(std::forward<A1>(a1))
619 , Value2(std::forward<A2>(a2))
620 , Value3(std::forward<A3>(a3))
624 template <vtkm::IdComponent Index>
627 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
630 template <vtkm::IdComponent Index>
633 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
637 template <
typename Function,
typename... Args>
639 auto Apply(Function&& f, Args&&... args)
640 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3))
642 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3);
645 template <
typename Function,
typename... Args>
647 auto Apply(Function&& f, Args&&... args)
const
648 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3))
650 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3);
654 template <
typename Function>
657 detail::TupleForEach(*
this, std::forward<Function>(f));
660 template <
typename Function>
663 detail::TupleForEach(*
this, std::forward<Function>(f));
667 template <
typename Function>
669 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
671 return detail::TupleTransform(*
this, std::forward<Function>(f));
674 template <
typename Function>
676 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
678 return detail::TupleTransform(*
this, std::forward<Function>(f));
682 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4>
686 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
697 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
708 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
719 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
730 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
742 template <vtkm::IdComponent Index>
743 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
745 template <vtkm::IdComponent,
typename>
746 friend struct detail::TupleElementImpl;
750 template <vtkm::IdComponent Index>
761 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4>
763 : Value0(std::forward<A0>(a0))
764 , Value1(std::forward<A1>(a1))
765 , Value2(std::forward<A2>(a2))
766 , Value3(std::forward<A3>(a3))
767 , Value4(std::forward<A4>(a4))
771 template <vtkm::IdComponent Index>
774 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
777 template <vtkm::IdComponent Index>
780 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
784 template <
typename Function,
typename... Args>
786 auto Apply(Function&& f, Args&&... args)
787 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4))
789 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4);
792 template <
typename Function,
typename... Args>
794 auto Apply(Function&& f, Args&&... args)
const
795 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4))
797 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4);
801 template <
typename Function>
804 detail::TupleForEach(*
this, std::forward<Function>(f));
807 template <
typename Function>
810 detail::TupleForEach(*
this, std::forward<Function>(f));
814 template <
typename Function>
816 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
818 return detail::TupleTransform(*
this, std::forward<Function>(f));
821 template <
typename Function>
823 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
825 return detail::TupleTransform(*
this, std::forward<Function>(f));
829 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
833 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
844 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
855 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
866 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
877 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
888 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
900 template <vtkm::IdComponent Index>
901 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
903 template <vtkm::IdComponent,
typename>
904 friend struct detail::TupleElementImpl;
908 template <vtkm::IdComponent Index>
919 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
921 : Value0(std::forward<A0>(a0))
922 , Value1(std::forward<A1>(a1))
923 , Value2(std::forward<A2>(a2))
924 , Value3(std::forward<A3>(a3))
925 , Value4(std::forward<A4>(a4))
926 , Value5(std::forward<A5>(a5))
930 template <vtkm::IdComponent Index>
933 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
936 template <vtkm::IdComponent Index>
939 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
943 template <
typename Function,
typename... Args>
945 auto Apply(Function&& f, Args&&... args)
946 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5))
948 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5);
951 template <
typename Function,
typename... Args>
953 auto Apply(Function&& f, Args&&... args)
const
954 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5))
956 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5);
960 template <
typename Function>
963 detail::TupleForEach(*
this, std::forward<Function>(f));
966 template <
typename Function>
969 detail::TupleForEach(*
this, std::forward<Function>(f));
973 template <
typename Function>
975 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
977 return detail::TupleTransform(*
this, std::forward<Function>(f));
980 template <
typename Function>
982 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
984 return detail::TupleTransform(*
this, std::forward<Function>(f));
988 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6>
989 class Tuple<T0, T1, T2, T3, T4, T5, T6>
992 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1003 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1006 return this->Value1;
1010 return this->Value1;
1014 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1017 return this->Value2;
1021 return this->Value2;
1025 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1028 return this->Value3;
1032 return this->Value3;
1036 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1039 return this->Value4;
1043 return this->Value4;
1047 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1050 return this->Value5;
1054 return this->Value5;
1058 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1061 return this->Value6;
1065 return this->Value6;
1070 template <vtkm::IdComponent Index>
1071 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1073 template <vtkm::IdComponent,
typename>
1074 friend struct detail::TupleElementImpl;
1078 template <vtkm::IdComponent Index>
1089 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
1091 : Value0(std::forward<A0>(a0))
1092 , Value1(std::forward<A1>(a1))
1093 , Value2(std::forward<A2>(a2))
1094 , Value3(std::forward<A3>(a3))
1095 , Value4(std::forward<A4>(a4))
1096 , Value5(std::forward<A5>(a5))
1097 , Value6(std::forward<A6>(a6))
1101 template <vtkm::IdComponent Index>
1104 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1107 template <vtkm::IdComponent Index>
1110 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1114 template <
typename Function,
typename... Args>
1116 auto Apply(Function&& f, Args&&... args)
1117 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6))
1119 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6);
1122 template <
typename Function,
typename... Args>
1124 auto Apply(Function&& f, Args&&... args)
const
1125 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6))
1127 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6);
1131 template <
typename Function>
1134 detail::TupleForEach(*
this, std::forward<Function>(f));
1137 template <
typename Function>
1140 detail::TupleForEach(*
this, std::forward<Function>(f));
1144 template <
typename Function>
1146 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1148 return detail::TupleTransform(*
this, std::forward<Function>(f));
1151 template <
typename Function>
1153 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1155 return detail::TupleTransform(*
this, std::forward<Function>(f));
1159 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7>
1160 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7>
1163 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1166 return this->Value0;
1170 return this->Value0;
1174 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1177 return this->Value1;
1181 return this->Value1;
1185 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1188 return this->Value2;
1192 return this->Value2;
1196 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1199 return this->Value3;
1203 return this->Value3;
1207 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1210 return this->Value4;
1214 return this->Value4;
1218 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1221 return this->Value5;
1225 return this->Value5;
1229 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1232 return this->Value6;
1236 return this->Value6;
1240 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1243 return this->Value7;
1247 return this->Value7;
1252 template <vtkm::IdComponent Index>
1253 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1255 template <vtkm::IdComponent,
typename>
1256 friend struct detail::TupleElementImpl;
1260 template <vtkm::IdComponent Index>
1271 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
1273 : Value0(std::forward<A0>(a0))
1274 , Value1(std::forward<A1>(a1))
1275 , Value2(std::forward<A2>(a2))
1276 , Value3(std::forward<A3>(a3))
1277 , Value4(std::forward<A4>(a4))
1278 , Value5(std::forward<A5>(a5))
1279 , Value6(std::forward<A6>(a6))
1280 , Value7(std::forward<A7>(a7))
1284 template <vtkm::IdComponent Index>
1287 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1290 template <vtkm::IdComponent Index>
1293 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1297 template <
typename Function,
typename... Args>
1299 auto Apply(Function&& f, Args&&... args)
1300 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7))
1302 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7);
1305 template <
typename Function,
typename... Args>
1307 auto Apply(Function&& f, Args&&... args)
const
1308 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7))
1310 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7);
1314 template <
typename Function>
1317 detail::TupleForEach(*
this, std::forward<Function>(f));
1320 template <
typename Function>
1323 detail::TupleForEach(*
this, std::forward<Function>(f));
1327 template <
typename Function>
1329 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1331 return detail::TupleTransform(*
this, std::forward<Function>(f));
1334 template <
typename Function>
1336 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1338 return detail::TupleTransform(*
this, std::forward<Function>(f));
1342 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8>
1343 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8>
1346 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1349 return this->Value0;
1353 return this->Value0;
1357 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1360 return this->Value1;
1364 return this->Value1;
1368 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1371 return this->Value2;
1375 return this->Value2;
1379 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1382 return this->Value3;
1386 return this->Value3;
1390 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1393 return this->Value4;
1397 return this->Value4;
1401 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1404 return this->Value5;
1408 return this->Value5;
1412 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1415 return this->Value6;
1419 return this->Value6;
1423 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1426 return this->Value7;
1430 return this->Value7;
1434 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
1437 return this->Value8;
1441 return this->Value8;
1446 template <vtkm::IdComponent Index>
1447 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1449 template <vtkm::IdComponent,
typename>
1450 friend struct detail::TupleElementImpl;
1454 template <vtkm::IdComponent Index>
1465 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8>
1467 : Value0(std::forward<A0>(a0))
1468 , Value1(std::forward<A1>(a1))
1469 , Value2(std::forward<A2>(a2))
1470 , Value3(std::forward<A3>(a3))
1471 , Value4(std::forward<A4>(a4))
1472 , Value5(std::forward<A5>(a5))
1473 , Value6(std::forward<A6>(a6))
1474 , Value7(std::forward<A7>(a7))
1475 , Value8(std::forward<A8>(a8))
1479 template <vtkm::IdComponent Index>
1482 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1485 template <vtkm::IdComponent Index>
1488 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1492 template <
typename Function,
typename... Args>
1494 auto Apply(Function&& f, Args&&... args)
1495 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8))
1497 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8);
1500 template <
typename Function,
typename... Args>
1502 auto Apply(Function&& f, Args&&... args)
const
1503 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8))
1505 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8);
1509 template <
typename Function>
1512 detail::TupleForEach(*
this, std::forward<Function>(f));
1515 template <
typename Function>
1518 detail::TupleForEach(*
this, std::forward<Function>(f));
1522 template <
typename Function>
1524 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1526 return detail::TupleTransform(*
this, std::forward<Function>(f));
1529 template <
typename Function>
1531 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1533 return detail::TupleTransform(*
this, std::forward<Function>(f));
1537 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9>
1538 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
1541 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1544 return this->Value0;
1548 return this->Value0;
1552 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1555 return this->Value1;
1559 return this->Value1;
1563 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1566 return this->Value2;
1570 return this->Value2;
1574 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1577 return this->Value3;
1581 return this->Value3;
1585 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1588 return this->Value4;
1592 return this->Value4;
1596 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1599 return this->Value5;
1603 return this->Value5;
1607 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1610 return this->Value6;
1614 return this->Value6;
1618 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1621 return this->Value7;
1625 return this->Value7;
1629 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
1632 return this->Value8;
1636 return this->Value8;
1640 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
1643 return this->Value9;
1647 return this->Value9;
1652 template <vtkm::IdComponent Index>
1653 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1655 template <vtkm::IdComponent,
typename>
1656 friend struct detail::TupleElementImpl;
1660 template <vtkm::IdComponent Index>
1661 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>;
1671 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9>
1672 VTKM_EXEC_CONT Tuple(A0&& a0, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9)
1673 : Value0(std::forward<A0>(a0))
1674 , Value1(std::forward<A1>(a1))
1675 , Value2(std::forward<A2>(a2))
1676 , Value3(std::forward<A3>(a3))
1677 , Value4(std::forward<A4>(a4))
1678 , Value5(std::forward<A5>(a5))
1679 , Value6(std::forward<A6>(a6))
1680 , Value7(std::forward<A7>(a7))
1681 , Value8(std::forward<A8>(a8))
1682 , Value9(std::forward<A9>(a9))
1686 template <vtkm::IdComponent Index>
1689 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1692 template <vtkm::IdComponent Index>
1695 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1699 template <
typename Function,
typename... Args>
1701 auto Apply(Function&& f, Args&&... args)
1702 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9))
1704 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9);
1707 template <
typename Function,
typename... Args>
1709 auto Apply(Function&& f, Args&&... args)
const
1710 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9))
1712 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9);
1716 template <
typename Function>
1719 detail::TupleForEach(*
this, std::forward<Function>(f));
1722 template <
typename Function>
1725 detail::TupleForEach(*
this, std::forward<Function>(f));
1729 template <
typename Function>
1731 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1733 return detail::TupleTransform(*
this, std::forward<Function>(f));
1736 template <
typename Function>
1738 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1740 return detail::TupleTransform(*
this, std::forward<Function>(f));
1744 template<
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10>
1745 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
1748 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1751 return this->Value0;
1755 return this->Value0;
1759 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1762 return this->Value1;
1766 return this->Value1;
1770 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1773 return this->Value2;
1777 return this->Value2;
1781 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
1784 return this->Value3;
1788 return this->Value3;
1792 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
1795 return this->Value4;
1799 return this->Value4;
1803 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
1806 return this->Value5;
1810 return this->Value5;
1814 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
1817 return this->Value6;
1821 return this->Value6;
1825 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
1828 return this->Value7;
1832 return this->Value7;
1836 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
1839 return this->Value8;
1843 return this->Value8;
1847 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
1850 return this->Value9;
1854 return this->Value9;
1858 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
1861 return this->Value10;
1865 return this->Value10;
1870 template <vtkm::IdComponent Index>
1871 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
1873 template <vtkm::IdComponent,
typename>
1874 friend struct detail::TupleElementImpl;
1878 template <vtkm::IdComponent Index>
1879 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>>;
1889 template <
typename A0,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10>
1890 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)
1891 : Value0(std::forward<A0>(a0))
1892 , Value1(std::forward<A1>(a1))
1893 , Value2(std::forward<A2>(a2))
1894 , Value3(std::forward<A3>(a3))
1895 , Value4(std::forward<A4>(a4))
1896 , Value5(std::forward<A5>(a5))
1897 , Value6(std::forward<A6>(a6))
1898 , Value7(std::forward<A7>(a7))
1899 , Value8(std::forward<A8>(a8))
1900 , Value9(std::forward<A9>(a9))
1901 , Value10(std::forward<A10>(a10))
1905 template <vtkm::IdComponent Index>
1908 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1911 template <vtkm::IdComponent Index>
1914 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
1918 template <
typename Function,
typename... Args>
1920 auto Apply(Function&& f, Args&&... args)
1921 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10))
1923 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10);
1926 template <
typename Function,
typename... Args>
1928 auto Apply(Function&& f, Args&&... args)
const
1929 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10))
1931 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10);
1935 template <
typename Function>
1938 detail::TupleForEach(*
this, std::forward<Function>(f));
1941 template <
typename Function>
1944 detail::TupleForEach(*
this, std::forward<Function>(f));
1948 template <
typename Function>
1950 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1952 return detail::TupleTransform(*
this, std::forward<Function>(f));
1955 template <
typename Function>
1957 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
1959 return detail::TupleTransform(*
this, std::forward<Function>(f));
1963 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>
1964 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
1967 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
1970 return this->Value0;
1974 return this->Value0;
1978 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
1981 return this->Value1;
1985 return this->Value1;
1989 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
1992 return this->Value2;
1996 return this->Value2;
2000 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2003 return this->Value3;
2007 return this->Value3;
2011 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2014 return this->Value4;
2018 return this->Value4;
2022 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2025 return this->Value5;
2029 return this->Value5;
2033 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2036 return this->Value6;
2040 return this->Value6;
2044 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2047 return this->Value7;
2051 return this->Value7;
2055 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2058 return this->Value8;
2062 return this->Value8;
2066 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2069 return this->Value9;
2073 return this->Value9;
2077 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2080 return this->Value10;
2084 return this->Value10;
2088 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2091 return this->Value11;
2095 return this->Value11;
2100 template <vtkm::IdComponent Index>
2101 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2103 template <vtkm::IdComponent,
typename>
2104 friend struct detail::TupleElementImpl;
2108 template <vtkm::IdComponent Index>
2109 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>>;
2119 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>
2120 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)
2121 : Value0(std::forward<A0>(a0))
2122 , Value1(std::forward<A1>(a1))
2123 , Value2(std::forward<A2>(a2))
2124 , Value3(std::forward<A3>(a3))
2125 , Value4(std::forward<A4>(a4))
2126 , Value5(std::forward<A5>(a5))
2127 , Value6(std::forward<A6>(a6))
2128 , Value7(std::forward<A7>(a7))
2129 , Value8(std::forward<A8>(a8))
2130 , Value9(std::forward<A9>(a9))
2131 , Value10(std::forward<A10>(a10))
2132 , Value11(std::forward<A11>(a11))
2136 template <vtkm::IdComponent Index>
2139 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2142 template <vtkm::IdComponent Index>
2145 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2149 template <
typename Function,
typename... Args>
2151 auto Apply(Function&& f, Args&&... args)
2152 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11))
2154 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11);
2157 template <
typename Function,
typename... Args>
2159 auto Apply(Function&& f, Args&&... args)
const
2160 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11))
2162 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11);
2166 template <
typename Function>
2169 detail::TupleForEach(*
this, std::forward<Function>(f));
2172 template <
typename Function>
2175 detail::TupleForEach(*
this, std::forward<Function>(f));
2179 template <
typename Function>
2181 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2183 return detail::TupleTransform(*
this, std::forward<Function>(f));
2186 template <
typename Function>
2188 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2190 return detail::TupleTransform(*
this, std::forward<Function>(f));
2194 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>
2195 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
2198 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2201 return this->Value0;
2205 return this->Value0;
2209 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2212 return this->Value1;
2216 return this->Value1;
2220 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2223 return this->Value2;
2227 return this->Value2;
2231 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2234 return this->Value3;
2238 return this->Value3;
2242 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2245 return this->Value4;
2249 return this->Value4;
2253 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2256 return this->Value5;
2260 return this->Value5;
2264 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2267 return this->Value6;
2271 return this->Value6;
2275 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2278 return this->Value7;
2282 return this->Value7;
2286 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2289 return this->Value8;
2293 return this->Value8;
2297 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2300 return this->Value9;
2304 return this->Value9;
2308 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2311 return this->Value10;
2315 return this->Value10;
2319 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2322 return this->Value11;
2326 return this->Value11;
2330 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
2333 return this->Value12;
2337 return this->Value12;
2342 template <vtkm::IdComponent Index>
2343 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2345 template <vtkm::IdComponent,
typename>
2346 friend struct detail::TupleElementImpl;
2350 template <vtkm::IdComponent Index>
2351 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>>;
2361 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>
2362 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)
2363 : Value0(std::forward<A0>(a0))
2364 , Value1(std::forward<A1>(a1))
2365 , Value2(std::forward<A2>(a2))
2366 , Value3(std::forward<A3>(a3))
2367 , Value4(std::forward<A4>(a4))
2368 , Value5(std::forward<A5>(a5))
2369 , Value6(std::forward<A6>(a6))
2370 , Value7(std::forward<A7>(a7))
2371 , Value8(std::forward<A8>(a8))
2372 , Value9(std::forward<A9>(a9))
2373 , Value10(std::forward<A10>(a10))
2374 , Value11(std::forward<A11>(a11))
2375 , Value12(std::forward<A12>(a12))
2379 template <vtkm::IdComponent Index>
2382 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2385 template <vtkm::IdComponent Index>
2388 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2392 template <
typename Function,
typename... Args>
2394 auto Apply(Function&& f, Args&&... args)
2395 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12))
2397 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12);
2400 template <
typename Function,
typename... Args>
2402 auto Apply(Function&& f, Args&&... args)
const
2403 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12))
2405 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12);
2409 template <
typename Function>
2412 detail::TupleForEach(*
this, std::forward<Function>(f));
2415 template <
typename Function>
2418 detail::TupleForEach(*
this, std::forward<Function>(f));
2422 template <
typename Function>
2424 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2426 return detail::TupleTransform(*
this, std::forward<Function>(f));
2429 template <
typename Function>
2431 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2433 return detail::TupleTransform(*
this, std::forward<Function>(f));
2437 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>
2438 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
2441 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2444 return this->Value0;
2448 return this->Value0;
2452 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2455 return this->Value1;
2459 return this->Value1;
2463 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2466 return this->Value2;
2470 return this->Value2;
2474 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2477 return this->Value3;
2481 return this->Value3;
2485 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2488 return this->Value4;
2492 return this->Value4;
2496 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2499 return this->Value5;
2503 return this->Value5;
2507 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2510 return this->Value6;
2514 return this->Value6;
2518 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2521 return this->Value7;
2525 return this->Value7;
2529 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2532 return this->Value8;
2536 return this->Value8;
2540 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2543 return this->Value9;
2547 return this->Value9;
2551 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2554 return this->Value10;
2558 return this->Value10;
2562 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2565 return this->Value11;
2569 return this->Value11;
2573 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
2576 return this->Value12;
2580 return this->Value12;
2584 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
2587 return this->Value13;
2591 return this->Value13;
2596 template <vtkm::IdComponent Index>
2597 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2599 template <vtkm::IdComponent,
typename>
2600 friend struct detail::TupleElementImpl;
2604 template <vtkm::IdComponent Index>
2605 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>>;
2615 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>
2616 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)
2617 : Value0(std::forward<A0>(a0))
2618 , Value1(std::forward<A1>(a1))
2619 , Value2(std::forward<A2>(a2))
2620 , Value3(std::forward<A3>(a3))
2621 , Value4(std::forward<A4>(a4))
2622 , Value5(std::forward<A5>(a5))
2623 , Value6(std::forward<A6>(a6))
2624 , Value7(std::forward<A7>(a7))
2625 , Value8(std::forward<A8>(a8))
2626 , Value9(std::forward<A9>(a9))
2627 , Value10(std::forward<A10>(a10))
2628 , Value11(std::forward<A11>(a11))
2629 , Value12(std::forward<A12>(a12))
2630 , Value13(std::forward<A13>(a13))
2634 template <vtkm::IdComponent Index>
2637 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2640 template <vtkm::IdComponent Index>
2643 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2647 template <
typename Function,
typename... Args>
2649 auto Apply(Function&& f, Args&&... args)
2650 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13))
2652 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13);
2655 template <
typename Function,
typename... Args>
2657 auto Apply(Function&& f, Args&&... args)
const
2658 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13))
2660 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13);
2664 template <
typename Function>
2667 detail::TupleForEach(*
this, std::forward<Function>(f));
2670 template <
typename Function>
2673 detail::TupleForEach(*
this, std::forward<Function>(f));
2677 template <
typename Function>
2679 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2681 return detail::TupleTransform(*
this, std::forward<Function>(f));
2684 template <
typename Function>
2686 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2688 return detail::TupleTransform(*
this, std::forward<Function>(f));
2692 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>
2693 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
2696 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2699 return this->Value0;
2703 return this->Value0;
2707 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2710 return this->Value1;
2714 return this->Value1;
2718 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2721 return this->Value2;
2725 return this->Value2;
2729 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2732 return this->Value3;
2736 return this->Value3;
2740 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
2743 return this->Value4;
2747 return this->Value4;
2751 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
2754 return this->Value5;
2758 return this->Value5;
2762 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
2765 return this->Value6;
2769 return this->Value6;
2773 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
2776 return this->Value7;
2780 return this->Value7;
2784 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
2787 return this->Value8;
2791 return this->Value8;
2795 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
2798 return this->Value9;
2802 return this->Value9;
2806 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
2809 return this->Value10;
2813 return this->Value10;
2817 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
2820 return this->Value11;
2824 return this->Value11;
2828 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
2831 return this->Value12;
2835 return this->Value12;
2839 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
2842 return this->Value13;
2846 return this->Value13;
2850 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
2853 return this->Value14;
2857 return this->Value14;
2862 template <vtkm::IdComponent Index>
2863 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
2865 template <vtkm::IdComponent,
typename>
2866 friend struct detail::TupleElementImpl;
2870 template <vtkm::IdComponent Index>
2871 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>>;
2881 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>
2882 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)
2883 : Value0(std::forward<A0>(a0))
2884 , Value1(std::forward<A1>(a1))
2885 , Value2(std::forward<A2>(a2))
2886 , Value3(std::forward<A3>(a3))
2887 , Value4(std::forward<A4>(a4))
2888 , Value5(std::forward<A5>(a5))
2889 , Value6(std::forward<A6>(a6))
2890 , Value7(std::forward<A7>(a7))
2891 , Value8(std::forward<A8>(a8))
2892 , Value9(std::forward<A9>(a9))
2893 , Value10(std::forward<A10>(a10))
2894 , Value11(std::forward<A11>(a11))
2895 , Value12(std::forward<A12>(a12))
2896 , Value13(std::forward<A13>(a13))
2897 , Value14(std::forward<A14>(a14))
2901 template <vtkm::IdComponent Index>
2904 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2907 template <vtkm::IdComponent Index>
2910 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
2914 template <
typename Function,
typename... Args>
2916 auto Apply(Function&& f, Args&&... args)
2917 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14))
2919 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14);
2922 template <
typename Function,
typename... Args>
2924 auto Apply(Function&& f, Args&&... args)
const
2925 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14))
2927 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14);
2931 template <
typename Function>
2934 detail::TupleForEach(*
this, std::forward<Function>(f));
2937 template <
typename Function>
2940 detail::TupleForEach(*
this, std::forward<Function>(f));
2944 template <
typename Function>
2946 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2948 return detail::TupleTransform(*
this, std::forward<Function>(f));
2951 template <
typename Function>
2953 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
2955 return detail::TupleTransform(*
this, std::forward<Function>(f));
2959 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>
2960 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
2963 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
2966 return this->Value0;
2970 return this->Value0;
2974 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
2977 return this->Value1;
2981 return this->Value1;
2985 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
2988 return this->Value2;
2992 return this->Value2;
2996 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
2999 return this->Value3;
3003 return this->Value3;
3007 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3010 return this->Value4;
3014 return this->Value4;
3018 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3021 return this->Value5;
3025 return this->Value5;
3029 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3032 return this->Value6;
3036 return this->Value6;
3040 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3043 return this->Value7;
3047 return this->Value7;
3051 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3054 return this->Value8;
3058 return this->Value8;
3062 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3065 return this->Value9;
3069 return this->Value9;
3073 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3076 return this->Value10;
3080 return this->Value10;
3084 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
3087 return this->Value11;
3091 return this->Value11;
3095 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
3098 return this->Value12;
3102 return this->Value12;
3106 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
3109 return this->Value13;
3113 return this->Value13;
3117 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
3120 return this->Value14;
3124 return this->Value14;
3128 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
3131 return this->Value15;
3135 return this->Value15;
3140 template <vtkm::IdComponent Index>
3141 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
3143 template <vtkm::IdComponent,
typename>
3144 friend struct detail::TupleElementImpl;
3148 template <vtkm::IdComponent Index>
3149 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>;
3159 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>
3160 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)
3161 : Value0(std::forward<A0>(a0))
3162 , Value1(std::forward<A1>(a1))
3163 , Value2(std::forward<A2>(a2))
3164 , Value3(std::forward<A3>(a3))
3165 , Value4(std::forward<A4>(a4))
3166 , Value5(std::forward<A5>(a5))
3167 , Value6(std::forward<A6>(a6))
3168 , Value7(std::forward<A7>(a7))
3169 , Value8(std::forward<A8>(a8))
3170 , Value9(std::forward<A9>(a9))
3171 , Value10(std::forward<A10>(a10))
3172 , Value11(std::forward<A11>(a11))
3173 , Value12(std::forward<A12>(a12))
3174 , Value13(std::forward<A13>(a13))
3175 , Value14(std::forward<A14>(a14))
3176 , Value15(std::forward<A15>(a15))
3180 template <vtkm::IdComponent Index>
3183 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3186 template <vtkm::IdComponent Index>
3189 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3193 template <
typename Function,
typename... Args>
3195 auto Apply(Function&& f, Args&&... args)
3196 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15))
3198 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15);
3201 template <
typename Function,
typename... Args>
3203 auto Apply(Function&& f, Args&&... args)
const
3204 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15))
3206 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15);
3210 template <
typename Function>
3213 detail::TupleForEach(*
this, std::forward<Function>(f));
3216 template <
typename Function>
3219 detail::TupleForEach(*
this, std::forward<Function>(f));
3223 template <
typename Function>
3225 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
3227 return detail::TupleTransform(*
this, std::forward<Function>(f));
3230 template <
typename Function>
3232 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
3234 return detail::TupleTransform(*
this, std::forward<Function>(f));
3238 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>
3239 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
3242 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
3245 return this->Value0;
3249 return this->Value0;
3253 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
3256 return this->Value1;
3260 return this->Value1;
3264 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
3267 return this->Value2;
3271 return this->Value2;
3275 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
3278 return this->Value3;
3282 return this->Value3;
3286 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3289 return this->Value4;
3293 return this->Value4;
3297 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3300 return this->Value5;
3304 return this->Value5;
3308 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3311 return this->Value6;
3315 return this->Value6;
3319 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3322 return this->Value7;
3326 return this->Value7;
3330 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3333 return this->Value8;
3337 return this->Value8;
3341 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3344 return this->Value9;
3348 return this->Value9;
3352 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3355 return this->Value10;
3359 return this->Value10;
3363 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
3366 return this->Value11;
3370 return this->Value11;
3374 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
3377 return this->Value12;
3381 return this->Value12;
3385 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
3388 return this->Value13;
3392 return this->Value13;
3396 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
3399 return this->Value14;
3403 return this->Value14;
3407 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
3410 return this->Value15;
3414 return this->Value15;
3418 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
3421 return this->Value16;
3425 return this->Value16;
3430 template <vtkm::IdComponent Index>
3431 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
3433 template <vtkm::IdComponent,
typename>
3434 friend struct detail::TupleElementImpl;
3438 template <vtkm::IdComponent Index>
3439 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>>;
3449 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>
3450 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)
3451 : Value0(std::forward<A0>(a0))
3452 , Value1(std::forward<A1>(a1))
3453 , Value2(std::forward<A2>(a2))
3454 , Value3(std::forward<A3>(a3))
3455 , Value4(std::forward<A4>(a4))
3456 , Value5(std::forward<A5>(a5))
3457 , Value6(std::forward<A6>(a6))
3458 , Value7(std::forward<A7>(a7))
3459 , Value8(std::forward<A8>(a8))
3460 , Value9(std::forward<A9>(a9))
3461 , Value10(std::forward<A10>(a10))
3462 , Value11(std::forward<A11>(a11))
3463 , Value12(std::forward<A12>(a12))
3464 , Value13(std::forward<A13>(a13))
3465 , Value14(std::forward<A14>(a14))
3466 , Value15(std::forward<A15>(a15))
3467 , Value16(std::forward<A16>(a16))
3471 template <vtkm::IdComponent Index>
3474 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3477 template <vtkm::IdComponent Index>
3480 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3484 template <
typename Function,
typename... Args>
3486 auto Apply(Function&& f, Args&&... args)
3487 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16))
3489 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16);
3492 template <
typename Function,
typename... Args>
3494 auto Apply(Function&& f, Args&&... args)
const
3495 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16))
3497 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16);
3501 template <
typename Function>
3504 detail::TupleForEach(*
this, std::forward<Function>(f));
3507 template <
typename Function>
3510 detail::TupleForEach(*
this, std::forward<Function>(f));
3514 template <
typename Function>
3516 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
3518 return detail::TupleTransform(*
this, std::forward<Function>(f));
3521 template <
typename Function>
3523 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
3525 return detail::TupleTransform(*
this, std::forward<Function>(f));
3529 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>
3530 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
3533 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
3536 return this->Value0;
3540 return this->Value0;
3544 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
3547 return this->Value1;
3551 return this->Value1;
3555 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
3558 return this->Value2;
3562 return this->Value2;
3566 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
3569 return this->Value3;
3573 return this->Value3;
3577 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3580 return this->Value4;
3584 return this->Value4;
3588 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3591 return this->Value5;
3595 return this->Value5;
3599 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3602 return this->Value6;
3606 return this->Value6;
3610 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3613 return this->Value7;
3617 return this->Value7;
3621 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3624 return this->Value8;
3628 return this->Value8;
3632 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3635 return this->Value9;
3639 return this->Value9;
3643 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3646 return this->Value10;
3650 return this->Value10;
3654 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
3657 return this->Value11;
3661 return this->Value11;
3665 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
3668 return this->Value12;
3672 return this->Value12;
3676 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
3679 return this->Value13;
3683 return this->Value13;
3687 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
3690 return this->Value14;
3694 return this->Value14;
3698 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
3701 return this->Value15;
3705 return this->Value15;
3709 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
3712 return this->Value16;
3716 return this->Value16;
3720 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
3723 return this->Value17;
3727 return this->Value17;
3732 template <vtkm::IdComponent Index>
3733 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
3735 template <vtkm::IdComponent,
typename>
3736 friend struct detail::TupleElementImpl;
3740 template <vtkm::IdComponent Index>
3741 using ElementType =
vtkm::TupleElement<Index, Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>>;
3751 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>
3752 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)
3753 : Value0(std::forward<A0>(a0))
3754 , Value1(std::forward<A1>(a1))
3755 , Value2(std::forward<A2>(a2))
3756 , Value3(std::forward<A3>(a3))
3757 , Value4(std::forward<A4>(a4))
3758 , Value5(std::forward<A5>(a5))
3759 , Value6(std::forward<A6>(a6))
3760 , Value7(std::forward<A7>(a7))
3761 , Value8(std::forward<A8>(a8))
3762 , Value9(std::forward<A9>(a9))
3763 , Value10(std::forward<A10>(a10))
3764 , Value11(std::forward<A11>(a11))
3765 , Value12(std::forward<A12>(a12))
3766 , Value13(std::forward<A13>(a13))
3767 , Value14(std::forward<A14>(a14))
3768 , Value15(std::forward<A15>(a15))
3769 , Value16(std::forward<A16>(a16))
3770 , Value17(std::forward<A17>(a17))
3774 template <vtkm::IdComponent Index>
3777 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3780 template <vtkm::IdComponent Index>
3783 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
3787 template <
typename Function,
typename... Args>
3789 auto Apply(Function&& f, Args&&... args)
3790 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17))
3792 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17);
3795 template <
typename Function,
typename... Args>
3797 auto Apply(Function&& f, Args&&... args)
const
3798 -> decltype(f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17))
3800 return f(std::forward<Args>(args)..., Value0, Value1, Value2, Value3, Value4, Value5, Value6, Value7, Value8, Value9, Value10, Value11, Value12, Value13, Value14, Value15, Value16, Value17);
3804 template <
typename Function>
3807 detail::TupleForEach(*
this, std::forward<Function>(f));
3810 template <
typename Function>
3813 detail::TupleForEach(*
this, std::forward<Function>(f));
3817 template <
typename Function>
3819 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
3821 return detail::TupleTransform(*
this, std::forward<Function>(f));
3824 template <
typename Function>
3826 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
3828 return detail::TupleTransform(*
this, std::forward<Function>(f));
3832 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>
3833 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
3836 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
3839 return this->Value0;
3843 return this->Value0;
3847 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
3850 return this->Value1;
3854 return this->Value1;
3858 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
3861 return this->Value2;
3865 return this->Value2;
3869 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
3872 return this->Value3;
3876 return this->Value3;
3880 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
3883 return this->Value4;
3887 return this->Value4;
3891 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
3894 return this->Value5;
3898 return this->Value5;
3902 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
3905 return this->Value6;
3909 return this->Value6;
3913 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
3916 return this->Value7;
3920 return this->Value7;
3924 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
3927 return this->Value8;
3931 return this->Value8;
3935 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
3938 return this->Value9;
3942 return this->Value9;
3946 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
3949 return this->Value10;
3953 return this->Value10;
3957 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
3960 return this->Value11;
3964 return this->Value11;
3968 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
3971 return this->Value12;
3975 return this->Value12;
3979 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
3982 return this->Value13;
3986 return this->Value13;
3990 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
3993 return this->Value14;
3997 return this->Value14;
4001 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
4004 return this->Value15;
4008 return this->Value15;
4012 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
4015 return this->Value16;
4019 return this->Value16;
4023 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
4026 return this->Value17;
4030 return this->Value17;
4034 static T18 ElementTypeI(vtkm::internal::IndexTag<18>);
4037 return this->Value18;
4041 return this->Value18;
4046 template <vtkm::IdComponent Index>
4047 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
4049 template <vtkm::IdComponent,
typename>
4050 friend struct detail::TupleElementImpl;
4054 template <vtkm::IdComponent Index>
4055 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>>;
4065 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>
4066 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)
4067 : Value0(std::forward<A0>(a0))
4068 , Value1(std::forward<A1>(a1))
4069 , Value2(std::forward<A2>(a2))
4070 , Value3(std::forward<A3>(a3))
4071 , Value4(std::forward<A4>(a4))
4072 , Value5(std::forward<A5>(a5))
4073 , Value6(std::forward<A6>(a6))
4074 , Value7(std::forward<A7>(a7))
4075 , Value8(std::forward<A8>(a8))
4076 , Value9(std::forward<A9>(a9))
4077 , Value10(std::forward<A10>(a10))
4078 , Value11(std::forward<A11>(a11))
4079 , Value12(std::forward<A12>(a12))
4080 , Value13(std::forward<A13>(a13))
4081 , Value14(std::forward<A14>(a14))
4082 , Value15(std::forward<A15>(a15))
4083 , Value16(std::forward<A16>(a16))
4084 , Value17(std::forward<A17>(a17))
4085 , Value18(std::forward<A18>(a18))
4089 template <vtkm::IdComponent Index>
4092 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4095 template <vtkm::IdComponent Index>
4098 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4102 template <
typename Function,
typename... Args>
4104 auto Apply(Function&& f, Args&&... args)
4105 -> 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))
4107 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);
4110 template <
typename Function,
typename... Args>
4112 auto Apply(Function&& f, Args&&... args)
const
4113 -> 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))
4115 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);
4119 template <
typename Function>
4122 detail::TupleForEach(*
this, std::forward<Function>(f));
4125 template <
typename Function>
4128 detail::TupleForEach(*
this, std::forward<Function>(f));
4132 template <
typename Function>
4134 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
4136 return detail::TupleTransform(*
this, std::forward<Function>(f));
4139 template <
typename Function>
4141 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
4143 return detail::TupleTransform(*
this, std::forward<Function>(f));
4147 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>
4148 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
4151 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
4154 return this->Value0;
4158 return this->Value0;
4162 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
4165 return this->Value1;
4169 return this->Value1;
4173 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
4176 return this->Value2;
4180 return this->Value2;
4184 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
4187 return this->Value3;
4191 return this->Value3;
4195 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
4198 return this->Value4;
4202 return this->Value4;
4206 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
4209 return this->Value5;
4213 return this->Value5;
4217 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
4220 return this->Value6;
4224 return this->Value6;
4228 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
4231 return this->Value7;
4235 return this->Value7;
4239 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
4242 return this->Value8;
4246 return this->Value8;
4250 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
4253 return this->Value9;
4257 return this->Value9;
4261 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
4264 return this->Value10;
4268 return this->Value10;
4272 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
4275 return this->Value11;
4279 return this->Value11;
4283 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
4286 return this->Value12;
4290 return this->Value12;
4294 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
4297 return this->Value13;
4301 return this->Value13;
4305 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
4308 return this->Value14;
4312 return this->Value14;
4316 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
4319 return this->Value15;
4323 return this->Value15;
4327 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
4330 return this->Value16;
4334 return this->Value16;
4338 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
4341 return this->Value17;
4345 return this->Value17;
4349 static T18 ElementTypeI(vtkm::internal::IndexTag<18>);
4352 return this->Value18;
4356 return this->Value18;
4360 static T19 ElementTypeI(vtkm::internal::IndexTag<19>);
4363 return this->Value19;
4367 return this->Value19;
4372 template <vtkm::IdComponent Index>
4373 static vtkm::internal::NullType ElementTypeI(vtkm::internal::IndexTag<Index>);
4375 template <vtkm::IdComponent,
typename>
4376 friend struct detail::TupleElementImpl;
4380 template <vtkm::IdComponent Index>
4381 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>>;
4391 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>
4392 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)
4393 : Value0(std::forward<A0>(a0))
4394 , Value1(std::forward<A1>(a1))
4395 , Value2(std::forward<A2>(a2))
4396 , Value3(std::forward<A3>(a3))
4397 , Value4(std::forward<A4>(a4))
4398 , Value5(std::forward<A5>(a5))
4399 , Value6(std::forward<A6>(a6))
4400 , Value7(std::forward<A7>(a7))
4401 , Value8(std::forward<A8>(a8))
4402 , Value9(std::forward<A9>(a9))
4403 , Value10(std::forward<A10>(a10))
4404 , Value11(std::forward<A11>(a11))
4405 , Value12(std::forward<A12>(a12))
4406 , Value13(std::forward<A13>(a13))
4407 , Value14(std::forward<A14>(a14))
4408 , Value15(std::forward<A15>(a15))
4409 , Value16(std::forward<A16>(a16))
4410 , Value17(std::forward<A17>(a17))
4411 , Value18(std::forward<A18>(a18))
4412 , Value19(std::forward<A19>(a19))
4416 template <vtkm::IdComponent Index>
4419 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4422 template <vtkm::IdComponent Index>
4425 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4429 template <
typename Function,
typename... Args>
4431 auto Apply(Function&& f, Args&&... args)
4432 -> 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))
4434 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);
4437 template <
typename Function,
typename... Args>
4439 auto Apply(Function&& f, Args&&... args)
const
4440 -> 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))
4442 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);
4446 template <
typename Function>
4449 detail::TupleForEach(*
this, std::forward<Function>(f));
4452 template <
typename Function>
4455 detail::TupleForEach(*
this, std::forward<Function>(f));
4459 template <
typename Function>
4461 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
4463 return detail::TupleTransform(*
this, std::forward<Function>(f));
4466 template <
typename Function>
4468 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
4470 return detail::TupleTransform(*
this, std::forward<Function>(f));
4476 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>
4477 class Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
4480 static T0 ElementTypeI(vtkm::internal::IndexTag<0>);
4483 return this->Value0;
4487 return this->Value0;
4491 static T1 ElementTypeI(vtkm::internal::IndexTag<1>);
4494 return this->Value1;
4498 return this->Value1;
4502 static T2 ElementTypeI(vtkm::internal::IndexTag<2>);
4505 return this->Value2;
4509 return this->Value2;
4513 static T3 ElementTypeI(vtkm::internal::IndexTag<3>);
4516 return this->Value3;
4520 return this->Value3;
4524 static T4 ElementTypeI(vtkm::internal::IndexTag<4>);
4527 return this->Value4;
4531 return this->Value4;
4535 static T5 ElementTypeI(vtkm::internal::IndexTag<5>);
4538 return this->Value5;
4542 return this->Value5;
4546 static T6 ElementTypeI(vtkm::internal::IndexTag<6>);
4549 return this->Value6;
4553 return this->Value6;
4557 static T7 ElementTypeI(vtkm::internal::IndexTag<7>);
4560 return this->Value7;
4564 return this->Value7;
4568 static T8 ElementTypeI(vtkm::internal::IndexTag<8>);
4571 return this->Value8;
4575 return this->Value8;
4579 static T9 ElementTypeI(vtkm::internal::IndexTag<9>);
4582 return this->Value9;
4586 return this->Value9;
4590 static T10 ElementTypeI(vtkm::internal::IndexTag<10>);
4593 return this->Value10;
4597 return this->Value10;
4601 static T11 ElementTypeI(vtkm::internal::IndexTag<11>);
4604 return this->Value11;
4608 return this->Value11;
4612 static T12 ElementTypeI(vtkm::internal::IndexTag<12>);
4615 return this->Value12;
4619 return this->Value12;
4623 static T13 ElementTypeI(vtkm::internal::IndexTag<13>);
4626 return this->Value13;
4630 return this->Value13;
4634 static T14 ElementTypeI(vtkm::internal::IndexTag<14>);
4637 return this->Value14;
4641 return this->Value14;
4645 static T15 ElementTypeI(vtkm::internal::IndexTag<15>);
4648 return this->Value15;
4652 return this->Value15;
4656 static T16 ElementTypeI(vtkm::internal::IndexTag<16>);
4659 return this->Value16;
4663 return this->Value16;
4667 static T17 ElementTypeI(vtkm::internal::IndexTag<17>);
4670 return this->Value17;
4674 return this->Value17;
4678 static T18 ElementTypeI(vtkm::internal::IndexTag<18>);
4681 return this->Value18;
4685 return this->Value18;
4689 static T19 ElementTypeI(vtkm::internal::IndexTag<19>);
4692 return this->Value19;
4696 return this->Value19;
4704 template <vtkm::IdComponent Index>
4706 ElementTypeI(vtkm::internal::IndexTag<Index>);
4708 template <
typename vtkm::IdComponent Index>
4711 template <
typename vtkm::IdComponent Index>
4715 template <vtkm::IdComponent,
typename>
4716 friend struct detail::TupleElementImpl;
4721 template <vtkm::IdComponent Index>
4722 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...>>;
4732 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>
4733 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)
4734 : Value0(std::forward<A0>(a0))
4735 , Value1(std::forward<A1>(a1))
4736 , Value2(std::forward<A2>(a2))
4737 , Value3(std::forward<A3>(a3))
4738 , Value4(std::forward<A4>(a4))
4739 , Value5(std::forward<A5>(a5))
4740 , Value6(std::forward<A6>(a6))
4741 , Value7(std::forward<A7>(a7))
4742 , Value8(std::forward<A8>(a8))
4743 , Value9(std::forward<A9>(a9))
4744 , Value10(std::forward<A10>(a10))
4745 , Value11(std::forward<A11>(a11))
4746 , Value12(std::forward<A12>(a12))
4747 , Value13(std::forward<A13>(a13))
4748 , Value14(std::forward<A14>(a14))
4749 , Value15(std::forward<A15>(a15))
4750 , Value16(std::forward<A16>(a16))
4751 , Value17(std::forward<A17>(a17))
4752 , Value18(std::forward<A18>(a18))
4753 , Value19(std::forward<A19>(a19))
4754 , RemainingValues(std::forward<As>(remainingArgs)...)
4758 template <vtkm::IdComponent Index>
4761 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4764 template <vtkm::IdComponent Index>
4767 return this->GetImpl(vtkm::internal::IndexTag<Index>{});
4771 template <
typename Function,
typename... Args>
4773 auto Apply(Function&& f, Args&&... args)
4774 -> decltype(this->RemainingValues.Apply(std::forward<Function>(f),
4775 std::forward<Args>(args)...,
4797 return this->RemainingValues.Apply(std::forward<Function>(f),
4798 std::forward<Args>(args)...,
4821 template <
typename Function,
typename... Args>
4823 auto Apply(Function&& f, Args&&... args)
const
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)...,
4872 template <
typename Function>
4875 detail::TupleForEach(*
this, std::forward<Function>(f));
4878 template <
typename Function>
4881 detail::TupleForEach(*
this, std::forward<Function>(f));
4885 template <
typename Function>
4887 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
4889 return detail::TupleTransform(*
this, std::forward<Function>(f));
4892 template <
typename Function>
4894 -> decltype(detail::TupleTransform(*
this, std::forward<Function>(f)))
4896 return detail::TupleTransform(*
this, std::forward<Function>(f));
4906 #endif //vtk_m_Tuple_h