Viskores  1.0
List.h
Go to the documentation of this file.
1 //============================================================================
2 // The contents of this file are covered by the Viskores license. See
3 // LICENSE.txt for details.
4 //
5 // By contributing to this file, all contributors agree to the Developer
6 // Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
7 //============================================================================
8 
9 //============================================================================
10 // Copyright (c) Kitware, Inc.
11 // All rights reserved.
12 // See LICENSE.txt for details.
13 //
14 // This software is distributed WITHOUT ANY WARRANTY; without even
15 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
16 // PURPOSE. See the above copyright notice for more information.
17 //============================================================================
18 #ifndef viskores_List_h
19 #define viskores_List_h
20 
21 #include <viskores/Types.h>
22 
23 #include <viskores/internal/Meta.h>
24 
25 #include <functional>
26 
27 namespace viskores
28 {
29 
30 // We are currently limiting the size of a `viskores::List`. Generally, a compiler will
31 // happily create a list of any size. However, to make sure the compiler does not go
32 // into an infinite loop, you can only iterate on a list so far. As such, it is safer
33 // to limit the size of the lists.
34 #define VISKORES_CHECK_LIST_SIZE(size) \
35  static_assert((size) <= 512, \
36  "A viskores::List with more than 512 elements is not supported." \
37  " A list this long is problematic for compilers." \
38  " Compilers often have a recursive template instantiation limit of around 1024," \
39  " so operations on lists this large can lead to confusing and misleading errors.")
40 
46 template <typename... Ts>
47 struct List
48 {
49  VISKORES_CHECK_LIST_SIZE(sizeof...(Ts));
50 };
51 
52 namespace internal
53 {
54 
55 template <typename T>
56 struct IsListImpl
57 {
58  using type = std::false_type;
59 };
60 
61 template <typename... Ts>
62 struct IsListImpl<viskores::List<Ts...>>
63 {
64  using type = std::true_type;
65 };
66 
67 template <typename T>
68 using IsList = typename viskores::internal::IsListImpl<T>::type;
69 
70 } // namespace internal
71 
77 #define VISKORES_IS_LIST(type) \
78  VISKORES_STATIC_ASSERT_MSG((::viskores::internal::IsList<type>::value), \
79  "Provided type is not a valid Viskores list type.")
80 
81 namespace detail
82 {
83 
85 struct UniversalTypeTag
86 {
87  //We never want this tag constructed, and by deleting the constructor
88  //we get an error when trying to use this class with ForEach.
89  UniversalTypeTag() = delete;
90 };
91 
92 } // namespace detail
93 
96 using ListEmpty = viskores::List<>;
97 
102 using ListUniversal = viskores::List<detail::UniversalTypeTag>;
103 
104 namespace detail
105 {
106 
107 template <typename L>
108 struct ListSizeImpl;
109 
110 template <typename... Ts>
111 struct ListSizeImpl<viskores::List<Ts...>>
112 {
113  using type = std::integral_constant<viskores::IdComponent,
114  static_cast<viskores::IdComponent>(sizeof...(Ts))>;
115 };
116 
117 } // namespace detail
118 
121 template <typename List>
122 using ListSize = typename detail::ListSizeImpl<List>::type;
123 
124 namespace detail
125 {
126 
127 template <typename T, template <typename...> class Target>
128 struct ListApplyImpl;
129 template <typename... Ts, template <typename...> class Target>
130 struct ListApplyImpl<viskores::List<Ts...>, Target>
131 {
132  using type = Target<Ts...>;
133 };
134 // Cannot apply the universal list.
135 template <template <typename...> class Target>
136 struct ListApplyImpl<viskores::ListUniversal, Target>;
137 
138 } // namespace detail
139 
145 template <typename List, template <typename...> class Target>
146 using ListApply = typename detail::ListApplyImpl<List, Target>::type;
147 
148 namespace detail
149 {
150 
151 template <typename... Ls>
152 struct ListAppendImpl;
153 
154 template <>
155 struct ListAppendImpl<>
156 {
157  using type = viskores::ListEmpty;
158 };
159 
160 template <typename L>
161 struct ListAppendImpl<L>
162 {
163  using type = L;
164 };
165 
166 template <typename... T0s, typename... T1s>
167 struct ListAppendImpl<viskores::List<T0s...>, viskores::List<T1s...>>
168 {
169  using type = viskores::List<T0s..., T1s...>;
170  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
171 };
172 
173 template <typename... T0s, typename... T1s, typename... T2s>
174 struct ListAppendImpl<viskores::List<T0s...>, viskores::List<T1s...>, viskores::List<T2s...>>
175 {
176  using type = viskores::List<T0s..., T1s..., T2s...>;
177  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
178 };
179 
180 template <typename... T0s, typename... T1s, typename... T2s, typename... T3s>
181 struct ListAppendImpl<viskores::List<T0s...>,
182  viskores::List<T1s...>,
183  viskores::List<T2s...>,
184  viskores::List<T3s...>>
185 {
186  using type = viskores::List<T0s..., T1s..., T2s..., T3s...>;
187  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
188 };
189 
190 template <typename... T0s, typename... T1s, typename... T2s, typename... T3s, typename... T4s>
191 struct ListAppendImpl<viskores::List<T0s...>,
192  viskores::List<T1s...>,
193  viskores::List<T2s...>,
194  viskores::List<T3s...>,
195  viskores::List<T4s...>>
196 {
197  using type = viskores::List<T0s..., T1s..., T2s..., T3s..., T4s...>;
198  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
199 };
200 
201 template <typename... T0s,
202  typename... T1s,
203  typename... T2s,
204  typename... T3s,
205  typename... T4s,
206  typename... T5s>
207 struct ListAppendImpl<viskores::List<T0s...>,
208  viskores::List<T1s...>,
209  viskores::List<T2s...>,
210  viskores::List<T3s...>,
211  viskores::List<T4s...>,
212  viskores::List<T5s...>>
213 {
214  using type = viskores::List<T0s..., T1s..., T2s..., T3s..., T4s..., T5s...>;
215  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
216 };
217 
218 template <typename... T0s,
219  typename... T1s,
220  typename... T2s,
221  typename... T3s,
222  typename... T4s,
223  typename... T5s,
224  typename... T6s>
225 struct ListAppendImpl<viskores::List<T0s...>,
226  viskores::List<T1s...>,
227  viskores::List<T2s...>,
228  viskores::List<T3s...>,
229  viskores::List<T4s...>,
230  viskores::List<T5s...>,
231  viskores::List<T6s...>>
232 {
233  using type = viskores::List<T0s..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s...>;
234  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
235 };
236 
237 template <typename... T0s,
238  typename... T1s,
239  typename... T2s,
240  typename... T3s,
241  typename... T4s,
242  typename... T5s,
243  typename... T6s,
244  typename... T7s>
245 struct ListAppendImpl<viskores::List<T0s...>,
246  viskores::List<T1s...>,
247  viskores::List<T2s...>,
248  viskores::List<T3s...>,
249  viskores::List<T4s...>,
250  viskores::List<T5s...>,
251  viskores::List<T6s...>,
252  viskores::List<T7s...>>
253 {
254  using type = viskores::List<T0s..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s..., T7s...>;
255  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
256 };
257 
258 template <typename... T0s,
259  typename... T1s,
260  typename... T2s,
261  typename... T3s,
262  typename... T4s,
263  typename... T5s,
264  typename... T6s,
265  typename... T7s,
266  typename... Ls>
267 struct ListAppendImpl<viskores::List<T0s...>,
268  viskores::List<T1s...>,
269  viskores::List<T2s...>,
270  viskores::List<T3s...>,
271  viskores::List<T4s...>,
272  viskores::List<T5s...>,
273  viskores::List<T6s...>,
274  viskores::List<T7s...>,
275  Ls...>
276 {
277  using type = typename ListAppendImpl<
278  viskores::List<T0s..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s..., T7s...>,
279  Ls...>::type;
280  VISKORES_CHECK_LIST_SIZE(viskores::ListSize<type>::value);
281 };
282 
283 } // namespace detail
284 
288 template <typename... Lists>
289 using ListAppend = typename detail::ListAppendImpl<Lists...>::type;
290 
291 namespace detail
292 {
293 
294 template <typename T, viskores::IdComponent N>
295 struct ListFillImpl
296 {
297  using type = typename ListAppendImpl<typename ListFillImpl<T, (N / 2)>::type,
298  typename ListFillImpl<T, (N - (N / 2))>::type>::type;
299 };
300 
301 template <typename T>
302 struct ListFillImpl<T, 1>
303 {
304  using type = viskores::List<T>;
305 };
306 
307 template <typename T>
308 struct ListFillImpl<T, 0>
309 {
310  using type = viskores::List<>;
311 };
312 
313 } // namespace detail
314 
317 template <typename T, viskores::IdComponent N>
318 using ListFill = typename detail::ListFillImpl<T, N>::type;
319 
320 namespace detail
321 {
322 
323 template <typename T>
324 struct ListAtImplFunc;
325 
326 template <typename... VoidTypes>
327 struct ListAtImplFunc<viskores::List<VoidTypes...>>
328 {
329  // Rather than declare a `type`, make a declaration of a function that returns the type
330  // after some number of `const void*` arguments. We can use ListFill to quickly create
331  // the list of `const void*` arguments, so the type can be returned. We can then use
332  // decltype to get the returned type.
333  //
334  // Templating the `Other` should not be strictly necessary. (You should be able to just
335  // end with `...`.) But some compilers (such as CUDA 8 and Intel 18) have a problem with
336  // that.
337  template <typename T, class... Other>
338  static T at(VoidTypes..., T*, Other...);
339 };
340 
341 template <typename T, viskores::IdComponent Index>
342 struct ListAtImpl;
343 
344 template <typename... Ts, viskores::IdComponent Index>
345 struct ListAtImpl<viskores::List<Ts...>, Index>
346 {
347  using type = decltype(ListAtImplFunc<viskores::ListFill<const void*, Index>>::at(
348  static_cast<Ts*>(nullptr)...));
349 };
350 
351 } // namespace detail
352 
357 template <typename List, viskores::IdComponent Index>
358 using ListAt = typename detail::ListAtImpl<List, Index>::type;
359 
360 namespace detail
361 {
362 
363 template <viskores::IdComponent NumSearched, typename Target, typename... Remaining>
364 struct FindFirstOfType;
365 
366 // Not found
367 template <viskores::IdComponent NumSearched, typename Target>
368 struct FindFirstOfType<NumSearched, Target> : std::integral_constant<viskores::IdComponent, -1>
369 {
370 };
371 
372 // Basic search next one
373 template <bool NextIsTarget,
374  viskores::IdComponent NumSearched,
375  typename Target,
376  typename... Remaining>
377 struct FindFirstOfCheckHead;
378 
379 template <viskores::IdComponent NumSearched, typename Target, typename... Ts>
380 struct FindFirstOfCheckHead<true, NumSearched, Target, Ts...>
381  : std::integral_constant<viskores::IdComponent, NumSearched>
382 {
383 };
384 
385 template <viskores::IdComponent NumSearched, typename Target, typename Next, typename... Remaining>
386 struct FindFirstOfCheckHead<false, NumSearched, Target, Next, Remaining...>
387  : FindFirstOfCheckHead<std::is_same<Target, Next>::value, NumSearched + 1, Target, Remaining...>
388 {
389 };
390 
391 // Not found
392 template <viskores::IdComponent NumSearched, typename Target>
393 struct FindFirstOfCheckHead<false, NumSearched, Target>
394  : std::integral_constant<viskores::IdComponent, -1>
395 {
396 };
397 
398 template <viskores::IdComponent NumSearched, typename Target, typename Next, typename... Remaining>
399 struct FindFirstOfType<NumSearched, Target, Next, Remaining...>
400  : FindFirstOfCheckHead<std::is_same<Target, Next>::value, NumSearched, Target, Remaining...>
401 {
402 };
403 
404 // If there are at least 6 entries, check the first 4 to quickly narrow down
405 template <bool OneInFirst4Matches,
406  viskores::IdComponent NumSearched,
407  typename Target,
408  typename... Ts>
409 struct FindFirstOfSplit4;
410 
411 template <viskores::IdComponent NumSearched,
412  typename Target,
413  typename T0,
414  typename T1,
415  typename T2,
416  typename T3,
417  typename... Ts>
418 struct FindFirstOfSplit4<true, NumSearched, Target, T0, T1, T2, T3, Ts...>
419  : FindFirstOfCheckHead<std::is_same<Target, T0>::value, NumSearched, Target, T1, T2, T3>
420 {
421 };
422 
423 template <viskores::IdComponent NumSearched,
424  typename Target,
425  typename T0,
426  typename T1,
427  typename T2,
428  typename T3,
429  typename T4,
430  typename... Ts>
431 struct FindFirstOfSplit4<false, NumSearched, Target, T0, T1, T2, T3, T4, Ts...>
432  : FindFirstOfCheckHead<std::is_same<Target, T4>::value, NumSearched + 4, Target, Ts...>
433 {
434 };
435 
436 template <viskores::IdComponent NumSearched,
437  typename Target,
438  typename T0,
439  typename T1,
440  typename T2,
441  typename T3,
442  typename T4,
443  typename T5,
444  typename... Ts>
445 struct FindFirstOfType<NumSearched, Target, T0, T1, T2, T3, T4, T5, Ts...>
446  : FindFirstOfSplit4<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
447  std::is_same<Target, T2>::value || std::is_same<Target, T3>::value),
448  NumSearched,
449  Target,
450  T0,
451  T1,
452  T2,
453  T3,
454  T4,
455  T5,
456  Ts...>
457 {
458 };
459 
460 // If there are at least 12 entries, check the first 8 to quickly narrow down
461 template <bool OneInFirst8Matches,
462  viskores::IdComponent NumSearched,
463  typename Target,
464  typename... Ts>
465 struct FindFirstOfSplit8;
466 
467 template <viskores::IdComponent NumSearched,
468  typename Target,
469  typename T0,
470  typename T1,
471  typename T2,
472  typename T3,
473  typename T4,
474  typename T5,
475  typename T6,
476  typename T7,
477  typename... Ts>
478 struct FindFirstOfSplit8<true, NumSearched, Target, T0, T1, T2, T3, T4, T5, T6, T7, Ts...>
479  : FindFirstOfSplit4<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
480  std::is_same<Target, T2>::value || std::is_same<Target, T3>::value),
481  NumSearched,
482  Target,
483  T0,
484  T1,
485  T2,
486  T3,
487  T4,
488  T5,
489  T6,
490  T7>
491 {
492 };
493 
494 template <viskores::IdComponent NumSearched,
495  typename Target,
496  typename T0,
497  typename T1,
498  typename T2,
499  typename T3,
500  typename T4,
501  typename T5,
502  typename T6,
503  typename T7,
504  typename... Ts>
505 struct FindFirstOfSplit8<false, NumSearched, Target, T0, T1, T2, T3, T4, T5, T6, T7, Ts...>
506  : FindFirstOfType<NumSearched + 8, Target, Ts...>
507 {
508 };
509 
510 template <viskores::IdComponent NumSearched,
511  typename Target,
512  typename T0,
513  typename T1,
514  typename T2,
515  typename T3,
516  typename T4,
517  typename T5,
518  typename T6,
519  typename T7,
520  typename T8,
521  typename T9,
522  typename T10,
523  typename T11,
524  typename... Ts>
525 struct FindFirstOfType<NumSearched, Target, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Ts...>
526  : FindFirstOfSplit8<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
527  std::is_same<Target, T2>::value || std::is_same<Target, T3>::value ||
528  std::is_same<Target, T4>::value || std::is_same<Target, T5>::value ||
529  std::is_same<Target, T6>::value || std::is_same<Target, T7>::value),
530  NumSearched,
531  Target,
532  T0,
533  T1,
534  T2,
535  T3,
536  T4,
537  T5,
538  T6,
539  T7,
540  T8,
541  T9,
542  T10,
543  T11,
544  Ts...>
545 {
546 };
547 
548 template <typename List, typename Target>
549 struct ListIndexOfImpl;
550 template <typename... Ts, typename Target>
551 struct ListIndexOfImpl<viskores::List<Ts...>, Target>
552 {
553  using type =
554  std::integral_constant<viskores::IdComponent, FindFirstOfType<0, Target, Ts...>::value>;
555 };
556 template <typename Target>
557 struct ListIndexOfImpl<viskores::ListUniversal, Target>
558 {
559  VISKORES_STATIC_ASSERT_MSG((std::is_same<Target, void>::value &&
560  std::is_same<Target, int>::value),
561  "Cannot get indices in a universal list.");
562 };
563 
564 } // namespace detail
565 
571 template <typename List, typename T>
572 using ListIndexOf = typename detail::ListIndexOfImpl<List, T>::type;
573 
574 namespace detail
575 {
576 
577 template <typename List, typename T>
578 struct ListHasImpl
579 {
580  using type = std::integral_constant<bool, (viskores::ListIndexOf<List, T>::value >= 0)>;
581 };
582 
583 template <typename T>
584 struct ListHasImpl<viskores::ListUniversal, T>
585 {
586  using type = std::true_type;
587 };
588 
589 } // namespace detail
590 
595 template <typename List, typename T>
596 using ListHas = typename detail::ListHasImpl<List, T>::type;
597 
598 namespace detail
599 {
600 
601 template <typename T, template <typename> class Target>
602 struct ListTransformImpl;
603 template <typename... Ts, template <typename> class Target>
604 struct ListTransformImpl<viskores::List<Ts...>, Target>
605 {
606  using type = viskores::List<Target<Ts>...>;
607 };
608 // Cannot transform the universal list.
609 template <template <typename> class Target>
610 struct ListTransformImpl<viskores::ListUniversal, Target>;
611 
612 } // namespace detail
613 
616 template <typename List, template <typename> class Transform>
617 using ListTransform = typename detail::ListTransformImpl<List, Transform>::type;
618 
619 namespace detail
620 {
621 
622 #if defined(VISKORES_MSVC) && (_MSC_VER < 1920)
623 // Special (inefficient) implementation for MSVC 2017, which has an ICE for the regular version
624 
625 template <typename Passed,
626  typename Next,
627  bool Remove,
628  typename Rest,
629  template <typename>
630  class Predicate>
631 struct ListRemoveIfCheckNext;
632 
633 template <typename Passed, typename Rest, template <typename> class Predicate>
634 struct ListRemoveIfGetNext;
635 
636 template <typename Passed, typename Next, typename Rest, template <typename> class Predicate>
637 struct ListRemoveIfCheckNext<Passed, Next, true, Rest, Predicate>
638 {
639  using type = typename ListRemoveIfGetNext<Passed, Rest, Predicate>::type;
640 };
641 
642 template <typename... PassedTs, typename Next, typename Rest, template <typename> class Predicate>
643 struct ListRemoveIfCheckNext<viskores::List<PassedTs...>, Next, false, Rest, Predicate>
644 {
645  using type =
646  typename ListRemoveIfGetNext<viskores::List<PassedTs..., Next>, Rest, Predicate>::type;
647 };
648 
649 template <typename Passed, typename Next, typename... RestTs, template <typename> class Predicate>
650 struct ListRemoveIfGetNext<Passed, viskores::List<Next, RestTs...>, Predicate>
651 {
652  using type = typename ListRemoveIfCheckNext<Passed,
653  Next,
654  Predicate<Next>::value,
655  viskores::List<RestTs...>,
656  Predicate>::type;
657 };
658 
659 template <typename Passed, template <typename> class Predicate>
660 struct ListRemoveIfGetNext<Passed, viskores::List<>, Predicate>
661 {
662  using type = Passed;
663 };
664 
665 template <typename L, template <typename> class Predicate>
666 struct ListRemoveIfImpl
667 {
668  using type = typename ListRemoveIfGetNext<viskores::List<>, L, Predicate>::type;
669 };
670 
671 #else
672 
673 template <typename L, template <typename> class Predicate>
674 struct ListRemoveIfImpl;
675 
676 template <typename... Ts, template <typename> class Predicate>
677 struct ListRemoveIfImpl<viskores::List<Ts...>, Predicate>
678 {
679  using type = typename ListAppendImpl<
680  std::conditional_t<Predicate<Ts>::value, viskores::List<>, viskores::List<Ts>>...>::type;
681 };
682 
683 #endif
684 
685 } // namespace detail
686 
699 template <typename List, template <typename> class Predicate>
700 using ListRemoveIf = typename detail::ListRemoveIfImpl<List, Predicate>::type;
701 
702 namespace detail
703 {
704 
705 template <typename List1, typename List2>
706 struct ListIntersectImpl
707 {
708  template <typename T>
709  struct Predicate
710  {
711  static constexpr bool value = !viskores::ListHas<List1, T>::value;
712  };
713 
714  using type = viskores::ListRemoveIf<List2, Predicate>;
715 };
716 
717 template <typename List1>
718 struct ListIntersectImpl<List1, viskores::ListUniversal>
719 {
720  using type = List1;
721 };
722 template <typename List2>
723 struct ListIntersectImpl<viskores::ListUniversal, List2>
724 {
725  using type = List2;
726 };
727 template <>
728 struct ListIntersectImpl<viskores::ListUniversal, viskores::ListUniversal>
729 {
730  using type = viskores::ListUniversal;
731 };
732 
733 } // namespace detail
734 
737 template <typename List1, typename List2>
738 using ListIntersect = typename detail::ListIntersectImpl<List1, List2>::type;
739 
743 VISKORES_SUPPRESS_EXEC_WARNINGS
744 template <typename Functor, typename... Ts, typename... Args>
745 VISKORES_EXEC_CONT void ListForEach(Functor&& f, viskores::List<Ts...>, Args&&... args)
746 {
747  VISKORES_STATIC_ASSERT_MSG((!std::is_same<viskores::List<Ts...>, viskores::ListUniversal>::value),
748  "Cannot call ListFor on viskores::ListUniversal.");
749  auto init_list = { (f(Ts{}, std::forward<Args>(args)...), false)... };
750  (void)init_list;
751 }
752 template <typename Functor, typename... Args>
753 VISKORES_EXEC_CONT void ListForEach(Functor&&, viskores::ListEmpty, Args&&...)
754 {
755  // No types to run functor on.
756 }
757 
758 namespace detail
759 {
760 
761 template <typename List1, typename List2>
762 struct ListCrossImpl;
763 
764 template <typename... T0s, typename... T1s>
765 struct ListCrossImpl<viskores::List<T0s...>, viskores::List<T1s...>>
766 {
767  template <typename T>
768  struct Predicate
769  {
770  using type = viskores::List<viskores::List<T, T1s>...>;
771  };
772 
773  using type = viskores::ListAppend<typename Predicate<T0s>::type...>;
774 };
775 
776 } // namespace detail
777 
782 template <typename List1, typename List2>
783 using ListCross = typename detail::ListCrossImpl<List1, List2>::type;
784 
785 namespace detail
786 {
787 
788 template <typename L, template <typename T1, typename T2> class Operator, typename Result>
789 struct ListReduceImpl;
790 
791 template <template <typename T1, typename T2> class Operator, typename Result>
792 struct ListReduceImpl<viskores::List<>, Operator, Result>
793 {
794  using type = Result;
795 };
796 
797 template <typename T0,
798  typename... Ts,
799  template <typename O1, typename O2>
800  class Operator,
801  typename Result>
802 struct ListReduceImpl<viskores::List<T0, Ts...>, Operator, Result>
803 {
804  using type = typename ListReduceImpl<viskores::List<Ts...>, Operator, Operator<Result, T0>>::type;
805 };
806 
807 template <typename T0,
808  typename T1,
809  typename T2,
810  typename T3,
811  typename T4,
812  typename T5,
813  typename T6,
814  typename T7,
815  typename T8,
816  typename... Ts,
817  template <typename O1, typename O2>
818  class Operator,
819  typename Result>
820 struct ListReduceImpl<viskores::List<T0, T1, T2, T3, T4, T5, T6, T7, T8, Ts...>, Operator, Result>
821 {
822  using type =
823  typename ListReduceImpl<viskores::List<T8, Ts...>,
824  Operator,
825  typename ListReduceImpl<viskores::List<T0, T1, T2, T3, T4, T5, T6, T7>,
826  Operator,
827  Result>::type>::type;
828 };
829 
830 } // namespace detail
831 
839 template <typename List, template <typename T1, typename T2> class Operator, typename Initial>
840 using ListReduce = typename detail::ListReduceImpl<List, Operator, Initial>::type;
841 
862 template <typename List, template <typename> class Predicate = viskores::internal::meta::Identity>
863 using ListAll = viskores::ListReduce<viskores::ListTransform<List, Predicate>,
864  viskores::internal::meta::And,
865  std::true_type>;
866 
888 template <typename List, template <typename> class Predicate = viskores::internal::meta::Identity>
889 using ListAny = viskores::ListReduce<viskores::ListTransform<List, Predicate>,
890  viskores::internal::meta::Or,
891  std::false_type>;
892 
893 #undef VISKORES_CHECK_LIST_SIZE
894 
895 } // namespace viskores
896 
897 #endif //viskores_List_h
viskores::ListReduce
typename detail::ListReduceImpl< List, Operator, Initial >::type ListReduce
Reduces a list to a single type using an operator.
Definition: List.h:840
viskores::ListHas
typename detail::ListHasImpl< List, T >::type ListHas
Checks to see if the given T is in the list pointed to by List.
Definition: List.h:596
Types.h
viskores::ListApply
typename detail::ListApplyImpl< List, Target >::type ListApply
Applies the list of types to a template.
Definition: List.h:146
VISKORES_SUPPRESS_EXEC_WARNINGS
#define VISKORES_SUPPRESS_EXEC_WARNINGS
Definition: ExportMacros.h:61
viskores::ListAny
viskores::ListReduce< viskores::ListTransform< List, Predicate >, viskores::internal::meta::Or, std::false_type > ListAny
Determines whether any of the types in the list are "true.".
Definition: List.h:891
viskores::IdComponent
viskores::Int32 IdComponent
Base type to use to index small lists.
Definition: Types.h:202
VISKORES_EXEC_CONT
#define VISKORES_EXEC_CONT
Definition: ExportMacros.h:60
viskores::ListEmpty
viskores::List<> ListEmpty
A convenience type for an empty list.
Definition: List.h:96
viskores::List
A template used to hold a list of types.
Definition: List.h:47
viskores::ListAt
typename detail::ListAtImpl< List, Index >::type ListAt
Finds the type at the given index.
Definition: List.h:358
viskores
Groups connected points that have the same field value.
Definition: Atomic.h:27
viskores::ListTransform
typename detail::ListTransformImpl< List, Transform >::type ListTransform
Constructs a list containing all types in a source list applied to a transform template.
Definition: List.h:617
Meta.h
viskores::ListAll
viskores::ListReduce< viskores::ListTransform< List, Predicate >, viskores::internal::meta::And, std::true_type > ListAll
Determines whether all the types in the list are "true.".
Definition: List.h:865
viskores::ListFill
typename detail::ListFillImpl< T, N >::type ListFill
Returns a list filled with N copies of type T.
Definition: List.h:318
viskores::ListUniversal
viskores::List< detail::UniversalTypeTag > ListUniversal
A special type for a list that represents holding all potential values.
Definition: List.h:102
Index
int Index
Definition: ChooseCudaDevice.h:95
viskores::ListIntersect
typename detail::ListIntersectImpl< List1, List2 >::type ListIntersect
Constructs a list containing types present in all lists.
Definition: List.h:738
viskores::ListSize
typename detail::ListSizeImpl< List >::type ListSize
Becomes an std::integral_constant containing the number of types in a list.
Definition: List.h:122
VISKORES_STATIC_ASSERT_MSG
#define VISKORES_STATIC_ASSERT_MSG(condition, message)
Definition: StaticAssert.h:26
viskores::ListForEach
void ListForEach(Functor &&f, viskores::List< Ts... >, Args &&... args)
For each typename represented by the list, call the functor with a default instance of that type.
Definition: List.h:745
viskores::ListAppend
typename detail::ListAppendImpl< Lists... >::type ListAppend
Concatinates a set of lists into a single list.
Definition: List.h:289
viskores::ListRemoveIf
typename detail::ListRemoveIfImpl< List, Predicate >::type ListRemoveIf
Takes an existing List and a predicate template that is applied to each type in the List.
Definition: List.h:700
VISKORES_CHECK_LIST_SIZE
#define VISKORES_CHECK_LIST_SIZE(size)
Definition: List.h:34
viskores::ListCross
typename detail::ListCrossImpl< List1, List2 >::type ListCross
Generates a list that is the cross product of two input lists.
Definition: List.h:783
viskores::ListIndexOf
typename detail::ListIndexOfImpl< List, T >::type ListIndexOf
Finds the index of a given type.
Definition: List.h:572
Generated by   doxygen 1.8.17