Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Expand the list of types to include multiple widths.

Browse Source 
Since we want our code to generally handle data of different precision
(for example either float or double) expand the types in our list types
to include multiple precision.
This commit is contained in:
Kenneth Moreland 2014-10-08 15:40:20 -06:00
parent b2298172ee
commit 0cc9d27e26
11 changed files with 1917 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
vtkm/TypeListTag.h
View File

@ -29,34 +29,107 @@
namespace vtkm {
/// A list containing the type vtkm::Id.
///
struct TypeListTagId : vtkm::ListTagBase<vtkm::Id> { };
struct TypeListTagId2 : vtkm::ListTagBase<vtkm::Id2> { };
struct TypeListTagId3 : vtkm::ListTagBase<vtkm::Id3> { };
struct TypeListTagScalar : vtkm::ListTagBase<vtkm::Scalar> { };
struct TypeListTagVector2 : vtkm::ListTagBase<vtkm::Vector2> { };
struct TypeListTagVector3 : vtkm::ListTagBase<vtkm::Vector3> { };
struct TypeListTagVector4 : vtkm::ListTagBase<vtkm::Vector4> { };
/// A list containing the type vtkm::Id2.
///
struct TypeListTagId2 : vtkm::ListTagBase<vtkm::Id2> { };
/// A list containing the type vtkm::Id3.
///
struct TypeListTagId3 : vtkm::ListTagBase<vtkm::Id3> { };
/// A list containing types used to index arrays. Contains vtkm::Id, vtkm::Id2,
/// and vtkm::Id3.
///
struct TypeListTagIndex
: vtkm::ListTagBase<vtkm::Id,vtkm::Id2,vtkm::Id3> { };
struct TypeListTagReal
: vtkm::ListTagBase<vtkm::Scalar,vtkm::Vector2,vtkm::Vector3,vtkm::Vector4>
{ };
/// A list containing types used for scalar fields. Specifically, contains
/// floating point numbers of different widths (i.e. vtkm::Float32 and
/// vtkm::Float64).
struct TypeListTagScalar : vtkm::ListTagBase<vtkm::Float32,vtkm::Float64> { };
/// A list containing types for values for fields with two dimensional
/// vectors.
///
struct TypeListTagVec2
: vtkm::ListTagBase<vtkm::Vec<vtkm::Float32,2>,
vtkm::Vec<vtkm::Float64,2> > { };
/// A list containing types for values for fields with three dimensional
/// vectors.
///
struct TypeListTagVec3
: vtkm::ListTagBase<vtkm::Vec<vtkm::Float32,3>,
vtkm::Vec<vtkm::Float64,3> > { };
/// A list containing types for values for fields with four dimensional
/// vectors.
///
struct TypeListTagVec4
: vtkm::ListTagBase<vtkm::Vec<vtkm::Float32,4>,
vtkm::Vec<vtkm::Float64,4> > { };
/// A list containing common types for values in fields. Specifically contains
/// floating point scalars and vectors of size 2, 3, and 4 with floating point
/// components.
///
struct TypeListTagField
: vtkm::ListTagBase<vtkm::Float32,
vtkm::Float64,
vtkm::Vec<vtkm::Float32,2>,
vtkm::Vec<vtkm::Float64,2>,
vtkm::Vec<vtkm::Float32,3>,
vtkm::Vec<vtkm::Float64,3>,
vtkm::Vec<vtkm::Float32,4>,
vtkm::Vec<vtkm::Float64,4> >
{ };
/// A list of all basic types listed in vtkm/Types.h. Does not include all
/// possible VTK-m types like arbitrarily typed and sized tuples or math
/// types like matrices.
///
struct TypeListTagAll
: vtkm::ListTagJoin<vtkm::TypeListTagIndex, vtkm::TypeListTagReal>
{ };
: vtkm::ListTagBase<vtkm::Int8,
vtkm::UInt8,
vtkm::Int16,
vtkm::UInt16,
vtkm::Int32,
vtkm::UInt32,
vtkm::Int64,
vtkm::UInt64,
vtkm::Float32,
vtkm::Float64,
vtkm::Vec<vtkm::Int8,2>,
vtkm::Vec<vtkm::Int32,2>,
vtkm::Vec<vtkm::Int64,2>,
vtkm::Vec<vtkm::Float32,2>,
vtkm::Vec<vtkm::Float64,2>,
vtkm::Vec<vtkm::Int8,3>,
vtkm::Vec<vtkm::Int32,3>,
vtkm::Vec<vtkm::Int64,3>,
vtkm::Vec<vtkm::Float32,3>,
vtkm::Vec<vtkm::Float64,3>,
vtkm::Vec<vtkm::Int8,4>,
vtkm::Vec<vtkm::Int32,4>,
vtkm::Vec<vtkm::Int64,4>,
vtkm::Vec<vtkm::Float32,4>,
vtkm::Vec<vtkm::Float64,4> >
{ };
/// A list of the most commonly used types across multiple domains. Includes
/// Id, Scalar, and Vector3.
/// integers, floating points, and 3 dimensional vectors of floating points.
///
struct TypeListTagCommon
: vtkm::ListTagBase<vtkm::Id, vtkm::Scalar, vtkm::Vector3>
: vtkm::ListTagBase<vtkm::Int32,
vtkm::Int64,
vtkm::Float32,
vtkm::Float64,
vtkm::Vec<vtkm::Float32,3>,
vtkm::Vec<vtkm::Float64,3> >
{ };
} // namespace vtkm

