Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Deprecate ListTag operations

Browse Source 
The newer List operations should still work on the old ListTags, so make
those changes first to ensure that everything still works as expected if
given an old ListTag.

Next step is to deprecate ListTagBase itself and move all the lists to
the new types.
This commit is contained in:
Kenneth Moreland 2019-12-04 19:17:19 -07:00
parent 80d2948300
commit 6fc883213c
30 changed files with 287 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
benchmarking/BenchmarkFilters.cxx
View File

@ -133,14 +133,14 @@ static bool ReducedOptions;
// Limit the filter executions to only consider the following types, otherwise
// compile times and binary sizes are nuts.
using FieldTypes = vtkm::ListTagBase<vtkm::Float32, vtkm::Float64, vtkm::Vec3f_32, vtkm::Vec3f_64>;
using FieldTypes = vtkm::List<vtkm::Float32, vtkm::Float64, vtkm::Vec3f_32, vtkm::Vec3f_64>;
using StructuredCellList = vtkm::ListTagBase<vtkm::cont::CellSetStructured<3>>;
using StructuredCellList = vtkm::List<vtkm::cont::CellSetStructured<3>>;
using UnstructuredCellList =
vtkm::ListTagBase<vtkm::cont::CellSetExplicit<>, vtkm::cont::CellSetSingleType<>>;
vtkm::List<vtkm::cont::CellSetExplicit<>, vtkm::cont::CellSetSingleType<>>;
using AllCellList = vtkm::ListTagJoin<StructuredCellList, UnstructuredCellList>;
using AllCellList = vtkm::ListAppend<StructuredCellList, UnstructuredCellList>;
class BenchmarkFilterPolicy : public vtkm::filter::PolicyBase<BenchmarkFilterPolicy>

2
vtkm/Deprecated.h
View File

@ -45,7 +45,7 @@
/// Do not use a semicolon after this macro.
///
/// \def VTKM_DEPRECATED_SUPPRESS_ENDS
/// \def VTKM_DEPRECATED_SUPPRESS_END
///
/// Ends a region of code in which warnings about using deprecated code are ignored.
/// Any use of `VTKM_DEPRECATED_SUPPRESS_BEGIN` must be paired with a

31
vtkm/List.h
View File

