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
5f72eb9252
vtk-m/vtkm/testing/UnitTestTypeListTag.cxx

280 lines
9.7 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.
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
The Copyright statement now has all the periods in the correct location.
2015-05-21 12:09:22 +00:00
// Copyright 2014 Los Alamos National Security.
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
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#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
namespace {
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
{
typedef std::set<std::string> NameSetType;
NameSetType NameSet;
public:
template<typename T>
void AddExpected(T) {
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
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
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.");
}
};
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;
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
template<typename T>
VTKM_CONT_EXPORT
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
}
};
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
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;
vec2.AddExpected(vtkm::Vec<vtkm::Float32,2>());
vec2.AddExpected(vtkm::Vec<vtkm::Float64,2>());
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;
vec3.AddExpected(vtkm::Vec<vtkm::Float32,3>());
vec3.AddExpected(vtkm::Vec<vtkm::Float64,3>());
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;
vec4.AddExpected(vtkm::Vec<vtkm::Float32,4>());
vec4.AddExpected(vtkm::Vec<vtkm::Float64,4>());
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());
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());
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());
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());
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());
std::cout << "TypeListTagVecCommon" << std::endl;
TypeSet vecCommon;
vecCommon.AddExpected(vtkm::Vec<vtkm::Float32,2>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Float64,2>());
vecCommon.AddExpected(vtkm::Vec<vtkm::UInt8,2>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Int32,2>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Int64,2>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Float32,3>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Float64,3>());
vecCommon.AddExpected(vtkm::Vec<vtkm::UInt8,3>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Int32,3>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Int64,3>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Float32,4>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Float64,4>());
vecCommon.AddExpected(vtkm::Vec<vtkm::UInt8,4>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Int32,4>());
vecCommon.AddExpected(vtkm::Vec<vtkm::Int64,4>());
TryList(vecCommon, vtkm::TypeListTagVecCommon());
std::cout << "TypeListTagVecAll" << std::endl;
TypeSet vecAll;
vecAll.AddExpected(vtkm::Vec<vtkm::Float32,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::Float64,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int8,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int16,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int32,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int64,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt8,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt16,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt32,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt64,2>());
vecAll.AddExpected(vtkm::Vec<vtkm::Float32,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::Float64,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int8,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int16,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int32,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int64,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt8,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt16,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt32,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt64,3>());
vecAll.AddExpected(vtkm::Vec<vtkm::Float32,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::Float64,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int8,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int16,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int32,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::Int64,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt8,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt16,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt32,4>());
vecAll.AddExpected(vtkm::Vec<vtkm::UInt64,4>());
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());
all.AddExpected(vtkm::Vec<vtkm::Float32,2>());
all.AddExpected(vtkm::Vec<vtkm::Float64,2>());
all.AddExpected(vtkm::Vec<vtkm::Int8,2>());
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
all.AddExpected(vtkm::Vec<vtkm::Int16,2>());
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
all.AddExpected(vtkm::Vec<vtkm::Int32,2>());
all.AddExpected(vtkm::Vec<vtkm::Int64,2>());
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
all.AddExpected(vtkm::Vec<vtkm::UInt8,2>());
all.AddExpected(vtkm::Vec<vtkm::UInt16,2>());
all.AddExpected(vtkm::Vec<vtkm::UInt32,2>());
all.AddExpected(vtkm::Vec<vtkm::UInt64,2>());
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
all.AddExpected(vtkm::Vec<vtkm::Float32,3>());
all.AddExpected(vtkm::Vec<vtkm::Float64,3>());
all.AddExpected(vtkm::Vec<vtkm::Int8,3>());
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
all.AddExpected(vtkm::Vec<vtkm::Int16,3>());
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
all.AddExpected(vtkm::Vec<vtkm::Int32,3>());
all.AddExpected(vtkm::Vec<vtkm::Int64,3>());
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
all.AddExpected(vtkm::Vec<vtkm::UInt8,3>());
all.AddExpected(vtkm::Vec<vtkm::UInt16,3>());
all.AddExpected(vtkm::Vec<vtkm::UInt32,3>());
all.AddExpected(vtkm::Vec<vtkm::UInt64,3>());
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
all.AddExpected(vtkm::Vec<vtkm::Float32,4>());
all.AddExpected(vtkm::Vec<vtkm::Float64,4>());
all.AddExpected(vtkm::Vec<vtkm::Int8,4>());
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
all.AddExpected(vtkm::Vec<vtkm::Int16,4>());
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
all.AddExpected(vtkm::Vec<vtkm::Int32,4>());
all.AddExpected(vtkm::Vec<vtkm::Int64,4>());
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
all.AddExpected(vtkm::Vec<vtkm::UInt8,4>());
all.AddExpected(vtkm::Vec<vtkm::UInt16,4>());
all.AddExpected(vtkm::Vec<vtkm::UInt32,4>());
all.AddExpected(vtkm::Vec<vtkm::UInt64,4>());
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
int UnitTestTypeListTag(int, char *[])
{
return vtkm::testing::Testing::Run(TestLists);
}
Reference in New Issue Copy Permalink