Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-20 02:55:47 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
8deb661409
vtk-m/vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx

429 lines
14 KiB
C++
Raw Normal View History

Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +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.
//
Update copyright for Sandia Sandia National Laboratories recently changed management from the Sandia Corporation to the National Technology & Engineering Solutions of Sandia, LLC (NTESS). The copyright statements need to be updated accordingly.
2017-09-20 21:33:44 +00:00
// Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
// 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 a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
//
Update copyright for Sandia Sandia National Laboratories recently changed management from the Sandia Corporation to the National Technology & Engineering Solutions of Sandia, LLC (NTESS). The copyright statements need to be updated accordingly.
2017-09-20 21:33:44 +00:00
// Under the terms of Contract DE-NA0003525 with NTESS,
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
// 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/cont/DynamicArrayHandle.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 <vtkm/TypeTraits.h>
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
#include <vtkm/cont/ArrayHandleCast.h>
#include <vtkm/cont/ArrayHandleCompositeVector.h>
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandleCounting.h>
Add ArrayHandleGroupVec This is a fancy array handle that groups consecutive entries in a delegate array handle and presents them as a single vec.
2015-09-28 23:19:38 +00:00
#include <vtkm/cont/ArrayHandleGroupVec.h>
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
#include <vtkm/cont/ArrayHandleImplicit.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/ArrayHandleZip.h>
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
#include <vtkm/cont/testing/Testing.h>
#include <sstream>
#include <string>
Make floating point comparison more tolerant in UnitTestDynamicArrayHandle It appears that when the Intel compiler is optimizing, constant floating point values can be slightly different than the same value stored in memory and never changed. This change uses the test_equal method to compare these floating point values that might have a slight numeric error.
2014-07-10 16:53:02 +00:00
#include <typeinfo>
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace vtkm
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
// DynamicArrayHandle requires its value type to have a defined VecTraits
// class. One of the tests is to use an "unusual" array of std::string
// (which is pretty pointless but might tease out some assumptions).
// Make an implementation here. Because I am lazy, this is only a partial
// implementation.
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <>
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
struct VecTraits<std::string>
{
Switch over from static const to static constexpr where possible.
2018-02-27 14:25:25 +00:00
static constexpr vtkm::IdComponent NUM_COMPONENTS = 1;
Use printSummary_ArrayHandle when testing fancy arrays This makes it easier to see what is going on in the fancy arrays and do diagnostics. This change required some changes to printSummary_ArrayHandle to support more array types.
2017-02-15 00:14:29 +00:00
using HasMultipleComponents = vtkm::VecTraitsTagSingleComponent;
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
};
} // namespace vtkm
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace
{
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
const vtkm::Id ARRAY_SIZE = 10;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
struct TypeListTagString : vtkm::ListTagBase<std::string>
{
};
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
struct UnusualPortal
{
Convert VTK-m over to use 'using' instead of 'typedef'
2017-06-23 18:50:34 +00:00
using ValueType = T;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; }
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ValueType Get(vtkm::Id index) const { return TestValue(index, ValueType()); }
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
class ArrayHandleWithUnusualStorage
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
: public vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagImplicit<UnusualPortal<T>>>
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using Superclass = vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagImplicit<UnusualPortal<T>>>;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
public:
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
ArrayHandleWithUnusualStorage()
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
: Superclass(typename Superclass::PortalConstControl())
{
}
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
struct StorageListTagUnusual
: vtkm::ListTagBase<ArrayHandleWithUnusualStorage<vtkm::Id>::StorageTag,
ArrayHandleWithUnusualStorage<std::string>::StorageTag>
{
};
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
struct TestValueFunctor
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
T operator()(vtkm::Id index) const { return TestValue(index, T()); }
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
};
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
struct CheckFunctor
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T, typename Storage>
Update tests and a single worklet to verify new CastAndCall works
2017-11-08 17:16:34 +00:00
void operator()(vtkm::cont::ArrayHandle<T, Storage> array, bool& called) const
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Update tests and a single worklet to verify new CastAndCall works
2017-11-08 17:16:34 +00:00
called = true;
Make floating point comparison more tolerant in UnitTestDynamicArrayHandle It appears that when the Intel compiler is optimizing, constant floating point values can be slightly different than the same value stored in memory and never changed. This change uses the test_equal method to compare these floating point values that might have a slight numeric error.
2014-07-10 16:53:02 +00:00
std::cout << " Checking for type: " << typeid(T).name() << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE, "Unexpected array size.");
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typename vtkm::cont::ArrayHandle<T, Storage>::PortalConstControl portal =
array.GetPortalConstControl();
Unify test values. Lots of tests have to move values in and out of arrays and check them against expected values. It is also often the case that these tests are run on lots of different types. There is some repeated code for generating known values for particular indices. This change unifies some of that. This can probably also encourage making more generic tests.
2014-10-14 16:00:34 +00:00
CheckPortal(portal);
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename TypeList, typename StorageList>
void BasicDynamicArrayChecks(const vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>& array,
vtkm::IdComponent numComponents)
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE,
"Dynamic array reports unexpected size.");
VTKM_TEST_ASSERT(array.GetNumberOfComponents() == numComponents,
"Dynamic array reports unexpected number of components.");
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
void CheckDynamicArray(vtkm::cont::DynamicArrayHandle array, vtkm::IdComponent numComponents)
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
{
BasicDynamicArrayChecks(array, numComponents);
Update tests and a single worklet to verify new CastAndCall works
2017-11-08 17:16:34 +00:00
bool called = false;
array.CastAndCall(CheckFunctor(), called);
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_ASSERT(
Update tests and a single worklet to verify new CastAndCall works
2017-11-08 17:16:34 +00:00
called, "The functor was never called (and apparently a bad value exception not thrown).");
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename TypeList, typename StorageList>
void CheckDynamicArray(vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList> array,
vtkm::IdComponent numComponents)
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
BasicDynamicArrayChecks(array, numComponents);
Update tests and a single worklet to verify new CastAndCall works
2017-11-08 17:16:34 +00:00
bool called = false;
CastAndCall(array, CheckFunctor(), called);
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_ASSERT(
Update tests and a single worklet to verify new CastAndCall works
2017-11-08 17:16:34 +00:00
called, "The functor was never called (and apparently a bad value exception not thrown).");
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
vtkm::cont::DynamicArrayHandle CreateDynamicArray(T)
{
// Declared static to prevent going out of scope.
static T buffer[ARRAY_SIZE];
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
buffer[index] = TestValue(index, T());
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return vtkm::cont::DynamicArrayHandle(vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE));
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType>
void CheckCastToArrayHandle(const ArrayHandleType& array)
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
vtkm::cont::DynamicArrayHandle dynamicArray = array;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_ASSERT(!dynamicArray.IsType<vtkm::cont::ArrayHandle<std::string>>(),
"Dynamic array reporting is wrong type.");
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
ArrayHandleType castArray1;
Simplify and unify cast interface. Previously, DynamicArrayHandle and DynamicCellSet had slightly different interfaces to their CastTo feature. It was a bit confusing and not all that easy to use. This change simplifies and unifies them by making each class have a single CopyTo method that takes a reference to a cast object (an ArrayHandle or CellSet, respectively) and fills that object with the data contained if the cast is successfull. This interface gets around having to declare strange types. Each object also has a Cast method that has to have a template parameter specified and returns a reference of that type (if possible). In addition, the old behavior is preserved for DynamicArrayHandle (but not DynamicCellSet). To avoid confusion, the name of that cast method is CastToTypeStorage. However, the method was chaned to not take parameters to make it consistent with the other Cast method. Also, the IsType methods have been modified to reflect changes in cast/copy. IsType now no longer takes arguments. However, an alternate IsSameType does the same thing but does take an argument.
2016-01-14 19:01:05 +00:00
dynamicArray.CopyTo(castArray1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_ASSERT(dynamicArray.IsSameType(castArray1), "Did not query handle correctly.");
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
VTKM_TEST_ASSERT(array == castArray1, "Did not get back same array.");
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
ArrayHandleType castArray2 =
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
dynamicArray.CastToTypeStorage<typename ArrayHandleType::ValueType,
typename ArrayHandleType::StorageTag>();
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
VTKM_TEST_ASSERT(array == castArray2, "Did not get back same array.");
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T, typename DynamicArrayType>
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
void TryNewInstance(T, DynamicArrayType originalArray)
{
// This check should already have been performed by caller, but just in case.
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(originalArray, vtkm::VecTraits<T>::NUM_COMPONENTS);
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
std::cout << "Create new instance of array." << std::endl;
DynamicArrayType newArray = originalArray.NewInstance();
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::cout << "Get a static instance of the new array (which checks the type)." << std::endl;
Simplify and unify cast interface. Previously, DynamicArrayHandle and DynamicCellSet had slightly different interfaces to their CastTo feature. It was a bit confusing and not all that easy to use. This change simplifies and unifies them by making each class have a single CopyTo method that takes a reference to a cast object (an ArrayHandle or CellSet, respectively) and fills that object with the data contained if the cast is successfull. This interface gets around having to declare strange types. Each object also has a Cast method that has to have a template parameter specified and returns a reference of that type (if possible). In addition, the old behavior is preserved for DynamicArrayHandle (but not DynamicCellSet). To avoid confusion, the name of that cast method is CastToTypeStorage. However, the method was chaned to not take parameters to make it consistent with the other Cast method. Also, the IsType methods have been modified to reflect changes in cast/copy. IsType now no longer takes arguments. However, an alternate IsSameType does the same thing but does take an argument.
2016-01-14 19:01:05 +00:00
vtkm::cont::ArrayHandle<T> staticArray;
newArray.CopyTo(staticArray);
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
std::cout << "Fill the new array with invalid values and make sure the original" << std::endl
<< "is uneffected." << std::endl;
staticArray.Allocate(ARRAY_SIZE);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
staticArray.GetPortalControl().Set(index, TestValue(index + 100, T()));
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
}
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(originalArray, vtkm::VecTraits<T>::NUM_COMPONENTS);
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
std::cout << "Set the new static array to expected values and make sure the new" << std::endl
<< "dynamic array points to the same new values." << std::endl;
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
staticArray.GetPortalControl().Set(index, TestValue(index, T()));
}
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(newArray, vtkm::VecTraits<T>::NUM_COMPONENTS);
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
void TryDefaultType(T)
{
vtkm::cont::DynamicArrayHandle array = CreateDynamicArray(T());
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array, vtkm::VecTraits<T>::NUM_COMPONENTS);
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
TryNewInstance(T(), array);
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
struct TryBasicVTKmType
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
void operator()(T) const
{
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
vtkm::cont::DynamicArrayHandle array = CreateDynamicArray(T());
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array.ResetTypeList(vtkm::TypeListTagAll()),
vtkm::VecTraits<T>::NUM_COMPONENTS);
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
Add NewInstance method to DynamicArrayHandle.
2015-06-16 21:23:50 +00:00
TryNewInstance(T(), array.ResetTypeList(vtkm::TypeListTagAll()));
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
};
void TryUnusualType()
{
// A string is an unlikely type to be declared elsewhere in VTK-m.
vtkm::cont::DynamicArrayHandle array = CreateDynamicArray(std::string());
try
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array, 1);
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type.");
}
Catch all exceptions by reference
2017-02-23 15:13:30 +00:00
catch (vtkm::cont::ErrorBadValue&)
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
std::cout << " Caught exception for unrecognized type." << std::endl;
}
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array.ResetTypeList(TypeListTagString()), 1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::cout << " Found type when type list was reset." << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
void TryUnusualStorage()
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::cont::DynamicArrayHandle array = ArrayHandleWithUnusualStorage<vtkm::Id>();
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
try
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array, 1);
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
Catch all exceptions by reference
2017-02-23 15:13:30 +00:00
catch (vtkm::cont::ErrorBadValue&)
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
std::cout << " Caught exception for unrecognized storage." << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array.ResetStorageList(StorageListTagUnusual()), 1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::cout << " Found instance when storage list was reset." << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
void TryUnusualTypeAndStorage()
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::cont::DynamicArrayHandle array = ArrayHandleWithUnusualStorage<std::string>();
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
try
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array, 1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type/storage.");
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
Catch all exceptions by reference
2017-02-23 15:13:30 +00:00
catch (vtkm::cont::ErrorBadValue&)
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::cout << " Caught exception for unrecognized type/storage." << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
try
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array.ResetTypeList(TypeListTagString()), 1);
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
Catch all exceptions by reference
2017-02-23 15:13:30 +00:00
catch (vtkm::cont::ErrorBadValue&)
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
std::cout << " Caught exception for unrecognized storage." << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
try
{
Add data size introspection to DynamicArrayHandle. Sometimes it is useful to know how big an array held in a DynamicArrayHandle is. This adds two methods to DynamicArrayHandle: GetNumberOfValues and GetNumberOfComponents. They allow you to query the size of the array without having to statically cast to the array itself.
2015-07-08 20:09:36 +00:00
CheckDynamicArray(array.ResetStorageList(StorageListTagUnusual()), 1);
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type.");
}
Catch all exceptions by reference
2017-02-23 15:13:30 +00:00
catch (vtkm::cont::ErrorBadValue&)
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
std::cout << " Caught exception for unrecognized type." << std::endl;
}
Allow resetting the Type and Storage of a DynamicArrayHandle in a single call. vtkm::filter has the use case where we need to reset both the type and storage of an array handle, by doing both at the same time we can reduce the number of temporary objects, and invalid conversions of arrays.
2016-01-04 22:00:08 +00:00
try
{
//resetting the string and tag should result in a valid array handle
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckDynamicArray(array.ResetTypeAndStorageLists(TypeListTagString(), StorageListTagUnusual()),
Allow resetting the Type and Storage of a DynamicArrayHandle in a single call. vtkm::filter has the use case where we need to reset both the type and storage of an array handle, by doing both at the same time we can reduce the number of temporary objects, and invalid conversions of arrays.
2016-01-04 22:00:08 +00:00
1);
}
Catch all exceptions by reference
2017-02-23 15:13:30 +00:00
catch (vtkm::cont::ErrorBadValue&)
Allow resetting the Type and Storage of a DynamicArrayHandle in a single call. vtkm::filter has the use case where we need to reset both the type and storage of an array handle, by doing both at the same time we can reduce the number of temporary objects, and invalid conversions of arrays.
2016-01-04 22:00:08 +00:00
{
VTKM_TEST_FAIL("ResetTypeAndStorageLists should have handled the custom type/storage.");
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckDynamicArray(
array.ResetTypeList(TypeListTagString()).ResetStorageList(StorageListTagUnusual()), 1);
std::cout << " Found instance when type and storage lists were reset." << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckDynamicArray(
array.ResetStorageList(StorageListTagUnusual()).ResetTypeList(TypeListTagString()), 1);
std::cout << " Found instance when storage and type lists were reset." << std::endl;
Allow resetting the Type and Storage of a DynamicArrayHandle in a single call. vtkm::filter has the use case where we need to reset both the type and storage of an array handle, by doing both at the same time we can reduce the number of temporary objects, and invalid conversions of arrays.
2016-01-04 22:00:08 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckDynamicArray(array.ResetTypeAndStorageLists(TypeListTagString(), StorageListTagUnusual()),
Allow resetting the Type and Storage of a DynamicArrayHandle in a single call. vtkm::filter has the use case where we need to reset both the type and storage of an array handle, by doing both at the same time we can reduce the number of temporary objects, and invalid conversions of arrays.
2016-01-04 22:00:08 +00:00
1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::cout << " Found instance when storage and type lists were reset." << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
void TryCastToArrayHandle()
{
std::cout << " Normal array handle." << std::endl;
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
vtkm::Id buffer[ARRAY_SIZE];
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
buffer[index] = TestValue(index, vtkm::Id());
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::cont::ArrayHandle<vtkm::Id> array = vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE);
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
CheckCastToArrayHandle(array);
std::cout << " Cast array handle." << std::endl;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleCast(array, vtkm::FloatDefault()));
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
std::cout << " Composite vector array handle." << std::endl;
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleCompositeVector(array, array));
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
std::cout << " Constant array handle." << std::endl;
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleConstant(5, ARRAY_SIZE));
std::cout << " Counting array handle." << std::endl;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::cont::ArrayHandleCounting<vtkm::Id> countingArray(ARRAY_SIZE - 1, -1, ARRAY_SIZE);
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
CheckCastToArrayHandle(countingArray);
Add ArrayHandleGroupVec This is a fancy array handle that groups consecutive entries in a delegate array handle and presents them as a single vec.
2015-09-28 23:19:38 +00:00
std::cout << " Group vec array handle" << std::endl;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::cont::ArrayHandleGroupVec<vtkm::cont::ArrayHandle<vtkm::Id>, 2> groupVecArray(array);
Add ArrayHandleGroupVec This is a fancy array handle that groups consecutive entries in a delegate array handle and presents them as a single vec.
2015-09-28 23:19:38 +00:00
CheckCastToArrayHandle(groupVecArray);
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
std::cout << " Implicit array handle." << std::endl;
Simplify ArrayHandleImplicit template
2017-05-30 15:13:18 +00:00
CheckCastToArrayHandle(
vtkm::cont::make_ArrayHandleImplicit(TestValueFunctor<vtkm::FloatDefault>(), ARRAY_SIZE));
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
std::cout << " Index array handle." << std::endl;
CheckCastToArrayHandle(vtkm::cont::ArrayHandleIndex(ARRAY_SIZE));
std::cout << " Permutation array handle." << std::endl;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandlePermutation(countingArray, array));
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
std::cout << " Transform array handle." << std::endl;
Simplify ArrayHandleTransform template
2017-05-30 14:00:01 +00:00
CheckCastToArrayHandle(
vtkm::cont::make_ArrayHandleTransform(countingArray, TestValueFunctor<vtkm::FloatDefault>()));
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
std::cout << " Uniform point coordinates array handle." << std::endl;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckCastToArrayHandle(vtkm::cont::ArrayHandleUniformPointCoordinates(vtkm::Id3(ARRAY_SIZE)));
Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles Basically, this entails adding a constructor to each fancy ArrayHandle that accepts the base ArrayHandle with the appropriate type and storage.
2015-09-20 06:28:11 +00:00
std::cout << " Zip array handle." << std::endl;
Add simpler type check for DynamicArrayHandle.
2015-09-20 06:55:54 +00:00
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleZip(countingArray, array));
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
}
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
void TestDynamicArrayHandle()
{
std::cout << "Try common types with default type lists." << std::endl;
Remove vtkm::Scalar and vtkm::Vector# types Providing these types tends to "lock in" the precision of the algorithms used in VTK-m. Since we are using templating anyway, our templates should be generic enough to handle difference precision in the data. Usually the appropriate type can be determined by the data provided. In the case where there is no hint on the precision of data to use (for example, in the code that provides coordinates for uniform data), there is a vtkm::FloatDefault.
2014-10-09 14:54:56 +00:00
std::cout << "*** vtkm::Id **********************" << std::endl;
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
TryDefaultType(vtkm::Id());
Remove vtkm::Scalar and vtkm::Vector# types Providing these types tends to "lock in" the precision of the algorithms used in VTK-m. Since we are using templating anyway, our templates should be generic enough to handle difference precision in the data. Usually the appropriate type can be determined by the data provided. In the case where there is no hint on the precision of data to use (for example, in the code that provides coordinates for uniform data), there is a vtkm::FloatDefault.
2014-10-09 14:54:56 +00:00
std::cout << "*** vtkm::FloatDefault ************" << std::endl;
TryDefaultType(vtkm::FloatDefault());
std::cout << "*** vtkm::Float32 *****************" << std::endl;
TryDefaultType(vtkm::Float32());
std::cout << "*** vtkm::Float64 *****************" << std::endl;
TryDefaultType(vtkm::Float64());
std::cout << "*** vtkm::Vec<Float32,3> **********" << std::endl;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
TryDefaultType(vtkm::Vec<vtkm::Float32, 3>());
Remove vtkm::Scalar and vtkm::Vector# types Providing these types tends to "lock in" the precision of the algorithms used in VTK-m. Since we are using templating anyway, our templates should be generic enough to handle difference precision in the data. Usually the appropriate type can be determined by the data provided. In the case where there is no hint on the precision of data to use (for example, in the code that provides coordinates for uniform data), there is a vtkm::FloatDefault.
2014-10-09 14:54:56 +00:00
std::cout << "*** vtkm::Vec<Float64,3> **********" << std::endl;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
TryDefaultType(vtkm::Vec<vtkm::Float64, 3>());
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
Replace TryAllTypes with trying exemplar tests There were many tests that created code paths for every base and Vec type that VTK-m supports (up to 4 components). Although this is admirable, it is also excessive, and our compile times for the tests are very long. To shorten compile times, remove the TryAllTypes method. Replace it with a version of TryTypes that uses a default list of "exemplar" set of integers, floats, and Vecs.
2016-08-24 22:02:18 +00:00
std::cout << "Try exemplar VTK-m types." << std::endl;
vtkm::testing::Testing::TryTypes(TryBasicVTKmType());
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
std::cout << "Try unusual type." << std::endl;
TryUnusualType();
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
std::cout << "Try unusual storage." << std::endl;
TryUnusualStorage();
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
std::cout << "Try unusual type in unusual storage." << std::endl;
TryUnusualTypeAndStorage();
Add new version of DynamicArrayHandle::CastToArrayHandle This takes a reference to an array handle and fills it. This removes a lot of the pain of determining template arguments.
2015-09-18 04:31:58 +00:00
std::cout << "Try CastToArrayHandle" << std::endl;
TryCastToArrayHandle();
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
}
} // anonymous namespace
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
int UnitTestDynamicArrayHandle(int, char* [])
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
{
return vtkm::cont::testing::Testing::Run(TestDynamicArrayHandle);
}
Reference in New Issue Copy Permalink