Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 18:45:43 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
557055b9cc
vtk-m/vtkm/testing/UnitTestTypeListTag.cxx

305 lines
9.3 KiB
C++
Raw Normal View History

Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
Remove instances of ListTag in favor of List
2019-12-07 04:32:36 +00:00
// This tests deprecated code until it is deleted.
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
#include <vtkm/TypeListTag.h>
#include <vtkm/Types.h>
#include <vtkm/testing/Testing.h>
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
#include <set>
#include <string>
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
Update lists in TypeListTag.h A new header named TypeList.h and the type lists have been redefined in this new file. All the types have been renamed from `TypeListTag*` to `TypeList*`. TypeListTag.h has been gutted to provide deprecated versions of the old type list names. There were also some other type lists that were changed from using the old `ListTagBase` to the new `List`.
2019-12-05 17:55:57 +00:00
VTKM_DEPRECATED_SUPPRESS_BEGIN
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace
{
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
class TypeSet
{
vtkm prefers 'using' over typedef.
2018-02-22 13:29:13 +00:00
using NameSetType = std::set<std::string>;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
NameSetType NameSet;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
public:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
void AddExpected(T)
{
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
this->NameSet.insert(vtkm::testing::TypeName<T>::Name());
}
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
void Found(T)
{
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
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.");
}
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
void CheckFound()
{
for (NameSetType::iterator typeP = this->NameSet.begin(); typeP != this->NameSet.end(); typeP++)
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
{
std::cout << "**** Failed to find " << *typeP << std::endl;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_ASSERT(this->NameSet.empty(), "List did not call functor on all expected types.");
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
}
};
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
struct TestFunctor
{
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet ExpectedTypes;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
TestFunctor(const TypeSet& expectedTypes)
: ExpectedTypes(expectedTypes)
{
}
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
VTKM_CONT void operator()(T)
{
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
this->ExpectedTypes.Found(T());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ListTag>
void TryList(const TypeSet& expected, ListTag)
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
{
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TestFunctor functor(expected);
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
vtkm::ListForEach(functor, ListTag());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
functor.ExpectedTypes.CheckFound();
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
}
void TestLists()
{
std::cout << "TypeListTagId" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet id;
id.AddExpected(vtkm::Id());
TryList(id, vtkm::TypeListTagId());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
std::cout << "TypeListTagId2" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet id2;
id2.AddExpected(vtkm::Id2());
TryList(id2, vtkm::TypeListTagId2());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
std::cout << "TypeListTagId3" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet id3;
id3.AddExpected(vtkm::Id3());
TryList(id3, vtkm::TypeListTagId3());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
std::cout << "TypeListTagIndex" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet index;
index.AddExpected(vtkm::Id());
index.AddExpected(vtkm::Id2());
index.AddExpected(vtkm::Id3());
TryList(index, vtkm::TypeListTagIndex());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
std::cout << "TypeListTagFieldScalar" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet scalar;
scalar.AddExpected(vtkm::Float32());
scalar.AddExpected(vtkm::Float64());
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
TryList(scalar, vtkm::TypeListTagFieldScalar());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
std::cout << "TypeListTagFieldVec2" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet vec2;
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
vec2.AddExpected(vtkm::Vec2f_32());
vec2.AddExpected(vtkm::Vec2f_64());
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
TryList(vec2, vtkm::TypeListTagFieldVec2());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
std::cout << "TypeListTagFieldVec3" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet vec3;
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
vec3.AddExpected(vtkm::Vec3f_32());
vec3.AddExpected(vtkm::Vec3f_64());
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
TryList(vec3, vtkm::TypeListTagFieldVec3());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
std::cout << "TypeListTagFieldVec4" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet vec4;
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
vec4.AddExpected(vtkm::Vec4f_32());
vec4.AddExpected(vtkm::Vec4f_64());
Rename some type lists to be a bit more consistent.
2014-10-10 15:53:13 +00:00
TryList(vec4, vtkm::TypeListTagFieldVec4());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
std::cout << "TypeListTagField" << std::endl;
TypeSet field;
field.AddExpected(vtkm::Float32());
field.AddExpected(vtkm::Float64());
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
field.AddExpected(vtkm::Vec2f_32());
field.AddExpected(vtkm::Vec2f_64());
field.AddExpected(vtkm::Vec3f_32());
field.AddExpected(vtkm::Vec3f_64());
field.AddExpected(vtkm::Vec4f_32());
field.AddExpected(vtkm::Vec4f_64());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TryList(field, vtkm::TypeListTagField());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
std::cout << "TypeListTagCommon" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TypeSet common;
common.AddExpected(vtkm::Float32());
common.AddExpected(vtkm::Float64());
Add vtkm::Uint8 to default type test.
2019-03-01 15:41:55 +00:00
common.AddExpected(vtkm::UInt8());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
common.AddExpected(vtkm::Int32());
common.AddExpected(vtkm::Int64());
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
common.AddExpected(vtkm::Vec3f_32());
common.AddExpected(vtkm::Vec3f_64());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TryList(common, vtkm::TypeListTagCommon());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
TypeListTagAll should really have all basic types. The previous commits had TypeListTagAll containing a subset of Vec types. This commit adds all possible vectors with 2 to 4 components containing one of the basic C types.
2014-10-09 21:04:52 +00:00
std::cout << "TypeListTagScalarAll" << std::endl;
TypeSet scalarsAll;
scalarsAll.AddExpected(vtkm::Float32());
scalarsAll.AddExpected(vtkm::Float64());
scalarsAll.AddExpected(vtkm::Int8());
scalarsAll.AddExpected(vtkm::UInt8());
scalarsAll.AddExpected(vtkm::Int16());
scalarsAll.AddExpected(vtkm::UInt16());
scalarsAll.AddExpected(vtkm::Int32());
scalarsAll.AddExpected(vtkm::UInt32());
scalarsAll.AddExpected(vtkm::Int64());
scalarsAll.AddExpected(vtkm::UInt64());
TryList(scalarsAll, vtkm::TypeListTagScalarAll());
Enable reinterpreting `UnknownArrayHandle` to compatible C types The base C types have several "duplicate" types that the compiler considers different even though the byte representation is the same. For example, `char` and `signed char` have the same meaning but are treated as different types. Likewise, 'long', 'int', and 'long long' are all different types even though 'long' is the same as either 'int' or 'long long'. When pulling extracted components from `UnknownArrayHandle`, there is little value for creating multiple code paths for types like `char` and `signed char`. Instead, allow implicit conversion among these types.
2021-01-04 23:36:03 +00:00
std::cout << "TypeListBaseC" << std::endl;
TypeSet baseC;
baseC.AddExpected(vtkm::Float32());
baseC.AddExpected(vtkm::Float64());
baseC.AddExpected(vtkm::Int8());
baseC.AddExpected(vtkm::UInt8());
baseC.AddExpected(vtkm::Int16());
baseC.AddExpected(vtkm::UInt16());
baseC.AddExpected(vtkm::Int32());
baseC.AddExpected(vtkm::UInt32());
baseC.AddExpected(vtkm::Int64());
baseC.AddExpected(vtkm::UInt64());
// Extra types with same layout as above but considered different by C
baseC.AddExpected(bool());
baseC.AddExpected(char());
baseC.AddExpected((signed int)0);
baseC.AddExpected((unsigned int)0);
baseC.AddExpected((signed long)0);
baseC.AddExpected((unsigned long)0);
baseC.AddExpected((signed long long)0);
baseC.AddExpected((unsigned long long)0);
TryList(baseC, vtkm::TypeListBaseC());
TypeListTagAll should really have all basic types. The previous commits had TypeListTagAll containing a subset of Vec types. This commit adds all possible vectors with 2 to 4 components containing one of the basic C types.
2014-10-09 21:04:52 +00:00
std::cout << "TypeListTagVecCommon" << std::endl;
TypeSet vecCommon;
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
vecCommon.AddExpected(vtkm::Vec2f_32());
vecCommon.AddExpected(vtkm::Vec2f_64());
vecCommon.AddExpected(vtkm::Vec2ui_8());
vecCommon.AddExpected(vtkm::Vec2i_32());
vecCommon.AddExpected(vtkm::Vec2i_64());
vecCommon.AddExpected(vtkm::Vec3f_32());
vecCommon.AddExpected(vtkm::Vec3f_64());
vecCommon.AddExpected(vtkm::Vec3ui_8());
vecCommon.AddExpected(vtkm::Vec3i_32());
vecCommon.AddExpected(vtkm::Vec3i_64());
vecCommon.AddExpected(vtkm::Vec4f_32());
vecCommon.AddExpected(vtkm::Vec4f_64());
vecCommon.AddExpected(vtkm::Vec4ui_8());
vecCommon.AddExpected(vtkm::Vec4i_32());
vecCommon.AddExpected(vtkm::Vec4i_64());
TypeListTagAll should really have all basic types. The previous commits had TypeListTagAll containing a subset of Vec types. This commit adds all possible vectors with 2 to 4 components containing one of the basic C types.
2014-10-09 21:04:52 +00:00
TryList(vecCommon, vtkm::TypeListTagVecCommon());
std::cout << "TypeListTagVecAll" << std::endl;
TypeSet vecAll;
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
vecAll.AddExpected(vtkm::Vec2f_32());
vecAll.AddExpected(vtkm::Vec2f_64());
vecAll.AddExpected(vtkm::Vec2i_8());
vecAll.AddExpected(vtkm::Vec2i_16());
vecAll.AddExpected(vtkm::Vec2i_32());
vecAll.AddExpected(vtkm::Vec2i_64());
vecAll.AddExpected(vtkm::Vec2ui_8());
vecAll.AddExpected(vtkm::Vec2ui_16());
vecAll.AddExpected(vtkm::Vec2ui_32());
vecAll.AddExpected(vtkm::Vec2ui_64());
vecAll.AddExpected(vtkm::Vec3f_32());
vecAll.AddExpected(vtkm::Vec3f_64());
vecAll.AddExpected(vtkm::Vec3i_8());
vecAll.AddExpected(vtkm::Vec3i_16());
vecAll.AddExpected(vtkm::Vec3i_32());
vecAll.AddExpected(vtkm::Vec3i_64());
vecAll.AddExpected(vtkm::Vec3ui_8());
vecAll.AddExpected(vtkm::Vec3ui_16());
vecAll.AddExpected(vtkm::Vec3ui_32());
vecAll.AddExpected(vtkm::Vec3ui_64());
vecAll.AddExpected(vtkm::Vec4f_32());
vecAll.AddExpected(vtkm::Vec4f_64());
vecAll.AddExpected(vtkm::Vec4i_8());
vecAll.AddExpected(vtkm::Vec4i_16());
vecAll.AddExpected(vtkm::Vec4i_32());
vecAll.AddExpected(vtkm::Vec4i_64());
vecAll.AddExpected(vtkm::Vec4ui_8());
vecAll.AddExpected(vtkm::Vec4ui_16());
vecAll.AddExpected(vtkm::Vec4ui_32());
vecAll.AddExpected(vtkm::Vec4ui_64());
TypeListTagAll should really have all basic types. The previous commits had TypeListTagAll containing a subset of Vec types. This commit adds all possible vectors with 2 to 4 components containing one of the basic C types.
2014-10-09 21:04:52 +00:00
TryList(vecAll, vtkm::TypeListTagVecAll());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
std::cout << "TypeListTagAll" << std::endl;
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
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());
Update VTK-m code to use new Vec aliases Should make the code easier to read.
2019-07-31 16:20:38 +00:00
all.AddExpected(vtkm::Vec2f_32());
all.AddExpected(vtkm::Vec2f_64());
all.AddExpected(vtkm::Vec2i_8());
all.AddExpected(vtkm::Vec2i_16());
all.AddExpected(vtkm::Vec2i_32());
all.AddExpected(vtkm::Vec2i_64());
all.AddExpected(vtkm::Vec2ui_8());
all.AddExpected(vtkm::Vec2ui_16());
all.AddExpected(vtkm::Vec2ui_32());
all.AddExpected(vtkm::Vec2ui_64());
all.AddExpected(vtkm::Vec3f_32());
all.AddExpected(vtkm::Vec3f_64());
all.AddExpected(vtkm::Vec3i_8());
all.AddExpected(vtkm::Vec3i_16());
all.AddExpected(vtkm::Vec3i_32());
all.AddExpected(vtkm::Vec3i_64());
all.AddExpected(vtkm::Vec3ui_8());
all.AddExpected(vtkm::Vec3ui_16());
all.AddExpected(vtkm::Vec3ui_32());
all.AddExpected(vtkm::Vec3ui_64());
all.AddExpected(vtkm::Vec4f_32());
all.AddExpected(vtkm::Vec4f_64());
all.AddExpected(vtkm::Vec4i_8());
all.AddExpected(vtkm::Vec4i_16());
all.AddExpected(vtkm::Vec4i_32());
all.AddExpected(vtkm::Vec4i_64());
all.AddExpected(vtkm::Vec4ui_8());
all.AddExpected(vtkm::Vec4ui_16());
all.AddExpected(vtkm::Vec4ui_32());
all.AddExpected(vtkm::Vec4ui_64());
Expand the list of types to include multiple widths. 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.
2014-10-08 21:40:20 +00:00
TryList(all, vtkm::TypeListTagAll());
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
}
} // anonymous namespace
Testing run methods now take argc/argv to init logging/runtime device `vtkm::cont::testing` now initializes with logging enabled and support for device being passed on the command line, `vtkm::testing` only enables logging.
2019-01-01 22:19:02 +00:00
int UnitTestTypeListTag(int argc, char* argv[])
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
{
Testing run methods now take argc/argv to init logging/runtime device `vtkm::cont::testing` now initializes with logging enabled and support for device being passed on the command line, `vtkm::testing` only enables logging.
2019-01-01 22:19:02 +00:00
return vtkm::testing::Testing::Run(TestLists, argc, argv);
Add tag-based type list templates Provies a list of types in a template like boost::mpl::vector and a method to call a functor on each type. However, rather than explicitly list each type, uses tags to identify the list. This provides the following main advantages: 1. Can use these type lists without creating horrendously long class names based on them, making compiler errors easier to read. For example, you would have a typename like MyClass<TypeListTagVectors> instead of MyClass<TypeList<Id3,Vector2,Vector3,Vector4> > (or worse if variadic templates are not supported). This is the main motivation for this implementation. 2. Do not require variadic templates and usually few constructions. That should speed compile times. There is one main disadvantage to this approach: It is difficult to get a printed list of items in a list during an error. If necessary, it probably would not be too hard to make a template to convert a tag to a boost mpl vector.
2014-03-31 21:28:09 +00:00
}
Update lists in TypeListTag.h A new header named TypeList.h and the type lists have been redefined in this new file. All the types have been renamed from `TypeListTag*` to `TypeList*`. TypeListTag.h has been gutted to provide deprecated versions of the old type list names. There were also some other type lists that were changed from using the old `ListTagBase` to the new `List`.
2019-12-05 17:55:57 +00:00
VTKM_DEPRECATED_SUPPRESS_END
Reference in New Issue Copy Permalink