@ -22,13 +22,23 @@ struct List
{
};
namespace detail
{
// This prototype is here to detect deprecated ListTag objects. When ListTags are removed, then
// this should be removed too.
struct ListRoot;
}
namespace internal
{
template <typename T>
struct IsListImpl
{
using type = std::false_type;
// This prototype is here to detect deprecated ListTag objects. When ListTags are removed, then
// this should be changed to be just std::false_type.
using type = std::is_base_of<vtkm::detail::ListRoot, T>;
};
template <typename... Ts>
@ -243,12 +253,29 @@ struct ListIndexOfImpl<vtkm::ListUniversal, Target>
template <typename List, typename T>
using ListIndexOf = typename detail::ListIndexOfImpl<internal::AsList<List>, T>::type;
namespace detail
{
template <typename List, typename T>
struct ListHasImpl
{
using type = std::integral_constant<bool, (vtkm::ListIndexOf<List, T>::value >= 0)>;
};
template <typename T>
struct ListHasImpl<vtkm::ListUniversal, T>
{
using type = std::true_type;
};
} // namespace detail
/// \brief Checks to see if the given `T` is in the list pointed to by `List`.
///
/// Becomes `std::true_type` if the `T` is in `List`. `std::false_type` otherwise.
///
template <typename List, typename T>
using ListHas = std::integral_constant<bool, (vtkm::ListIndexOf<List, T>::value >= 0)>;
using ListHas = typename detail::ListHasImpl<List, T>::type;
/// Concatinates a set of lists into a single list.
///

79
vtkm/ListTag.h
View File

@ -10,6 +10,8 @@
#ifndef vtk_m_ListTag_h
#define vtk_m_ListTag_h
#include <vtkm/Deprecated.h>
#include <vtkm/List.h>
#include <vtkm/internal/ListTagDetail.h>
@ -41,13 +43,24 @@ struct ListTagCheck : std::is_base_of<vtkm::detail::ListRoot, ListTag>
} // namespace internal
namespace detail
{
template <typename ListTag>
struct VTKM_DEPRECATED(1.6, "VTKM_IS_LIST_TAG replaced with VTKM_IS_LIST.") ListTagAssert
: internal::ListTagCheck<ListTag>
{
};
} // namespace detal
/// Checks that the argument is a proper list tag. This is a handy concept
/// check for functions and classes to make sure that a template argument is
/// actually a device adapter tag. (You can get weird errors elsewhere in the
/// code when a mistake is made.)
///
#define VTKM_IS_LIST_TAG(tag) \
VTKM_STATIC_ASSERT_MSG((::vtkm::internal::ListTagCheck<tag>::value), \
VTKM_STATIC_ASSERT_MSG((::vtkm::detail::ListTagAssert<tag>::value), \
"Provided type is not a valid VTK-m list tag.")
namespace internal
@ -59,7 +72,9 @@ namespace detail
template <typename ListTag>
struct ListTagAsBrigandListImpl
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag);
VTKM_DEPRECATED_SUPPRESS_END
using type = typename ListTag::list;
};
@ -70,8 +85,10 @@ struct ListTagAsBrigandListImpl
template <typename ListTag>
using ListTagAsBrigandList = typename detail::ListTagAsBrigandListImpl<ListTag>::type;
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename List>
using ListAsListTag = brigand::wrap<List, vtkm::ListTagBase>;
VTKM_DEPRECATED_SUPPRESS_END
// This allows the new `List` operations work on `ListTag`s.
template <typename T>
@ -82,11 +99,13 @@ struct AsListImpl
using type = brigand::wrap<ListTagAsBrigandList<T>, vtkm::List>;
};
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <>
struct AsListImpl<vtkm::ListTagUniversal>
{
using type = vtkm::ListUniversal;
};
VTKM_DEPRECATED_SUPPRESS_END
} // namespace internal
@ -111,12 +130,14 @@ struct ListTagApplyImpl<brigand::list<Ts...>, Target>
/// represented by the ListTag.
///
template <typename ListTag, template <typename...> class Target>
using ListTagApply =
using ListTagApply VTKM_DEPRECATED(1.6, "ListTagApply replaced by ListApply.") =
typename detail::ListTagApplyImpl<internal::ListTagAsBrigandList<ListTag>, Target>::type;
/// A special tag for an empty list.
///
struct ListTagEmpty : detail::ListRoot
struct VTKM_DEPRECATED(1.6,
"ListTagEmpty replaced by ListTag. Note that ListTag cannot be subclassed.")
ListTagEmpty : detail::ListRoot
{
using list = vtkm::detail::ListBase<>;
};
@ -124,7 +145,10 @@ struct ListTagEmpty : detail::ListRoot
/// A tag that is a construction of two other tags joined together. This struct
/// can be subclassed and still behave like a list tag.
template <typename... ListTags>
struct ListTagJoin : detail::ListRoot
struct VTKM_DEPRECATED(
1.6,
"ListTagJoin replaced by ListAppend. Note that ListAppend cannot be subclassed.") ListTagJoin
: detail::ListRoot
{
using list = typename detail::ListJoin<internal::ListTagAsBrigandList<ListTags>...>::type;
};
@ -132,9 +156,14 @@ struct ListTagJoin : detail::ListRoot
/// A tag that is constructed by appending \c Type to \c ListTag.
template <typename ListTag, typename Type>
struct ListTagAppend : detail::ListRoot
struct VTKM_DEPRECATED(1.6,
"ListTagAppend<List, Type> replaced by ListAppend<List, vtkm::List<Type>. "
"Note that ListAppend cannot be subclassed.") ListTagAppend
: detail::ListRoot
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag);
VTKM_DEPRECATED_SUPPRESS_END
using list = typename detail::ListJoin<internal::ListTagAsBrigandList<ListTag>,
detail::ListBase<Type>>::type;
};
@ -142,9 +171,11 @@ struct ListTagAppend : detail::ListRoot
/// Append \c Type to \c ListTag only if \c ListTag does not already contain \c Type.
/// No checks are performed to see if \c ListTag itself has only unique elements.
template <typename ListTag, typename Type>
struct ListTagAppendUnique : detail::ListRoot
struct VTKM_DEPRECATED(1.6) ListTagAppendUnique : detail::ListRoot
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag);
VTKM_DEPRECATED_SUPPRESS_END
using list =
typename detail::ListAppendUniqueImpl<internal::ListTagAsBrigandList<ListTag>, Type>::type;
};
@ -152,10 +183,15 @@ struct ListTagAppendUnique : detail::ListRoot
/// A tag that consists of elements that are found in both tags. This struct
/// can be subclassed and still behave like a list tag.
template <typename ListTag1, typename ListTag2>
struct ListTagIntersect : detail::ListRoot
struct VTKM_DEPRECATED(
1.6,
"ListTagIntersect replaced by ListIntersect. Note that ListIntersect cannot be subclassed.")
ListTagIntersect : detail::ListRoot
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag1);
VTKM_IS_LIST_TAG(ListTag2);
VTKM_DEPRECATED_SUPPRESS_END
using list = typename detail::ListIntersect<internal::ListTagAsBrigandList<ListTag1>,
internal::ListTagAsBrigandList<ListTag2>>::type;
};
@ -163,9 +199,14 @@ struct ListTagIntersect : detail::ListRoot
/// A list tag that consists of each item in another list tag fed into a template that takes
/// a single parameter.
template <typename ListTag, template <typename> class Transform>
struct ListTagTransform : detail::ListRoot
struct VTKM_DEPRECATED(
1.6,
"ListTagTransform replaced by ListTransform. Note that ListTransform cannot be subclassed.")
ListTagTransform : detail::ListRoot
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag);
VTKM_DEPRECATED_SUPPRESS_END
using list = brigand::transform<internal::ListTagAsBrigandList<ListTag>,
brigand::bind<Transform, brigand::_1>>;
};
@ -184,9 +225,14 @@ struct ListTagTransform : detail::ListRoot
/// whereas `std::is_integral<float>` and `std::is_integral<double>` resolve to
/// `std::false_type`.
template <typename ListTag, template <typename> class Predicate>
struct ListTagRemoveIf : detail::ListRoot
struct VTKM_DEPRECATED(
1.6,
"ListTagRemoveIf replaced by ListRemoveIf. Note that ListRemoveIf cannot be subclassed.")
ListTagRemoveIf : detail::ListRoot
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag);
VTKM_DEPRECATED_SUPPRESS_END
using list = brigand::remove_if<internal::ListTagAsBrigandList<ListTag>,
brigand::bind<Predicate, brigand::_1>>;
};
@ -195,10 +241,15 @@ struct ListTagRemoveIf : detail::ListRoot
/// tag has the form of Tag< brigand::list<A1,B1>, brigand::list<A1,B2> .... >
///
template <typename ListTag1, typename ListTag2>
struct ListCrossProduct : detail::ListRoot
struct VTKM_DEPRECATED(
1.6,
"ListCrossProduct replaced by ListCross. Note that LIstCross cannot be subclassed.")
ListCrossProduct : detail::ListRoot
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag1);
VTKM_IS_LIST_TAG(ListTag2);
VTKM_DEPRECATED_SUPPRESS_END
using list =
typename detail::ListCrossProductImpl<internal::ListTagAsBrigandList<ListTag1>,
internal::ListTagAsBrigandList<ListTag2>>::type;
@ -210,9 +261,11 @@ struct ListCrossProduct : detail::ListRoot
/// contained in the list and false otherwise.
///
template <typename ListTag, typename Type>
struct ListContains
struct VTKM_DEPRECATED(1.6, "ListContains replaced by ListHas.") ListContains
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag);
VTKM_DEPRECATED_SUPPRESS_END
static constexpr bool value =
detail::ListContainsImpl<Type, internal::ListTagAsBrigandList<ListTag>>::value;
};
@ -222,9 +275,11 @@ struct ListContains
/// This struct contains subtype \c type that resolves to the type at the given index.
///
template <typename ListTag, vtkm::IdComponent Index>
struct ListTypeAt
struct VTKM_DEPRECATED(1.6, "ListTypeAt::type replaced by ListAt.") ListTypeAt
{
VTKM_DEPRECATED_SUPPRESS_BEGIN
VTKM_IS_LIST_TAG(ListTag);
VTKM_DEPRECATED_SUPPRESS_END
using type = brigand::at<internal::ListTagAsBrigandList<ListTag>,
std::integral_constant<vtkm::IdComponent, Index>>;
};

28
vtkm/TypeListTag.h
View File