27
vtkm/TypeTraits.h
View File

@ -97,23 +97,16 @@ struct TypeTraits<const T> : TypeTraits<T>
/// Traits for basic C++ types.
///
VTKM_BASIC_REAL_TYPE(float);
VTKM_BASIC_REAL_TYPE(double);
VTKM_BASIC_INTEGER_TYPE(char);
VTKM_BASIC_INTEGER_TYPE(unsigned char);
VTKM_BASIC_INTEGER_TYPE(short);
VTKM_BASIC_INTEGER_TYPE(unsigned short);
VTKM_BASIC_INTEGER_TYPE(int);
VTKM_BASIC_INTEGER_TYPE(unsigned int);
#if VTKM_SIZE_LONG == 8
VTKM_BASIC_INTEGER_TYPE(long);
VTKM_BASIC_INTEGER_TYPE(unsigned long);
#elif VTKM_SIZE_LONG_LONG == 8
VTKM_BASIC_INTEGER_TYPE(long long);
VTKM_BASIC_INTEGER_TYPE(unsigned long long);
#else
#error No implementation for 64-bit integer traits.
#endif
VTKM_BASIC_REAL_TYPE(vtkm::Float32);
VTKM_BASIC_REAL_TYPE(vtkm::Float64);
VTKM_BASIC_INTEGER_TYPE(vtkm::Int8);
VTKM_BASIC_INTEGER_TYPE(vtkm::UInt8);
VTKM_BASIC_INTEGER_TYPE(vtkm::Int16);
VTKM_BASIC_INTEGER_TYPE(vtkm::UInt16);
VTKM_BASIC_INTEGER_TYPE(vtkm::Int32);
VTKM_BASIC_INTEGER_TYPE(vtkm::UInt32);
VTKM_BASIC_INTEGER_TYPE(vtkm::Int64);
VTKM_BASIC_INTEGER_TYPE(vtkm::UInt64);
#undef VTKM_BASIC_REAL_TYPE
#undef VTKM_BASIC_INTEGER_TYPE

24
vtkm/Types.h
View File

