mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-21 03:25:48 +00:00
ed43dad6ca
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.
466 lines
15 KiB
C++
466 lines
15 KiB
C++
//============================================================================
|
|
// 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.
|
|
// Copyright 2014 Los Alamos National Security.
|
|
//
|
|
// 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/cont/DynamicArrayHandle.h>
|
|
|
|
#include <vtkm/TypeTraits.h>
|
|
|
|
#include <vtkm/cont/ArrayHandleCast.h>
|
|
#include <vtkm/cont/ArrayHandleCompositeVector.h>
|
|
#include <vtkm/cont/ArrayHandleConstant.h>
|
|
#include <vtkm/cont/ArrayHandleCounting.h>
|
|
#include <vtkm/cont/ArrayHandleGroupVec.h>
|
|
#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>
|
|
|
|
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
|
|
|
|
#include <vtkm/cont/testing/Testing.h>
|
|
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <typeinfo>
|
|
|
|
namespace vtkm {
|
|
|
|
// 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.
|
|
template<>
|
|
struct VecTraits<std::string>
|
|
{
|
|
static const vtkm::IdComponent NUM_COMPONENTS = 1;
|
|
};
|
|
|
|
} // namespace vtkm
|
|
|
|
namespace {
|
|
|
|
const vtkm::Id ARRAY_SIZE = 10;
|
|
|
|
struct TypeListTagString : vtkm::ListTagBase<std::string> { };
|
|
|
|
template<typename T>
|
|
struct UnusualPortal
|
|
{
|
|
typedef T ValueType;
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; }
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
ValueType Get(vtkm::Id index) const {
|
|
return TestValue(index, ValueType());
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
class ArrayHandleWithUnusualStorage
|
|
: public vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagImplicit<UnusualPortal<T> > >
|
|
{
|
|
typedef vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagImplicit<UnusualPortal<T> > >
|
|
Superclass;
|
|
public:
|
|
VTKM_CONT_EXPORT
|
|
ArrayHandleWithUnusualStorage()
|
|
: Superclass(typename Superclass::PortalConstControl()) { }
|
|
};
|
|
|
|
struct StorageListTagUnusual :
|
|
vtkm::ListTagBase<
|
|
ArrayHandleWithUnusualStorage<vtkm::Id>::StorageTag,
|
|
ArrayHandleWithUnusualStorage<std::string>::StorageTag>
|
|
{ };
|
|
|
|
template<typename T>
|
|
struct TestValueFunctor
|
|
{
|
|
T operator()(vtkm::Id index) const
|
|
{
|
|
return TestValue(index, T());
|
|
}
|
|
};
|
|
|
|
bool CheckCalled;
|
|
|
|
struct CheckFunctor
|
|
{
|
|
template<typename T, typename Storage>
|
|
void operator()(vtkm::cont::ArrayHandle<T, Storage> array) const {
|
|
CheckCalled = true;
|
|
std::cout << " Checking for type: " << typeid(T).name() << std::endl;
|
|
|
|
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE,
|
|
"Unexpected array size.");
|
|
|
|
typename vtkm::cont::ArrayHandle<T,Storage>::PortalConstControl portal =
|
|
array.GetPortalConstControl();
|
|
CheckPortal(portal);
|
|
}
|
|
};
|
|
|
|
template<typename TypeList, typename StorageList>
|
|
void BasicDynamicArrayChecks(
|
|
const vtkm::cont::DynamicArrayHandleBase<TypeList,StorageList> &array,
|
|
vtkm::IdComponent numComponents)
|
|
{
|
|
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.");
|
|
}
|
|
|
|
void CheckDynamicArray(vtkm::cont::DynamicArrayHandle array,
|
|
vtkm::IdComponent numComponents)
|
|
{
|
|
BasicDynamicArrayChecks(array, numComponents);
|
|
|
|
array.CastAndCall(CheckFunctor());
|
|
|
|
VTKM_TEST_ASSERT(CheckCalled,
|
|
"The functor was never called (and apparently a bad value exception not thrown).");
|
|
}
|
|
|
|
template<typename TypeList, typename StorageList>
|
|
void CheckDynamicArray(
|
|
vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList> array,
|
|
vtkm::IdComponent numComponents)
|
|
{
|
|
BasicDynamicArrayChecks(array, numComponents);
|
|
|
|
array.CastAndCall(CheckFunctor());
|
|
|
|
VTKM_TEST_ASSERT(CheckCalled,
|
|
"The functor was never called (and apparently a bad value exception not thrown).");
|
|
}
|
|
|
|
template<typename T>
|
|
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());
|
|
}
|
|
|
|
return vtkm::cont::DynamicArrayHandle(
|
|
vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE));
|
|
}
|
|
|
|
template<typename ArrayHandleType>
|
|
void CheckCastToArrayHandle(const ArrayHandleType &array)
|
|
{
|
|
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
|
|
|
|
vtkm::cont::DynamicArrayHandle dynamicArray = array;
|
|
VTKM_TEST_ASSERT(
|
|
!dynamicArray.IsArrayHandleType<vtkm::cont::ArrayHandle<std::string> >(),
|
|
"Dynamic array reporting is wrong type.");
|
|
|
|
ArrayHandleType castArray1;
|
|
dynamicArray.CopyTo(castArray1);
|
|
VTKM_TEST_ASSERT(dynamicArray.IsSameType(castArray1),
|
|
"Did not query handle correctly.");
|
|
VTKM_TEST_ASSERT(array == castArray1, "Did not get back same array.");
|
|
|
|
ArrayHandleType castArray2 =
|
|
dynamicArray.CastToTypeStorage<typename ArrayHandleType::ValueType,
|
|
typename ArrayHandleType::StorageTag>();
|
|
VTKM_TEST_ASSERT(array == castArray2, "Did not get back same array.");
|
|
}
|
|
|
|
template<typename T, typename DynamicArrayType>
|
|
void TryNewInstance(T, DynamicArrayType originalArray)
|
|
{
|
|
// This check should already have been performed by caller, but just in case.
|
|
CheckDynamicArray(originalArray, vtkm::VecTraits<T>::NUM_COMPONENTS);
|
|
|
|
std::cout << "Create new instance of array." << std::endl;
|
|
DynamicArrayType newArray = originalArray.NewInstance();
|
|
|
|
std::cout << "Get a static instance of the new array (which checks the type)."
|
|
<< std::endl;
|
|
vtkm::cont::ArrayHandle<T> staticArray;
|
|
newArray.CopyTo(staticArray);
|
|
|
|
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++)
|
|
{
|
|
staticArray.GetPortalControl().Set(index, TestValue(index+100, T()));
|
|
}
|
|
CheckDynamicArray(originalArray, vtkm::VecTraits<T>::NUM_COMPONENTS);
|
|
|
|
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()));
|
|
}
|
|
CheckDynamicArray(newArray, vtkm::VecTraits<T>::NUM_COMPONENTS);
|
|
}
|
|
|
|
template<typename T>
|
|
void TryDefaultType(T)
|
|
{
|
|
CheckCalled = false;
|
|
|
|
vtkm::cont::DynamicArrayHandle array = CreateDynamicArray(T());
|
|
|
|
CheckDynamicArray(array, vtkm::VecTraits<T>::NUM_COMPONENTS);
|
|
|
|
TryNewInstance(T(), array);
|
|
}
|
|
|
|
struct TryBasicVTKmType
|
|
{
|
|
template<typename T>
|
|
void operator()(T) const {
|
|
CheckCalled = false;
|
|
|
|
vtkm::cont::DynamicArrayHandle array = CreateDynamicArray(T());
|
|
|
|
CheckDynamicArray(array.ResetTypeList(vtkm::TypeListTagAll()),
|
|
vtkm::VecTraits<T>::NUM_COMPONENTS);
|
|
|
|
TryNewInstance(T(), array.ResetTypeList(vtkm::TypeListTagAll()));
|
|
}
|
|
};
|
|
|
|
void TryUnusualType()
|
|
{
|
|
// A string is an unlikely type to be declared elsewhere in VTK-m.
|
|
vtkm::cont::DynamicArrayHandle array = CreateDynamicArray(std::string());
|
|
|
|
try
|
|
{
|
|
CheckDynamicArray(array, 1);
|
|
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type.");
|
|
}
|
|
catch (vtkm::cont::ErrorControlBadValue)
|
|
{
|
|
std::cout << " Caught exception for unrecognized type." << std::endl;
|
|
}
|
|
|
|
CheckCalled = false;
|
|
CheckDynamicArray(array.ResetTypeList(TypeListTagString()), 1);
|
|
VTKM_TEST_ASSERT(CheckCalled,
|
|
"The functor was never called (and apparently a bad value exception not thrown).");
|
|
std::cout << " Found type when type list was reset." << std:: endl;
|
|
}
|
|
|
|
void TryUnusualStorage()
|
|
{
|
|
vtkm::cont::DynamicArrayHandle array =
|
|
ArrayHandleWithUnusualStorage<vtkm::Id>();
|
|
|
|
try
|
|
{
|
|
CheckDynamicArray(array, 1);
|
|
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
|
|
}
|
|
catch (vtkm::cont::ErrorControlBadValue)
|
|
{
|
|
std::cout << " Caught exception for unrecognized storage." << std::endl;
|
|
}
|
|
|
|
CheckCalled = false;
|
|
CheckDynamicArray(array.ResetStorageList(StorageListTagUnusual()), 1);
|
|
std::cout << " Found instance when storage list was reset." << std:: endl;
|
|
}
|
|
|
|
void TryUnusualTypeAndStorage()
|
|
{
|
|
vtkm::cont::DynamicArrayHandle array =
|
|
ArrayHandleWithUnusualStorage<std::string>();
|
|
|
|
try
|
|
{
|
|
CheckDynamicArray(array, 1);
|
|
VTKM_TEST_FAIL(
|
|
"CastAndCall failed to error for unrecognized type/storage.");
|
|
}
|
|
catch (vtkm::cont::ErrorControlBadValue)
|
|
{
|
|
std::cout << " Caught exception for unrecognized type/storage."
|
|
<< std::endl;
|
|
}
|
|
|
|
try
|
|
{
|
|
CheckDynamicArray(array.ResetTypeList(TypeListTagString()), 1);
|
|
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
|
|
}
|
|
catch (vtkm::cont::ErrorControlBadValue)
|
|
{
|
|
std::cout << " Caught exception for unrecognized storage." << std::endl;
|
|
}
|
|
|
|
try
|
|
{
|
|
CheckDynamicArray(array.ResetStorageList(StorageListTagUnusual()), 1);
|
|
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type.");
|
|
}
|
|
catch (vtkm::cont::ErrorControlBadValue)
|
|
{
|
|
std::cout << " Caught exception for unrecognized type." << std::endl;
|
|
}
|
|
|
|
try
|
|
{
|
|
//resetting the string and tag should result in a valid array handle
|
|
CheckDynamicArray(array.ResetTypeAndStorageLists(TypeListTagString(),
|
|
StorageListTagUnusual()),
|
|
1);
|
|
}
|
|
catch (vtkm::cont::ErrorControlBadValue)
|
|
{
|
|
VTKM_TEST_FAIL("ResetTypeAndStorageLists should have handled the custom type/storage.");
|
|
}
|
|
|
|
|
|
CheckCalled = false;
|
|
CheckDynamicArray(array
|
|
.ResetTypeList(TypeListTagString())
|
|
.ResetStorageList(StorageListTagUnusual()),
|
|
1);
|
|
std::cout << " Found instance when type and storage lists were reset." << std:: endl;
|
|
|
|
CheckCalled = false;
|
|
CheckDynamicArray(array
|
|
.ResetStorageList(StorageListTagUnusual())
|
|
.ResetTypeList(TypeListTagString()),
|
|
1);
|
|
std::cout << " Found instance when storage and type lists were reset." << std:: endl;
|
|
|
|
CheckCalled = false;
|
|
CheckDynamicArray(array
|
|
.ResetTypeAndStorageLists(TypeListTagString(),
|
|
StorageListTagUnusual()),
|
|
1);
|
|
std::cout << " Found instance when storage and type lists were reset." << std:: endl;
|
|
}
|
|
|
|
void TryCastToArrayHandle()
|
|
{
|
|
std::cout << " Normal array handle." << std::endl;
|
|
vtkm::Id buffer[ARRAY_SIZE];
|
|
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
|
|
{
|
|
buffer[index] = TestValue(index, vtkm::Id());
|
|
}
|
|
vtkm::cont::ArrayHandle<vtkm::Id> array =
|
|
vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE);
|
|
CheckCastToArrayHandle(array);
|
|
|
|
std::cout << " Cast array handle." << std::endl;
|
|
CheckCastToArrayHandle(
|
|
vtkm::cont::make_ArrayHandleCast(array, vtkm::FloatDefault()));
|
|
|
|
std::cout << " Composite vector array handle." << std::endl;
|
|
CheckCastToArrayHandle(
|
|
vtkm::cont::make_ArrayHandleCompositeVector(array, 0, array, 0));
|
|
|
|
std::cout << " Constant array handle." << std::endl;
|
|
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleConstant(5, ARRAY_SIZE));
|
|
|
|
std::cout << " Counting array handle." << std::endl;
|
|
vtkm::cont::ArrayHandleCounting<vtkm::Id> countingArray(
|
|
ARRAY_SIZE-1, -1, ARRAY_SIZE);
|
|
CheckCastToArrayHandle(countingArray);
|
|
|
|
std::cout << " Group vec array handle" << std::endl;
|
|
vtkm::cont::ArrayHandleGroupVec<vtkm::cont::ArrayHandle<vtkm::Id>, 2>
|
|
groupVecArray(array);
|
|
CheckCastToArrayHandle(groupVecArray);
|
|
|
|
std::cout << " Implicit array handle." << std::endl;
|
|
CheckCastToArrayHandle(
|
|
vtkm::cont::make_ArrayHandleImplicit<vtkm::FloatDefault>(
|
|
TestValueFunctor<vtkm::FloatDefault>(), ARRAY_SIZE));
|
|
|
|
std::cout << " Index array handle." << std::endl;
|
|
CheckCastToArrayHandle(vtkm::cont::ArrayHandleIndex(ARRAY_SIZE));
|
|
|
|
std::cout << " Permutation array handle." << std::endl;
|
|
CheckCastToArrayHandle(
|
|
vtkm::cont::make_ArrayHandlePermutation(countingArray, array));
|
|
|
|
std::cout << " Transform array handle." << std::endl;
|
|
CheckCastToArrayHandle(
|
|
vtkm::cont::make_ArrayHandleTransform<vtkm::FloatDefault>(
|
|
countingArray,TestValueFunctor<vtkm::FloatDefault>()));
|
|
|
|
std::cout << " Uniform point coordinates array handle." << std::endl;
|
|
CheckCastToArrayHandle(vtkm::cont::ArrayHandleUniformPointCoordinates(
|
|
vtkm::Id3(ARRAY_SIZE)));
|
|
|
|
std::cout << " Zip array handle." << std::endl;
|
|
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleZip(countingArray, array));
|
|
}
|
|
|
|
void TestDynamicArrayHandle()
|
|
{
|
|
std::cout << "Try common types with default type lists." << std::endl;
|
|
std::cout << "*** vtkm::Id **********************" << std::endl;
|
|
TryDefaultType(vtkm::Id());
|
|
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;
|
|
TryDefaultType(vtkm::Vec<vtkm::Float32,3>());
|
|
std::cout << "*** vtkm::Vec<Float64,3> **********" << std::endl;
|
|
TryDefaultType(vtkm::Vec<vtkm::Float64,3>());
|
|
|
|
std::cout << "Try all VTK-m types." << std::endl;
|
|
vtkm::testing::Testing::TryAllTypes(TryBasicVTKmType());
|
|
|
|
std::cout << "Try unusual type." << std::endl;
|
|
TryUnusualType();
|
|
|
|
std::cout << "Try unusual storage." << std::endl;
|
|
TryUnusualStorage();
|
|
|
|
std::cout << "Try unusual type in unusual storage." << std::endl;
|
|
TryUnusualTypeAndStorage();
|
|
|
|
std::cout << "Try CastToArrayHandle" << std::endl;
|
|
TryCastToArrayHandle();
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
int UnitTestDynamicArrayHandle(int, char *[])
|
|
{
|
|
return vtkm::cont::testing::Testing::Run(TestDynamicArrayHandle);
|
|
}
|