@ -183,19 +183,14 @@ struct VTKM_ALWAYS_EXPORT TypeListTagVecUncommon
/// A list of all vector classes with standard types as components and
/// lengths between 2 and 4.
///
struct VTKM_ALWAYS_EXPORT TypeListTagVecAll
: vtkm::ListTagJoin<vtkm::TypeListTagVecCommon, vtkm::internal::TypeListTagVecUncommon>
{
};
using TypeListTagVecAll =
vtkm::ListAppend<vtkm::TypeListTagVecCommon, vtkm::internal::TypeListTagVecUncommon>;
/// A list of all basic types listed in vtkm/Types.h. Does not include all
/// possible VTK-m types like arbitrarily typed and sized Vecs (only up to
/// length 4) or math types like matrices.
///
struct VTKM_ALWAYS_EXPORT TypeListTagAll
: vtkm::ListTagJoin<vtkm::TypeListTagScalarAll, vtkm::TypeListTagVecAll>
{
};
using TypeListTagAll = vtkm::ListAppend<vtkm::TypeListTagScalarAll, vtkm::TypeListTagVecAll>;
/// A list of the most commonly used types across multiple domains. Includes
/// integers, floating points, and 3 dimensional vectors of floating points.
@ -211,6 +206,7 @@ struct VTKM_ALWAYS_EXPORT TypeListTagCommon
{
};
VTKM_DEPRECATED_SUPPRESS_BEGIN
// Special implementation of ListContains for TypeListTagAll to always be
// true. Although TypeListTagAll is necessarily finite, the point is to
// be all inclusive. Besides, this should speed up the compilation when
@ -220,6 +216,22 @@ struct ListContains<vtkm::TypeListTagAll, Type>
{
static constexpr bool value = true;
};
VTKM_DEPRECATED_SUPPRESS_END
// Special implementation of ListContains for TypeListTagAll to always be
// true. Although TypeListTagAll is necessarily finite, the point is to
// be all inclusive. Besides, this should speed up the compilation when
// checking a list that should contain everything.
namespace detail
{
template<typename Type>
struct ListHasImpl<vtkm::TypeListTagAll, Type>
{
using type = std::true_type;
};
} // namespace detail
} // namespace vtkm

16
vtkm/cont/ArrayHandleMultiplexer.h
View File

@ -534,8 +534,22 @@ public:
/// the list tag must be some type of \c ArrayHandle. The templated type gets aliased to
/// an \c ArrayHandleMultiplexer that can store any of these ArrayHandle types.
///
/// Deprecated. Use `ArrayHandleMultiplexerFromList` instead.
///
template <typename ListTag>
using ArrayHandleMultiplexerFromListTag = vtkm::ListTagApply<ListTag, ArrayHandleMultiplexer>;
using ArrayHandleMultiplexerFromListTag VTKM_DEPRECATED(
1.6,
"vtkm::ListTag is no longer supported. Use vtkm::List instead.") =
vtkm::ListApply<ListTag, ArrayHandleMultiplexer>;
/// \brief Converts a`vtkm::List` to an `ArrayHandleMultiplexer`
///
/// The argument of this template must be a `vtkm::List` and furthermore all the types in
/// the list tag must be some type of \c ArrayHandle. The templated type gets aliased to
/// an \c ArrayHandleMultiplexer that can store any of these ArrayHandle types.
///
template <typename List>
using ArrayHandleMultiplexerFromList = vtkm::ListApply<List, ArrayHandleMultiplexer>;
} // namespace cont

2
vtkm/cont/AtomicArray.h
View File

@ -48,7 +48,7 @@ struct AtomicArrayTypeListTag
template <typename T>
class AtomicArray : public vtkm::cont::ExecutionObjectBase
{
static constexpr bool ValueTypeIsValid = vtkm::ListContains<AtomicArrayTypeListTag, T>::value;
static constexpr bool ValueTypeIsValid = vtkm::ListHas<AtomicArrayTypeListTag, T>::value;
VTKM_STATIC_ASSERT_MSG(ValueTypeIsValid, "AtomicArray used with unsupported ValueType.");

20
vtkm/cont/BitField.h
View File

@ -61,16 +61,16 @@ struct BitFieldTraits
/// Require an unsigned integral type that is <= BlockSize bytes, and is
/// is supported by the specified AtomicInterface.
template <typename WordType, typename AtomicInterface>
using IsValidWordTypeAtomic = std::integral_constant<
bool,
/* is unsigned */
std::is_unsigned<WordType>::value &&
/* doesn't exceed blocksize */
sizeof(WordType) <= static_cast<size_t>(BlockSize) &&
/* BlockSize is a multiple of WordType */
static_cast<size_t>(BlockSize) % sizeof(WordType) == 0 &&
/* Supported by atomic interface */
vtkm::ListContains<typename AtomicInterface::WordTypes, WordType>::value>;
using IsValidWordTypeAtomic =
std::integral_constant<bool,
/* is unsigned */
std::is_unsigned<WordType>::value &&
/* doesn't exceed blocksize */
sizeof(WordType) <= static_cast<size_t>(BlockSize) &&
/* BlockSize is a multiple of WordType */
static_cast<size_t>(BlockSize) % sizeof(WordType) == 0 &&
/* Supported by atomic interface */
vtkm::ListHas<typename AtomicInterface::WordTypes, WordType>::value>;
};
/// Identifies a bit in a BitField by Word and BitOffset. Note that these

4
vtkm/cont/DynamicCellSet.h
View File

@ -53,7 +53,7 @@ namespace cont
template <typename CellSetList>
class VTKM_ALWAYS_EXPORT DynamicCellSetBase
{
VTKM_IS_LIST_TAG(CellSetList);
VTKM_IS_LIST(CellSetList);
public:
VTKM_CONT
@ -136,7 +136,7 @@ public:
VTKM_CONT DynamicCellSetBase<NewCellSetList> ResetCellSetList(
NewCellSetList = NewCellSetList()) const
{
VTKM_IS_LIST_TAG(NewCellSetList);
VTKM_IS_LIST(NewCellSetList);
return DynamicCellSetBase<NewCellSetList>(*this);
}

2
vtkm/cont/Field.h
View File

@ -150,7 +150,7 @@ private:
template <typename TypeList>
VTKM_CONT const vtkm::cont::ArrayHandle<vtkm::Range>& GetRangeImpl(TypeList) const
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST(TypeList);
if (this->ModifiedFlag)
{

4
vtkm/cont/FieldRangeCompute.h
View File

@ -45,7 +45,7 @@ VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST(TypeList);
return vtkm::cont::detail::FieldRangeComputeImpl(dataset, name, assoc, TypeList());
}
@ -74,7 +74,7 @@ VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST(TypeList);
return vtkm::cont::detail::FieldRangeComputeImpl(pds, name, assoc, TypeList());
}

4
vtkm/cont/FieldRangeGlobalCompute.h
View File

@ -43,7 +43,7 @@ VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST(TypeList);
return detail::FieldRangeGlobalComputeImpl(dataset, name, assoc, TypeList());
}
@ -71,7 +71,7 @@ VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST(TypeList);
return detail::FieldRangeGlobalComputeImpl(pds, name, assoc, TypeList());
}
//@}