@ -733,8 +733,9 @@ protected:
vtkm::internal::VecCopy<NUM_COMPONENTS>()(this->Components, values);
}
template<typename OtherValueType, typename OtherDerivedType>
VTKM_EXEC_CONT_EXPORT
VecBase(const DerivedClass &src)
VecBase(const VecBase<OtherValueType,Size,OtherDerivedType> &src)
{
vtkm::internal::VecCopy<NUM_COMPONENTS>()(this->Components, src);
}
@ -967,7 +968,10 @@ public:
VTKM_EXEC_CONT_EXPORT Vec() {}
VTKM_EXEC_CONT_EXPORT explicit Vec(const T& value) : Superclass(value) { }
VTKM_EXEC_CONT_EXPORT explicit Vec(const T* values) : Superclass(values) { }
VTKM_EXEC_CONT_EXPORT Vec(const Vec<T, Size> &src) : Superclass(src) { }
template<typename OtherType>
VTKM_EXEC_CONT_EXPORT
Vec(const Vec<OtherType, Size> &src) : Superclass(src) { }
};
//-----------------------------------------------------------------------------
@ -986,7 +990,9 @@ public:
VTKM_EXEC_CONT_EXPORT Vec() {}
VTKM_EXEC_CONT_EXPORT explicit Vec(const ComponentType&) { }
VTKM_EXEC_CONT_EXPORT explicit Vec(const ComponentType*) { }
VTKM_EXEC_CONT_EXPORT Vec(const Vec<ComponentType, NUM_COMPONENTS> &) { }
template<typename OtherType>
VTKM_EXEC_CONT_EXPORT Vec(const Vec<OtherType, NUM_COMPONENTS> &) { }
VTKM_EXEC_CONT_EXPORT
Vec<ComponentType, NUM_COMPONENTS> &
@ -1025,7 +1031,9 @@ public:
VTKM_EXEC_CONT_EXPORT Vec() {}
VTKM_EXEC_CONT_EXPORT explicit Vec(const T& value) : Superclass(value) { }
VTKM_EXEC_CONT_EXPORT explicit Vec(const T* values) : Superclass(values) { }
VTKM_EXEC_CONT_EXPORT Vec(const Vec<T, 2> &src) : Superclass(src) { }
template<typename OtherType>
VTKM_EXEC_CONT_EXPORT Vec(const Vec<OtherType, 2> &src) : Superclass(src) { }
VTKM_EXEC_CONT_EXPORT
Vec(const T &x, const T &y)
@ -1050,7 +1058,9 @@ public:
VTKM_EXEC_CONT_EXPORT Vec() {}
VTKM_EXEC_CONT_EXPORT explicit Vec(const T& value) : Superclass(value) { }
VTKM_EXEC_CONT_EXPORT explicit Vec(const T* values) : Superclass(values) { }
VTKM_EXEC_CONT_EXPORT Vec(const Vec<T, 3> &src) : Superclass(src) { }
template<typename OtherType>
VTKM_EXEC_CONT_EXPORT Vec(const Vec<OtherType, 3> &src) : Superclass(src) { }
VTKM_EXEC_CONT_EXPORT
Vec(const T &x, const T &y, const T &z)
@ -1077,7 +1087,9 @@ public:
VTKM_EXEC_CONT_EXPORT Vec() {}
VTKM_EXEC_CONT_EXPORT explicit Vec(const T& value) : Superclass(value) { }
VTKM_EXEC_CONT_EXPORT explicit Vec(const T* values) : Superclass(values) { }
VTKM_EXEC_CONT_EXPORT Vec(const Vec<T, 4> &src) : Superclass(src) { }
template<typename OtherType>
VTKM_EXEC_CONT_EXPORT Vec(const Vec<OtherType, 4> &src) : Superclass(src) { }
VTKM_EXEC_CONT_EXPORT
Vec(const T &x, const T &y, const T &z, const T &w)

2
vtkm/cont/PointCoordinatesArray.h
View File

@ -62,7 +62,7 @@ public:
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TypeList, StorageList) const
{
this->Array.CastAndCall(f, vtkm::TypeListTagVector3(), StorageList());
this->Array.CastAndCall(f, vtkm::TypeListTagVec3(), StorageList());
}
private:

20
vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx
View File