30
vtkm/cont/VariantArrayHandle.h
View File

@ -137,7 +137,7 @@ public:
template <typename T, typename StorageTagList = VTKM_DEFAULT_STORAGE_LIST_TAG>
VTKM_CONT vtkm::cont::ArrayHandleVirtual<T> AsVirtual() const
{
VTKM_IS_LIST_TAG(StorageTagList);
VTKM_IS_LIST(StorageTagList);
vtkm::cont::internal::variant::ForceCastToVirtual caster;
vtkm::cont::ArrayHandleVirtual<T> output;
this->CastAndCall(StorageTagList{}, caster, output);
@ -182,7 +182,7 @@ public:
}
/// Changes the types to try casting to when resolving this variant array,
/// which is specified with a list tag like those in TypeListTag.h. Since C++
/// which is specified with a list tag like those in TypeList.h. Since C++
/// does not allow you to actually change the template arguments, this method
/// returns a new variant array object. This method is particularly useful to
/// narrow down (or expand) the types when using an array of particular
@ -191,7 +191,7 @@ public:
template <typename NewTypeList>
VTKM_CONT VariantArrayHandleBase<NewTypeList> ResetTypes(NewTypeList = NewTypeList()) const
{
VTKM_IS_LIST_TAG(NewTypeList);
VTKM_IS_LIST(NewTypeList);
return VariantArrayHandleBase<NewTypeList>(*this);
}
@ -210,7 +210,7 @@ public:
/// array does not match any of the storage tags given, then the array will
/// be cast to an \c ArrayHandleVirtual, which can hold any array given the
/// appropriate value type. To always use \c ArrayHandleVirtual, pass
/// \c vtkm::ListTagEmpty as thefirst argument.
/// \c vtkm::ListEmpty as thefirst argument.
///
/// As previous stated, if a storage tag list is provided, it is given in the
/// first argument. The functor to call with the cast array is given as the next
@ -223,7 +223,7 @@ public:
template <typename FunctorOrStorageList, typename... Args>
VTKM_CONT void CastAndCall(FunctorOrStorageList&& functorOrStorageList, Args&&... args) const
{
this->CastAndCallImpl(vtkm::internal::ListTagCheck<FunctorOrStorageList>(),
this->CastAndCallImpl(vtkm::internal::IsList<FunctorOrStorageList>(),
std::forward<FunctorOrStorageList>(functorOrStorageList),
std::forward<Args>(args)...);
}
@ -329,7 +329,7 @@ namespace detail
struct VariantArrayHandleTry
{
template <typename T, typename Storage, typename Functor, typename... Args>
void operator()(brigand::list<T, Storage>,
void operator()(vtkm::List<T, Storage>,
Functor&& f,
bool& called,
const vtkm::cont::internal::VariantArrayHandleContainerBase& container,
@ -391,18 +391,13 @@ struct IsUndefinedStorage
{
};
template <typename T, typename U>
struct IsUndefinedStorage<brigand::list<T, U>> : vtkm::cont::internal::IsInValidArrayHandle<T, U>
struct IsUndefinedStorage<vtkm::List<T, U>> : vtkm::cont::internal::IsInValidArrayHandle<T, U>
{
};
template <typename TypeList, typename StorageList>
struct ListTagDynamicTypes : vtkm::detail::ListRoot
{
using crossProduct = typename vtkm::ListCrossProduct<TypeList, StorageList>;
// using list = vtkm::internal::ListTagAsBrigandList<crossProduct>;
using list = ::brigand::remove_if<vtkm::internal::ListTagAsBrigandList<crossProduct>,
IsUndefinedStorage<brigand::_1>>;
};
using ListDynamicTypes =
vtkm::ListRemoveIf<vtkm::ListCross<TypeList, StorageList>, IsUndefinedStorage>;
VTKM_CONT_EXPORT void ThrowCastAndCallException(
@ -420,7 +415,7 @@ VTKM_CONT void VariantArrayHandleBase<TypeList>::CastAndCallImpl(std::true_type,
Functor&& f,
Args&&... args) const
{
using crossProduct = detail::ListTagDynamicTypes<TypeList, StorageTagList>;
using crossProduct = detail::ListDynamicTypes<TypeList, StorageTagList>;
bool called = false;
const auto& ref = *this->ArrayContainer;
@ -538,8 +533,7 @@ inline VTKM_CONT void VariantArrayHandleBase<TypeList>::AsMultiplexer(
{
// Make sure IsValid is clear
result = vtkm::cont::ArrayHandleMultiplexer<T...>{};
vtkm::ListForEach(
detail::VariantArrayHandleTryMultiplexer{}, vtkm::ListTagBase<T...>{}, *this, result);
vtkm::ListForEach(detail::VariantArrayHandleTryMultiplexer{}, vtkm::List<T...>{}, *this, result);
}
namespace internal
@ -606,7 +600,7 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& obj)
{
obj.CastAndCall(vtkm::ListTagEmpty(), internal::VariantArrayHandleSerializeFunctor{}, bb);
obj.CastAndCall(vtkm::ListEmpty(), internal::VariantArrayHandleSerializeFunctor{}, bb);
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& obj)

4
vtkm/cont/arg/TypeCheckTagAtomicArray.h
View File

@ -42,13 +42,13 @@ struct TypeCheck<TypeCheckTagAtomicArray, ArrayType>
template <typename T>
struct TypeCheck<TypeCheckTagAtomicArray, vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>>
{
static constexpr bool value = vtkm::ListContains<vtkm::cont::AtomicArrayTypeListTag, T>::value;
static constexpr bool value = vtkm::ListHas<vtkm::cont::AtomicArrayTypeListTag, T>::value;
};
template <typename T>
struct TypeCheck<TypeCheckTagAtomicArray, vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagVirtual>>
{
static constexpr bool value = vtkm::ListContains<vtkm::cont::AtomicArrayTypeListTag, T>::value;
static constexpr bool value = vtkm::ListHas<vtkm::cont::AtomicArrayTypeListTag, T>::value;
};
}
}

2
vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx
View File

@ -68,7 +68,7 @@ constexpr vtkm::Id ArraySize = 10;
using TestTypesList = vtkm::ListTagBase<vtkm::Int8, vtkm::Id, vtkm::FloatDefault, vtkm::Vec3f>;
template <typename T, typename S>
inline vtkm::cont::VariantArrayHandleBase<vtkm::ListTagAppendUnique<TestTypesList, T>>
inline vtkm::cont::VariantArrayHandleBase<vtkm::ListAppend<TestTypesList, vtkm::List<T>>>
MakeTestVariantArrayHandle(const vtkm::cont::ArrayHandle<T, S>& array)
{
return array;

6
vtkm/cont/testing/UnitTestTimer.cxx
View File

@ -20,10 +20,8 @@
namespace
{
struct TimerTestDevices
: vtkm::ListTagAppend<VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG, vtkm::cont::DeviceAdapterTagAny>
{
};
using TimerTestDevices = vtkm::ListAppend<VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG,
vtkm::List<vtkm::cont::DeviceAdapterTagAny>>;
constexpr long long waitTimeMilliseconds = 250;
constexpr vtkm::Float64 waitTimeSeconds = vtkm::Float64(waitTimeMilliseconds) / 1000;

21
vtkm/cont/testing/UnitTestVariantArrayHandle.cxx
View File

@ -57,9 +57,7 @@ namespace
const vtkm::Id ARRAY_SIZE = 10;
struct TypeListTagString : vtkm::ListTagBase<std::string>
{
};
using TypeListString = vtkm::List<std::string>;
template <typename T>
struct UnusualPortal
@ -187,8 +185,7 @@ void CheckArrayVariant(const vtkm::cont::VariantArrayHandleBase<TypeList>& array
calledBasic = false;
calledUnusual = false;
calledVirtual = false;
array.CastAndCall(
vtkm::ListTagEmpty(), CheckFunctor(), calledBasic, calledUnusual, calledVirtual);
array.CastAndCall(vtkm::ListEmpty(), CheckFunctor(), calledBasic, calledUnusual, calledVirtual);
VTKM_TEST_ASSERT(
calledBasic || calledUnusual || calledVirtual,
"The functor was never called (and apparently a bad value exception not thrown).");
@ -199,9 +196,9 @@ void CheckArrayVariant(const vtkm::cont::VariantArrayHandleBase<TypeList>& array
calledBasic = false;
calledUnusual = false;
calledVirtual = false;
array.CastAndCall(vtkm::ListTagBase<vtkm::cont::StorageTagBasic,
ArrayHandleWithUnusualStorage<vtkm::Id>::StorageTag,
ArrayHandleWithUnusualStorage<std::string>::StorageTag>(),
array.CastAndCall(vtkm::List<vtkm::cont::StorageTagBasic,
ArrayHandleWithUnusualStorage<vtkm::Id>::StorageTag,
ArrayHandleWithUnusualStorage<std::string>::StorageTag>(),
CheckFunctor(),
calledBasic,
calledUnusual,
@ -274,9 +271,9 @@ void CheckCastToVirtualArrayHandle(const ArrayType& array)
static constexpr vtkm::IdComponent NumComps = VTraits::NUM_COMPONENTS;
using Storage = typename ArrayType::StorageTag;
using StorageList = vtkm::ListTagAppendUnique<VTKM_DEFAULT_STORAGE_LIST_TAG, Storage>;
using StorageList = vtkm::ListAppend<VTKM_DEFAULT_STORAGE_LIST_TAG, vtkm::List<Storage>>;
using TypeList = vtkm::ListTagAppendUnique<VTKM_DEFAULT_TYPE_LIST_TAG, ValueType>;
using TypeList = vtkm::ListAppend<VTKM_DEFAULT_TYPE_LIST_TAG, vtkm::List<ValueType>>;
using VariantArrayType = vtkm::cont::VariantArrayHandleBase<TypeList>;
VariantArrayType arrayVariant = array;
@ -466,7 +463,7 @@ void TryUnusualType()
std::cout << " Caught exception for unrecognized type." << std::endl;
}
CheckArrayVariant(array.ResetTypes(TypeListTagString()), 1, true, false);
CheckArrayVariant(array.ResetTypes(TypeListString()), 1, true, false);
std::cout << " Found type when type list was reset." << std::endl;
}
@ -500,7 +497,7 @@ void TryUnusualTypeAndStorage()
try
{
CheckArrayVariant(array.ResetTypes(TypeListTagString()), 1, false, true);
CheckArrayVariant(array.ResetTypes(TypeListString()), 1, false, true);
}
catch (...)
{

6
vtkm/filter/Filter.h
View File

@ -182,9 +182,9 @@ public:
/// \brief Specify which subset of types a filter supports.
///
/// A filter is able to state what subset of types it supports
/// by default. By default we use ListTagUniversal to represent that the
/// by default. By default we use ListUniversal to represent that the
/// filter accepts all types specified by the users provided policy
using SupportedTypes = vtkm::ListTagUniversal;
using SupportedTypes = vtkm::ListUniversal;
/// \brief Specify which additional field storage to support.
///
@ -194,7 +194,7 @@ public:
/// For example, the filter might make sense to support ArrayHandleIndex or
/// ArrayHandleConstant. If so, the storage of those additional types should be
/// listed here.
using AdditionalFieldStorage = vtkm::ListTagEmpty;
using AdditionalFieldStorage = vtkm::ListEmpty;
//@{
/// \brief Specify which fields get passed from input to output.

2
vtkm/filter/FilterDataSetWithField.hxx
View File

@ -102,7 +102,7 @@ inline VTKM_CONT vtkm::cont::DataSet FilterDataSetWithField<Derived>::PrepareFor
//determine the field type first
using Traits = vtkm::filter::FilterTraits<Derived>;
constexpr bool supportsVec3 =
vtkm::ListContains<typename Traits::InputFieldTypeList, vtkm::Vec3f>::value;
vtkm::ListHas<typename Traits::InputFieldTypeList, vtkm::Vec3f>::value;
using supportsCoordinateSystem = std::integral_constant<bool, supportsVec3>;
vtkm::cont::ConditionalCastAndCall(supportsCoordinateSystem(),
field,

2
vtkm/filter/FilterField.hxx
View File

@ -101,7 +101,7 @@ VTKM_CONT vtkm::cont::DataSet FilterField<Derived>::PrepareForExecution(
using Traits = vtkm::filter::FilterTraits<Derived>;
constexpr bool supportsVec3 =
vtkm::ListContains<typename Traits::InputFieldTypeList, vtkm::Vec3f>::value;
vtkm::ListHas<typename Traits::InputFieldTypeList, vtkm::Vec3f>::value;
using supportsCoordinateSystem = std::integral_constant<bool, supportsVec3>;
vtkm::cont::ConditionalCastAndCall(supportsCoordinateSystem(),

21
vtkm/filter/FilterTraits.h
View File

@ -21,20 +21,21 @@ namespace filter
template <typename Derived>
class Filter;
namespace detail
{
// template<typename T> vtkm::ListTagBase<T> as_list(T);
vtkm::ListTagUniversal as_list(vtkm::ListTagUniversal);
template <typename... T>
vtkm::ListTagBase<T...> as_list(vtkm::ListTagBase<T...>);
}
//namespace detail
//{
//// template<typename T> vtkm::ListTagBase<T> as_list(T);
//vtkm::ListTagUniversal as_list(vtkm::ListTagUniversal);
//template <typename... T>
//vtkm::ListTagBase<T...> as_list(vtkm::ListTagBase<T...>);
//}
template <typename Filter>
struct FilterTraits
{
using InputFieldTypeList =
decltype(detail::as_list(std::declval<typename Filter::SupportedTypes>()));
// using InputFieldTypeList =
// decltype(detail::as_list(std::declval<typename Filter::SupportedTypes>()));
using InputFieldTypeList = typename Filter::SupportedTypes;
using AdditionalFieldStorage = typename Filter::AdditionalFieldStorage;
};
@ -42,7 +43,7 @@ template <typename DerivedPolicy, typename ListOfTypes>
struct DeduceFilterFieldTypes
{
using PList = typename DerivedPolicy::FieldTypeList;
using TypeList = vtkm::ListTagIntersect<ListOfTypes, PList>;
using TypeList = vtkm::ListIntersect<ListOfTypes, PList>;
};
}
}

69
vtkm/filter/PolicyBase.h
View File

@ -32,9 +32,9 @@ template <typename Derived>
struct PolicyBase
{
using FieldTypeList = VTKM_DEFAULT_TYPE_LIST_TAG;
using StorageList = vtkm::ListTagJoin<
using StorageList = vtkm::ListAppend<
VTKM_DEFAULT_STORAGE_LIST_TAG,
vtkm::ListTagBase<
vtkm::List<
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag,
vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<vtkm::Float32>,
vtkm::cont::ArrayHandle<vtkm::Float32>,
@ -61,17 +61,16 @@ struct AllCastingTypes
{
using VTraits = vtkm::VecTraits<BaseType>;
using type =
vtkm::ListTagBase<typename VTraits::template ReplaceBaseComponentType<vtkm::Int8>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt8>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Int16>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt8>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Int32>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt32>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Int64>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt64>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Float32>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Float64>>;
using type = vtkm::List<typename VTraits::template ReplaceBaseComponentType<vtkm::Int8>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt8>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Int16>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt8>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Int32>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt32>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Int64>,
typename VTraits::template ReplaceBaseComponentType<vtkm::UInt64>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Float32>,
typename VTraits::template ReplaceBaseComponentType<vtkm::Float64>>;
};
// Provides a transform template that builds a cast from an array of some source type to a
@ -98,8 +97,8 @@ struct AllCastArraysForStorageImpl;
template <typename TargetT, typename Storage>
struct ValidCastingTypes
{
using type = vtkm::ListTagRemoveIf<typename AllCastingTypes<TargetT>::type,
ArrayValidPredicate<Storage>::template Predicate>;
using type = vtkm::ListRemoveIf<typename AllCastingTypes<TargetT>::type,
ArrayValidPredicate<Storage>::template Predicate>;
};
template <typename TargetT, typename Storage>
@ -107,9 +106,8 @@ struct AllCastArraysForStorageImpl<TargetT, Storage, true>
{
using SourceTypes = typename ValidCastingTypes<TargetT, Storage>::type;
using CastArrays =
vtkm::ListTagTransform<SourceTypes, CastArrayTransform<TargetT, Storage>::template Transform>;
using type =
vtkm::ListTagJoin<vtkm::ListTagBase<vtkm::cont::ArrayHandle<TargetT, Storage>>, CastArrays>;
vtkm::ListTransform<SourceTypes, CastArrayTransform<TargetT, Storage>::template Transform>;
using type = vtkm::ListAppend<vtkm::List<vtkm::cont::ArrayHandle<TargetT, Storage>>, CastArrays>;
};
template <typename TargetT, typename Storage>
@ -117,7 +115,7 @@ struct AllCastArraysForStorageImpl<TargetT, Storage, false>
{
using SourceTypes = typename ValidCastingTypes<TargetT, Storage>::type;
using type =
vtkm::ListTagTransform<SourceTypes, CastArrayTransform<TargetT, Storage>::template Transform>;
vtkm::ListTransform<SourceTypes, CastArrayTransform<TargetT, Storage>::template Transform>;
};
// Special cases for known storage with limited type support.
@ -126,14 +124,14 @@ struct AllCastArraysForStorageImpl<vtkm::Vec3f,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag,
true>
{
using type = vtkm::ListTagBase<vtkm::cont::ArrayHandleUniformPointCoordinates>;
using type = vtkm::List<vtkm::cont::ArrayHandleUniformPointCoordinates>;
};
template <typename T>
struct AllCastArraysForStorageImpl<vtkm::Vec<T, 3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag,
false>
{
using type = vtkm::ListTagBase<vtkm::cont::ArrayHandleCast<
using type = vtkm::List<vtkm::cont::ArrayHandleCast<
vtkm::Vec<T, 3>,
vtkm::cont::ArrayHandle<vtkm::Vec3f,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>>>;
@ -143,7 +141,7 @@ struct AllCastArraysForStorageImpl<TargetT,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag,
false>
{
using type = vtkm::ListTagEmpty;
using type = vtkm::ListEmpty;
};
template <typename T, typename S1, typename S2, typename S3>
@ -154,10 +152,9 @@ struct AllCastArraysForStorageImpl<
vtkm::cont::ArrayHandle<T, S3>>,
true>
{
using type =
vtkm::ListTagBase<vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<T, S1>,
vtkm::cont::ArrayHandle<T, S2>,
vtkm::cont::ArrayHandle<T, S3>>>;
using type = vtkm::List<vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<T, S1>,
vtkm::cont::ArrayHandle<T, S2>,
vtkm::cont::ArrayHandle<T, S3>>>;
};
template <typename TargetT, typename SourceT, typename S1, typename S2, typename S3>
struct AllCastArraysForStorageImpl<
@ -167,7 +164,7 @@ struct AllCastArraysForStorageImpl<
vtkm::cont::ArrayHandle<SourceT, S3>>,
false>
{
using type = vtkm::ListTagBase<vtkm::cont::ArrayHandleCast<
using type = vtkm::List<vtkm::cont::ArrayHandleCast<
vtkm::Vec<TargetT, 3>,
vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<SourceT, S1>,
vtkm::cont::ArrayHandle<SourceT, S2>,
@ -181,7 +178,7 @@ struct AllCastArraysForStorageImpl<
vtkm::cont::ArrayHandle<SourceT, S3>>,
false>
{
using type = vtkm::ListTagEmpty;
using type = vtkm::ListEmpty;
};
// Given a target type and storage of an array handle, provides a list this array handle plus all
@ -210,16 +207,16 @@ struct AllCastArraysTransform
template <typename TargetT, typename StorageList>
struct AllCastArraysForStorageList
{
VTKM_IS_LIST_TAG(StorageList);
VTKM_IS_LIST(StorageList);
using listOfLists =
vtkm::ListTagTransform<StorageList, AllCastArraysTransform<TargetT>::template Transform>;
using type = vtkm::ListTagApply<listOfLists, vtkm::ListTagJoin>;
vtkm::ListTransform<StorageList, AllCastArraysTransform<TargetT>::template Transform>;
using type = vtkm::ListApply<listOfLists, vtkm::ListAppend>;
};
} // detail
template <typename TargetT, typename StorageList>
using ArrayHandleMultiplexerForStorageList = vtkm::cont::ArrayHandleMultiplexerFromListTag<
using ArrayHandleMultiplexerForStorageList = vtkm::cont::ArrayHandleMultiplexerFromList<
typename detail::AllCastArraysForStorageList<TargetT, StorageList>::type>;
} // namespace internal
@ -248,16 +245,16 @@ ApplyPolicyFieldNotActive(const vtkm::cont::Field& field, vtkm::filter::PolicyBa
template <typename T, typename DerivedPolicy, typename FilterType>
VTKM_CONT internal::ArrayHandleMultiplexerForStorageList<
T,
vtkm::ListTagJoin<typename vtkm::filter::FilterTraits<FilterType>::AdditionalFieldStorage,
typename DerivedPolicy::StorageList>>
vtkm::ListAppend<typename vtkm::filter::FilterTraits<FilterType>::AdditionalFieldStorage,
typename DerivedPolicy::StorageList>>
ApplyPolicyFieldOfType(const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>,
const FilterType&)
{
using ArrayHandleMultiplexerType = internal::ArrayHandleMultiplexerForStorageList<
T,
vtkm::ListTagJoin<typename FilterType::AdditionalFieldStorage,
typename DerivedPolicy::StorageList>>;
vtkm::ListAppend<typename FilterType::AdditionalFieldStorage,
typename DerivedPolicy::StorageList>>;
return field.GetData().AsMultiplexer<ArrayHandleMultiplexerType>();
}

8
vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx
View File

@ -221,10 +221,10 @@ void TestWithExplicitData()
struct SplitSharpTestPolicy : public vtkm::filter::PolicyBase<SplitSharpTestPolicy>
{
using StructuredCellSetList = vtkm::ListTagBase<vtkm::cont::CellSetStructured<3>>;
using UnstructuredCellSetList = vtkm::ListTagBase<vtkm::cont::CellSetSingleType<>>;
using AllCellSetList = vtkm::ListTagJoin<StructuredCellSetList, UnstructuredCellSetList>;
using FieldTypeList = vtkm::ListTagBase<vtkm::FloatDefault, vtkm::Vec3f>;
using StructuredCellSetList = vtkm::List<vtkm::cont::CellSetStructured<3>>;
using UnstructuredCellSetList = vtkm::List<vtkm::cont::CellSetSingleType<>>;
using AllCellSetList = vtkm::ListAppend<StructuredCellSetList, UnstructuredCellSetList>;
using FieldTypeList = vtkm::List<vtkm::FloatDefault, vtkm::Vec3f>;
};

21
vtkm/internal/Variant.h
View File

@ -12,7 +12,8 @@
#include <vtkm/internal/VariantDetail.h>
#include <vtkm/ListTag.h>
#include <vtkm/Deprecated.h>
#include <vtkm/List.h>
// It would make sense to put this in its own header file, but it is hard to imagine needing
@ -199,7 +200,7 @@ struct VariantStorageImpl
vtkm::IdComponent Index = -1;
template <vtkm::IdComponent Index>
using TypeAt = typename vtkm::ListTypeAt<vtkm::ListTagBase<Ts...>, Index>::type;
using TypeAt = typename vtkm::ListAt<vtkm::List<Ts...>, Index>;
VTKM_EXEC_CONT void* GetPointer() { return reinterpret_cast<void*>(&this->Storage); }
VTKM_EXEC_CONT const void* GetPointer() const
@ -328,8 +329,8 @@ public:
/// Type that converts to a std::integral_constant containing the index of the given type (or
/// -1 if that type is not in the list).
template <typename T>
using IndexOf = std::integral_constant<vtkm::IdComponent,
vtkm::ListIndexOf<vtkm::ListTagBase<Ts...>, T>::value>;
using IndexOf =
std::integral_constant<vtkm::IdComponent, vtkm::ListIndexOf<vtkm::List<Ts...>, T>::value>;
/// Returns the index for the given type (or -1 if that type is not in the list).
///
@ -498,8 +499,18 @@ public:
/// \brief Convert a ListTag to a Variant.
///
/// Depricated. Use ListAsVariant instead.
///
template <typename ListTag>
using ListTagAsVariant = typename vtkm::ListTagApply<ListTag, vtkm::internal::Variant>::type;
using ListTagAsVariant VTKM_DEPRECATED(
1.6,
"vtkm::ListTag is no longer supported. Use vtkm::List instead.") =
vtkm::ListApply<ListTag, vtkm::internal::Variant>;
/// \brief Convert a `List` to a `Variant`.
///
template <typename List>
using ListAsVariant = vtkm::ListApply<List, vtkm::internal::Variant>;
}
} // namespace vtkm::internal

8
vtkm/testing/Testing.h
View File

@ -404,15 +404,13 @@ public:
vtkm::ListForEach(InternalPrintTypeAndInvoke<FunctionType>(function), TypeList());
}
struct TypeListTagExemplarTypes
: vtkm::ListTagBase<vtkm::UInt8, vtkm::Id, vtkm::FloatDefault, vtkm::Vec3f_64>
{
};
using TypeListExemplarTypes =
vtkm::List<vtkm::UInt8, vtkm::Id, vtkm::FloatDefault, vtkm::Vec3f_64>;
template <typename FunctionType>
static void TryTypes(const FunctionType& function)
{
TryTypes(function, TypeListTagExemplarTypes());
TryTypes(function, TypeListExemplarTypes());
}
// Disabled: This very long list results is very long compile times.

15
vtkm/testing/TestingMath.h
View File

@ -742,12 +742,9 @@ struct TryAbsTests
}
};
struct TypeListTagAbs
: vtkm::ListTagJoin<
vtkm::ListTagJoin<vtkm::ListTagBase<vtkm::Int32, vtkm::Int64>, vtkm::TypeListTagIndex>,
vtkm::TypeListTagField>
{
};
using TypeListAbs = vtkm::ListAppend<vtkm::List<vtkm::Int32, vtkm::Int64>,
vtkm::TypeListTagIndex,
vtkm::TypeListTagField>;
//-----------------------------------------------------------------------------
static constexpr vtkm::Id BitOpSamples = 1024 * 1024;
@ -817,7 +814,7 @@ struct TryBitOpTests
}
};
using TypeListTagBitOp = vtkm::ListTagBase<vtkm::UInt32, vtkm::UInt64>;
using TypeListBitOp = vtkm::List<vtkm::UInt32, vtkm::UInt64>;
//-----------------------------------------------------------------------------
template <typename Device>
@ -830,9 +827,9 @@ void RunMathTests()
std::cout << "Test for exemplar types." << std::endl;
vtkm::testing::Testing::TryTypes(TryAllTypesTests<Device>());
std::cout << "Test all Abs types" << std::endl;
vtkm::testing::Testing::TryTypes(TryAbsTests<Device>(), TypeListTagAbs());
vtkm::testing::Testing::TryTypes(TryAbsTests<Device>(), TypeListAbs());
std::cout << "Test all bit operations" << std::endl;
vtkm::testing::Testing::TryTypes(TryBitOpTests<Device>(), TypeListTagBitOp());
vtkm::testing::Testing::TryTypes(TryBitOpTests<Device>(), TypeListBitOp());
}
} // namespace UnitTestMathNamespace

8
vtkm/testing/UnitTestListTag.cxx
View File

@ -8,6 +8,12 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
// ListTag has been depricated. Until it is officially removed, we continue to test it, but
// disable the deprecated warnings while doing so. Once ListTag is officially removed,
// this entire test can be deleted.
#include <vtkm/Deprecated.h>
VTKM_DEPRECATED_SUPPRESS_BEGIN
#include <vtkm/ListTag.h>
#include <vtkm/Types.h>
@ -297,3 +303,5 @@ int UnitTestListTag(int argc, char* argv[])
{
return vtkm::testing::Testing::Run(TestLists, argc, argv);
}
VTKM_DEPRECATED_SUPPRESS_END

22
vtkm/testing/UnitTestTypes.cxx
View File

@ -860,18 +860,16 @@ struct TypeTestFunctor
}
};
struct TypesToTest : vtkm::ListTagJoin<vtkm::testing::Testing::TypeListTagExemplarTypes,
vtkm::ListTagBase<vtkm::Vec<vtkm::FloatDefault, 6>,
vtkm::Id4,
vtkm::Vec<unsigned char, 4>,
vtkm::Vec<vtkm::Id, 1>,
vtkm::Id2,
vtkm::Vec<vtkm::Float64, 1>,
vtkm::Vec<vtkm::Id2, 3>,
vtkm::Vec<vtkm::Vec2f_32, 3>,
vtkm::Vec<vtkm::Vec2f_32, 5>>>
{
};
using TypesToTest = vtkm::ListAppend<vtkm::testing::Testing::TypeListExemplarTypes,
vtkm::List<vtkm::Vec<vtkm::FloatDefault, 6>,
vtkm::Id4,
vtkm::Vec<unsigned char, 4>,
vtkm::Vec<vtkm::Id, 1>,
vtkm::Id2,
vtkm::Vec<vtkm::Float64, 1>,
vtkm::Vec<vtkm::Id2, 3>,
vtkm::Vec<vtkm::Vec2f_32, 3>,
vtkm::Vec<vtkm::Vec2f_32, 5>>>;
void TestTypes()
{

22
vtkm/worklet/CellMeasure.h
View File

@ -33,18 +33,10 @@ struct IntegrateOverSolid : IntegrateOver
};
// Lists of acceptable types of integration
struct ArcLength : vtkm::ListTagBase<IntegrateOverCurve>
{
};
struct Area : vtkm::ListTagBase<IntegrateOverSurface>
{
};
struct Volume : vtkm::ListTagBase<IntegrateOverSolid>
{
};
struct AllMeasures : vtkm::ListTagBase<IntegrateOverSolid, IntegrateOverSurface, IntegrateOverCurve>
{
};
using ArcLength = vtkm::List<IntegrateOverCurve>;
using Area = vtkm::List<IntegrateOverSurface>;
using Volume = vtkm::List<IntegrateOverSolid>;
using AllMeasures = vtkm::List<IntegrateOverSolid, IntegrateOverSurface, IntegrateOverCurve>;
namespace worklet
{
@ -105,19 +97,19 @@ protected:
// Fall through to return 0 measure.
break;
case 1:
if (vtkm::ListContains<IntegrationTypeList, IntegrateOverCurve>::value)
if (vtkm::ListHas<IntegrationTypeList, IntegrateOverCurve>::value)
{
return vtkm::exec::CellMeasure<OutType>(numPts, pts, CellShapeType(), *this);
}
break;
case 2:
if (vtkm::ListContains<IntegrationTypeList, IntegrateOverSurface>::value)
if (vtkm::ListHas<IntegrationTypeList, IntegrateOverSurface>::value)
{
return vtkm::exec::CellMeasure<OutType>(numPts, pts, CellShapeType(), *this);
}
break;
case 3:
if (vtkm::ListContains<IntegrationTypeList, IntegrateOverSolid>::value)
if (vtkm::ListHas<IntegrationTypeList, IntegrateOverSolid>::value)
{
return vtkm::exec::CellMeasure<OutType>(numPts, pts, CellShapeType(), *this);
}

8
vtkm/worklet/testing/UnitTestOrientNormals.cxx
View File

@ -50,10 +50,10 @@ namespace
struct TestPolicy : public vtkm::filter::PolicyBase<TestPolicy>
{
using StructuredCellSetList = vtkm::ListTagBase<vtkm::cont::CellSetStructured<3>>;
using UnstructuredCellSetList = vtkm::ListTagBase<vtkm::cont::CellSetSingleType<>>;
using AllCellSetList = vtkm::ListTagJoin<StructuredCellSetList, UnstructuredCellSetList>;
using FieldTypeList = vtkm::ListTagBase<vtkm::FloatDefault, vtkm::Vec<vtkm::FloatDefault, 3>>;
using StructuredCellSetList = vtkm::List<vtkm::cont::CellSetStructured<3>>;
using UnstructuredCellSetList = vtkm::List<vtkm::cont::CellSetSingleType<>>;
using AllCellSetList = vtkm::ListAppend<StructuredCellSetList, UnstructuredCellSetList>;
using FieldTypeList = vtkm::List<vtkm::FloatDefault, vtkm::Vec<vtkm::FloatDefault, 3>>;
};
VTKM_CONT