@ -21,6 +21,8 @@
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/TypeTraits.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
@ -35,12 +37,22 @@ namespace {
const vtkm::Id ARRAY_SIZE = 10;
vtkm::Id TestValue(vtkm::Id index, vtkm::Id) {
return index*100;
template<typename T>
T TestValue(vtkm::Id index, T, vtkm::TypeTraitsIntegerTag)
{
return T(index*100);
}
vtkm::Scalar TestValue(vtkm::Id index, vtkm::Scalar) {
return static_cast<vtkm::Scalar>(index)/100;
template<typename T>
T TestValue(vtkm::Id index, T, vtkm::TypeTraitsRealTag)
{
return T(index)/100;
}
template<typename T>
T TestValue(vtkm::Id index, T)
{
return TestValue(index, T(), typename vtkm::TypeTraits<T>::NumericTag());
}
template<typename T, vtkm::IdComponent N>

7
vtkm/cont/testing/UnitTestDynamicPointCoordinates.cxx
View File

@ -54,13 +54,12 @@ struct CheckArray
g_CheckArrayInvocations = 0;
}
template<typename Storage>
void operator()(
const vtkm::cont::ArrayHandle<vtkm::Vector3,Storage> &array) const
template<typename ArrayType>
void operator()(const ArrayType &array) const
{
std::cout << " In CastAndCall functor" << std::endl;
g_CheckArrayInvocations++;
typename vtkm::cont::ArrayHandle<vtkm::Vector3,Storage>::PortalConstControl portal =
typename ArrayType::PortalConstControl portal =
array.GetPortalConstControl();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE,

7
vtkm/cont/testing/UnitTestPointCoordinates.cxx
View File

@ -62,12 +62,11 @@ vtkm::Vector3 TestValue(vtkm::Id index)
struct CheckArray
{
template<typename C>
void operator()(
const vtkm::cont::ArrayHandle<vtkm::Vector3,C> &array) const
template<typename ArrayType>
void operator()(const ArrayType &array) const
{
std::cout << " In CastAndCall functor" << std::endl;
typename vtkm::cont::ArrayHandle<vtkm::Vector3,C>::PortalConstControl portal =
typename ArrayType::PortalConstControl portal =
array.GetPortalConstControl();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE,

1611
vtkm/internal/ListTagDetail.h
View File

File diff suppressed because it is too large Load Diff

2
vtkm/internal/ListTagDetail.h.in
View File

@ -41,7 +41,7 @@ $# Ignore the following comment. It is meant for the generated file.
#include <vtkm/Types.h>
$py(max_base_list=10)\
$py(max_base_list=25)\
#define VTKM_MAX_BASE_LIST $(max_base_list)
$# Python commands used in template expansion.

41
vtkm/testing/Testing.h
View File

@ -24,6 +24,8 @@
#include <vtkm/TypeTraits.h>
#include <vtkm/VecTraits.h>
#include <boost/static_assert.hpp>
#include <iostream>
#include <sstream>
#include <string>
@ -61,6 +63,43 @@
namespace vtkm {
namespace testing {
// If you get an error about this class definition being incomplete, it means
// that you tried to get the name of a type that is not specified. You can
// either not use that type, not try to get the string name, or add it to the
// list.
template<typename T>
struct TypeName;
#define VTK_M_BASIC_TYPE(type) \
template<> struct TypeName<type> { \
static std::string Name() { return #type; } \
} \
VTK_M_BASIC_TYPE(vtkm::Float32);
VTK_M_BASIC_TYPE(vtkm::Float64);
VTK_M_BASIC_TYPE(vtkm::Int8);
VTK_M_BASIC_TYPE(vtkm::UInt8);
VTK_M_BASIC_TYPE(vtkm::Int16);
VTK_M_BASIC_TYPE(vtkm::UInt16);
VTK_M_BASIC_TYPE(vtkm::Int32);
VTK_M_BASIC_TYPE(vtkm::UInt32);
VTK_M_BASIC_TYPE(vtkm::Int64);
VTK_M_BASIC_TYPE(vtkm::UInt64);
template<typename T, vtkm::IdComponent Size>
struct TypeName<vtkm::Vec<T,Size> >
{
static std::string Name() {
std::stringstream stream;
stream << "vtkm::Vec< "
<< TypeName<T>::Name()
<< ", "
<< Size
<< " >";
return stream.str();
}
};
struct Testing
{
public:
@ -334,7 +373,7 @@ bool test_equal(VectorType vector1,
/// Special implementation of test_equal for strings, which don't fit a model
/// of fixed length vectors of numbers.
///
VTKM_EXEC_CONT_EXPORT
VTKM_CONT_EXPORT
bool test_equal(const std::string &string1, const std::string &string2)
{
return string1 == string2;

197
vtkm/testing/UnitTestTypeListTag.cxx
View File

@ -24,104 +24,169 @@
#include <vtkm/testing/Testing.h>
#include <vector>
#include <set>
#include <string>
namespace {
enum TypeId {
ID,
ID2,
ID3,
SCALAR,
VECTOR2,
VECTOR3,
VECTOR4
};
class TypeSet
{
typedef std::set<std::string> NameSetType;
NameSetType NameSet;
public:
template<typename T>
void AddExpected(T) {
this->NameSet.insert(vtkm::testing::TypeName<T>::Name());
}
TypeId GetTypeId(vtkm::Id) { return ID; }
TypeId GetTypeId(vtkm::Id2) { return ID2; }
TypeId GetTypeId(vtkm::Id3) { return ID3; }
TypeId GetTypeId(vtkm::Scalar) { return SCALAR; }
TypeId GetTypeId(vtkm::Vector2) { return VECTOR2; }
TypeId GetTypeId(vtkm::Vector3) { return VECTOR3; }
TypeId GetTypeId(vtkm::Vector4) { return VECTOR4; }
template<typename T>
void Found(T) {
std::string name = vtkm::testing::TypeName<T>::Name();
//std::cout << " found " << name << std::endl;
NameSetType::iterator typeLocation = this->NameSet.find(name);
if (typeLocation != this->NameSet.end())
{
// This type is expected. Remove it to mark it found.
this->NameSet.erase(typeLocation);
}
else
{
std::cout << "**** Did not expect to get type " << name << std::endl;
VTKM_TEST_FAIL("Got unexpected type.");
}
}
void CheckFound() {
for (NameSetType::iterator typeP = this->NameSet.begin();
typeP != this->NameSet.end();
typeP++)
{
std::cout << "**** Failed to find " << *typeP << std::endl;
}
VTKM_TEST_ASSERT(this->NameSet.empty(),
"List did not call functor on all expected types.");
}
};
struct TestFunctor
{
std::vector<TypeId> FoundTypes;
TypeSet ExpectedTypes;
TestFunctor(const TypeSet &expectedTypes) : ExpectedTypes(expectedTypes) { }
template<typename T>
VTKM_CONT_EXPORT
void operator()(T) {
this->FoundTypes.push_back(GetTypeId(T()));
this->ExpectedTypes.Found(T());
}
};
template<vtkm::IdComponent N>
void CheckSame(const vtkm::Vec<TypeId,N> &expected,
const std::vector<TypeId> &found)
template<typename ListTag>
void TryList(const TypeSet &expected, ListTag)
{
VTKM_TEST_ASSERT(static_cast<vtkm::IdComponent>(found.size()) == N,
"Got wrong number of items.");
for (vtkm::IdComponent index = 0; index < N; index++)
{
VTKM_TEST_ASSERT(expected[index] == found[index],
"Got wrong type.");
}
}
template<vtkm::IdComponent N, typename ListTag>
void TryList(const vtkm::Vec<TypeId,N> &expected, ListTag)
{
TestFunctor functor;
TestFunctor functor(expected);
vtkm::ListForEach(functor, ListTag());
CheckSame(expected, functor.FoundTypes);
functor.ExpectedTypes.CheckFound();
}
void TestLists()
{
std::cout << "TypeListTagId" << std::endl;
TryList(vtkm::Vec<TypeId,1>(ID), vtkm::TypeListTagId());
TypeSet id;
id.AddExpected(vtkm::Id());
TryList(id, vtkm::TypeListTagId());
std::cout << "TypeListTagId2" << std::endl;
TryList(vtkm::Vec<TypeId,1>(ID2), vtkm::TypeListTagId2());
TypeSet id2;
id2.AddExpected(vtkm::Id2());
TryList(id2, vtkm::TypeListTagId2());
std::cout << "TypeListTagId3" << std::endl;
TryList(vtkm::Vec<TypeId,1>(ID3), vtkm::TypeListTagId3());
std::cout << "TypeListTagScalar" << std::endl;
TryList(vtkm::Vec<TypeId,1>(SCALAR), vtkm::TypeListTagScalar());
std::cout << "TypeListTagVector2" << std::endl;
TryList(vtkm::Vec<TypeId,1>(VECTOR2), vtkm::TypeListTagVector2());
std::cout << "TypeListTagVector3" << std::endl;
TryList(vtkm::Vec<TypeId,1>(VECTOR3), vtkm::TypeListTagVector3());
std::cout << "TypeListTagVector4" << std::endl;
TryList(vtkm::Vec<TypeId,1>(VECTOR4), vtkm::TypeListTagVector4());
TypeSet id3;
id3.AddExpected(vtkm::Id3());
TryList(id3, vtkm::TypeListTagId3());
std::cout << "TypeListTagIndex" << std::endl;
TryList(vtkm::Vec<TypeId,3>(ID,ID2,ID3), vtkm::TypeListTagIndex());
TypeSet index;
index.AddExpected(vtkm::Id());
index.AddExpected(vtkm::Id2());
index.AddExpected(vtkm::Id3());
TryList(index, vtkm::TypeListTagIndex());
std::cout << "TypeListTagReal" << std::endl;
TryList(vtkm::Vec<TypeId,4>(SCALAR,VECTOR2,VECTOR3,VECTOR4),
vtkm::TypeListTagReal());
std::cout << "TypeListTagScalar" << std::endl;
TypeSet scalar;
scalar.AddExpected(vtkm::Float32());
scalar.AddExpected(vtkm::Float64());
TryList(scalar, vtkm::TypeListTagScalar());
std::cout << "TypeListTagVec2" << std::endl;
TypeSet vec2;
vec2.AddExpected(vtkm::Vec<vtkm::Float32,2>());
vec2.AddExpected(vtkm::Vec<vtkm::Float64,2>());
TryList(vec2, vtkm::TypeListTagVec2());
std::cout << "TypeListTagVec3" << std::endl;
TypeSet vec3;
vec3.AddExpected(vtkm::Vec<vtkm::Float32,3>());
vec3.AddExpected(vtkm::Vec<vtkm::Float64,3>());
TryList(vec3, vtkm::TypeListTagVec3());
std::cout << "TypeListTagVec4" << std::endl;
TypeSet vec4;
vec4.AddExpected(vtkm::Vec<vtkm::Float32,4>());
vec4.AddExpected(vtkm::Vec<vtkm::Float64,4>());
TryList(vec4, vtkm::TypeListTagVec4());
std::cout << "TypeListTagField" << std::endl;
TypeSet field;
field.AddExpected(vtkm::Float32());
field.AddExpected(vtkm::Float64());
field.AddExpected(vtkm::Vec<vtkm::Float32,2>());
field.AddExpected(vtkm::Vec<vtkm::Float64,2>());
field.AddExpected(vtkm::Vec<vtkm::Float32,3>());
field.AddExpected(vtkm::Vec<vtkm::Float64,3>());
field.AddExpected(vtkm::Vec<vtkm::Float32,4>());
field.AddExpected(vtkm::Vec<vtkm::Float64,4>());
TryList(field, vtkm::TypeListTagField());
std::cout << "TypeListTagCommon" << std::endl;
TryList(vtkm::Vec<TypeId,3>(ID,SCALAR,VECTOR3), vtkm::TypeListTagCommon());
TypeSet common;
common.AddExpected(vtkm::Float32());
common.AddExpected(vtkm::Float64());
common.AddExpected(vtkm::Int32());
common.AddExpected(vtkm::Int64());
common.AddExpected(vtkm::Vec<vtkm::Float32,3>());
common.AddExpected(vtkm::Vec<vtkm::Float64,3>());
TryList(common, vtkm::TypeListTagCommon());
std::cout << "TypeListTagAll" << std::endl;
vtkm::Vec<TypeId,7> allTags;
allTags[0] = ID;
allTags[1] = ID2;
allTags[2] = ID3;
allTags[3] = SCALAR;
allTags[4] = VECTOR2;
allTags[5] = VECTOR3;
allTags[6] = VECTOR4;
TryList(allTags, vtkm::TypeListTagAll());
TypeSet all;
all.AddExpected(vtkm::Float32());
all.AddExpected(vtkm::Float64());
all.AddExpected(vtkm::Int8());
all.AddExpected(vtkm::UInt8());
all.AddExpected(vtkm::Int16());
all.AddExpected(vtkm::UInt16());
all.AddExpected(vtkm::Int32());
all.AddExpected(vtkm::UInt32());
all.AddExpected(vtkm::Int64());
all.AddExpected(vtkm::UInt64());
all.AddExpected(vtkm::Vec<vtkm::Float32,2>());
all.AddExpected(vtkm::Vec<vtkm::Float64,2>());
all.AddExpected(vtkm::Vec<vtkm::Int8,2>());
all.AddExpected(vtkm::Vec<vtkm::Int32,2>());
all.AddExpected(vtkm::Vec<vtkm::Int64,2>());
all.AddExpected(vtkm::Vec<vtkm::Float32,3>());
all.AddExpected(vtkm::Vec<vtkm::Float64,3>());
all.AddExpected(vtkm::Vec<vtkm::Int8,3>());
all.AddExpected(vtkm::Vec<vtkm::Int32,3>());
all.AddExpected(vtkm::Vec<vtkm::Int64,3>());
all.AddExpected(vtkm::Vec<vtkm::Float32,4>());
all.AddExpected(vtkm::Vec<vtkm::Float64,4>());
all.AddExpected(vtkm::Vec<vtkm::Int8,4>());
all.AddExpected(vtkm::Vec<vtkm::Int32,4>());
all.AddExpected(vtkm::Vec<vtkm::Int64,4>());
TryList(all, vtkm::TypeListTagAll());
}
} // anonymous namespace