diff --git a/vtkm/cont/CMakeLists.txt b/vtkm/cont/CMakeLists.txt index e6d7185f17cf1bbd91aef1847a9b18998da74683..8ee151f757a190cf20ccdf2082b8c24722133c70 100644 --- a/vtkm/cont/CMakeLists.txt +++ b/vtkm/cont/CMakeLists.txt @@ -74,7 +74,6 @@ set(headers DeviceAdapter.h DeviceAdapterAlgorithm.h DeviceAdapterListTag.h - DynamicArrayHandle.h DynamicCellSet.h EnvironmentTracker.h Error.h @@ -139,7 +138,6 @@ set(sources DataSetBuilderExplicit.cxx DataSetBuilderRectilinear.cxx DataSetBuilderUniform.cxx - DynamicArrayHandle.cxx EnvironmentTracker.cxx ErrorBadDevice.cxx ErrorBadType.cxx diff --git a/vtkm/cont/DynamicArrayHandle.cxx b/vtkm/cont/DynamicArrayHandle.cxx deleted file mode 100644 index 0d7ce827d177b6fd81aed4bcd3d7611d82b11e76..0000000000000000000000000000000000000000 --- a/vtkm/cont/DynamicArrayHandle.cxx +++ /dev/null @@ -1,53 +0,0 @@ -//============================================================================ -// 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 2015 National Technology & Engineering Solutions of Sandia, LLC (NTESS). -// Copyright 2015 UT-Battelle, LLC. -// Copyright 2015 Los Alamos National Security. -// -// Under the terms of Contract DE-NA0003525 with NTESS, -// 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 -#include -#include - -namespace vtkm -{ -namespace cont -{ -namespace detail -{ - -PolymorphicArrayHandleContainerBase::PolymorphicArrayHandleContainerBase() -{ -} - -PolymorphicArrayHandleContainerBase::~PolymorphicArrayHandleContainerBase() -{ -} - -void ThrowCastAndCallException(PolymorphicArrayHandleContainerBase* ptr, - const std::type_info* type, - const std::type_info* storage) -{ - std::ostringstream out; - out << "Could not find appropriate cast for array in CastAndCall1.\n" - "Array: "; - ptr->PrintSummary(out); - out << "TypeList: " << type->name() << "\nStorageList: " << storage->name() << "\n"; - throw vtkm::cont::ErrorBadValue(out.str()); -} -} -} -} // namespace vtkm::cont::detail diff --git a/vtkm/cont/DynamicArrayHandle.h b/vtkm/cont/DynamicArrayHandle.h deleted file mode 100644 index 1ec1a24ecdf43c31be63f8568b56beaf6e058efe..0000000000000000000000000000000000000000 --- a/vtkm/cont/DynamicArrayHandle.h +++ /dev/null @@ -1,579 +0,0 @@ -//============================================================================ -// 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 National Technology & Engineering Solutions of Sandia, LLC (NTESS). -// Copyright 2014 UT-Battelle, LLC. -// Copyright 2014 Los Alamos National Security. -// -// Under the terms of Contract DE-NA0003525 with NTESS, -// 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. -//============================================================================ -#ifndef vtk_m_cont_DynamicArrayHandle_h -#define vtk_m_cont_DynamicArrayHandle_h - -#include - -#include -#include - -#include -#include -#include -#include - -#include -#include - -namespace vtkm -{ - -template struct ListCrossProduct; - -namespace cont -{ - -// Forward declaration -template -class DynamicArrayHandleBase; - -namespace detail -{ - -/// \brief Base class for PolymorphicArrayHandleContainer -/// -struct VTKM_CONT_EXPORT PolymorphicArrayHandleContainerBase -{ - PolymorphicArrayHandleContainerBase(); - - // This must exist so that subclasses are destroyed correctly. - virtual ~PolymorphicArrayHandleContainerBase(); - - virtual vtkm::IdComponent GetNumberOfComponents() const = 0; - virtual vtkm::Id GetNumberOfValues() const = 0; - - virtual void PrintSummary(std::ostream& out) const = 0; - - virtual std::shared_ptr NewInstance() const = 0; -}; - -/// \brief ArrayHandle container that can use C++ run-time type information. -/// -/// The \c PolymorphicArrayHandleContainer is similar to the -/// \c SimplePolymorphicContainer in that it can contain an object of an -/// unknown type. However, this class specifically holds ArrayHandle objects -/// (with different template parameters) so that it can polymorphically answer -/// simple questions about the object. -/// -template -struct VTKM_ALWAYS_EXPORT PolymorphicArrayHandleContainer - : public PolymorphicArrayHandleContainerBase -{ - using ArrayHandleType = vtkm::cont::ArrayHandle; - - ArrayHandleType Array; - - VTKM_CONT - PolymorphicArrayHandleContainer() - : Array() - { - } - - VTKM_CONT - PolymorphicArrayHandleContainer(const ArrayHandleType& array) - : Array(array) - { - } - - virtual vtkm::IdComponent GetNumberOfComponents() const - { - return vtkm::VecTraits::NUM_COMPONENTS; - } - - virtual vtkm::Id GetNumberOfValues() const { return this->Array.GetNumberOfValues(); } - - virtual void PrintSummary(std::ostream& out) const - { - vtkm::cont::printSummary_ArrayHandle(this->Array, out); - } - - virtual std::shared_ptr NewInstance() const - { - return std::shared_ptr( - new PolymorphicArrayHandleContainer()); - } -}; - -// One instance of a template class cannot access the private members of -// another instance of a template class. However, I want to be able to copy -// construct a DynamicArrayHandle from another DynamicArrayHandle of any other -// type. Since you cannot partially specialize friendship, use this accessor -// class to get at the internals for the copy constructor. -struct DynamicArrayHandleCopyHelper -{ - template - VTKM_CONT static const std::shared_ptr& - GetArrayHandleContainer(const vtkm::cont::DynamicArrayHandleBase& src) - { - return src.ArrayContainer; - } -}; - -// A simple function to downcast an ArrayHandle encapsulated in a -// PolymorphicArrayHandleContainerBase to the given type of ArrayHandle. If the -// conversion cannot be done, nullptr is returned. -template -VTKM_CONT vtkm::cont::ArrayHandle* DynamicArrayHandleTryCast( - vtkm::cont::detail::PolymorphicArrayHandleContainerBase* arrayContainer) -{ - vtkm::cont::detail::PolymorphicArrayHandleContainer* downcastContainer = nullptr; - downcastContainer = dynamic_cast(arrayContainer); - if (downcastContainer != nullptr) - { - return &downcastContainer->Array; - } - else - { - return nullptr; - } -} - -template -VTKM_CONT vtkm::cont::ArrayHandle* DynamicArrayHandleTryCast( - const std::shared_ptr& arrayContainer) -{ - return detail::DynamicArrayHandleTryCast(arrayContainer.get()); -} - -} // namespace detail - -/// \brief Holds an array handle without having to specify template parameters. -/// -/// \c DynamicArrayHandle holds an \c ArrayHandle object using runtime -/// polymorphism to manage different value types and storage rather than -/// compile-time templates. This adds a programming convenience that helps -/// avoid a proliferation of templates. It also provides the management -/// necessary to interface VTK-m with data sources where types will not be -/// known until runtime. -/// -/// To interface between the runtime polymorphism and the templated algorithms -/// in VTK-m, \c DynamicArrayHandle contains a method named \c CastAndCall that -/// will determine the correct type from some known list of types and storage -/// objects. This mechanism is used internally by VTK-m's worklet invocation -/// mechanism to determine the type when running algorithms. -/// -/// By default, \c DynamicArrayHandle will assume that the value type in the -/// array matches one of the types specified by \c VTKM_DEFAULT_TYPE_LIST_TAG -/// and the storage matches one of the tags specified by \c -/// VTKM_DEFAULT_STORAGE_LIST_TAG. These lists can be changed by using the \c -/// ResetTypeList and \c ResetStorageList methods, respectively. It is -/// worthwhile to match these lists closely to the possible types that might be -/// used. If a type is missing you will get a runtime error. If there are more -/// types than necessary, then the template mechanism will create a lot of -/// object code that is never used, and keep in mind that the number of -/// combinations grows exponentially when using multiple \c DynamicArrayHandle -/// objects. -/// -/// The actual implementation of \c DynamicArrayHandle is in a templated class -/// named \c DynamicArrayHandleBase, which is templated on the list of -/// component types and storage types. \c DynamicArrayHandle is really just a -/// typedef of \c DynamicArrayHandleBase with the default type and storage -/// lists. -/// -template -class VTKM_ALWAYS_EXPORT DynamicArrayHandleBase -{ -public: - VTKM_CONT - DynamicArrayHandleBase() {} - - template - VTKM_CONT DynamicArrayHandleBase(const vtkm::cont::ArrayHandle& array) - : ArrayContainer(new vtkm::cont::detail::PolymorphicArrayHandleContainer(array)) - { - } - - VTKM_CONT - DynamicArrayHandleBase(const DynamicArrayHandleBase& src) - : ArrayContainer(src.ArrayContainer) - { - } - - template - VTKM_CONT explicit DynamicArrayHandleBase( - const DynamicArrayHandleBase& src) - : ArrayContainer(detail::DynamicArrayHandleCopyHelper::GetArrayHandleContainer(src)) - { - } - - VTKM_CONT - ~DynamicArrayHandleBase() {} - - VTKM_CONT - vtkm::cont::DynamicArrayHandleBase& operator=( - const vtkm::cont::DynamicArrayHandleBase& src) - { - this->ArrayContainer = src.ArrayContainer; - return *this; - } - - /// Returns true if this array is of the provided type and uses the provided - /// storage. - /// - template - VTKM_CONT bool IsTypeAndStorage() const - { - return (detail::DynamicArrayHandleTryCast(this->ArrayContainer) != nullptr); - } - - /// Returns true if this array matches the array handle type passed in. - /// - template - VTKM_CONT bool IsType() - { - VTKM_IS_ARRAY_HANDLE(ArrayHandleType); - using ValueType = typename ArrayHandleType::ValueType; - using StorageTag = typename ArrayHandleType::StorageTag; - return this->IsTypeAndStorage(); - } - - /// Returns true if the array held in this object is the same (or equivalent) - /// type as the object given. - /// - template - VTKM_CONT bool IsSameType(const ArrayHandleType&) - { - VTKM_IS_ARRAY_HANDLE(ArrayHandleType); - return this->IsType(); - } - - /// Returns this array cast to an ArrayHandle object of the given type and - /// storage. Throws \c ErrorBadType if the cast does not work. Use - /// \c IsTypeAndStorage to check if the cast can happen. - /// - /// - template - VTKM_CONT vtkm::cont::ArrayHandle CastToTypeStorage() const - { - vtkm::cont::ArrayHandle* downcastArray = - detail::DynamicArrayHandleTryCast(this->ArrayContainer); - if (downcastArray == nullptr) - { - VTKM_LOG_CAST_FAIL(*this, decltype(downcastArray)); - throw vtkm::cont::ErrorBadType("Bad cast of dynamic array."); - } - // Technically, this method returns a copy of the \c ArrayHandle. But - // because \c ArrayHandle acts like a shared pointer, it is valid to - // do the copy. - VTKM_LOG_CAST_SUCC(*this, *downcastArray); - return *downcastArray; - } - - /// Returns this array cast to the given \c ArrayHandle type. Throws \c - /// ErrorBadType if the cast does not work. Use \c IsType - /// to check if the cast can happen. - /// - template - VTKM_CONT ArrayHandleType Cast() const - { - VTKM_IS_ARRAY_HANDLE(ArrayHandleType); - using ValueType = typename ArrayHandleType::ValueType; - using StorageTag = typename ArrayHandleType::StorageTag; - // Technically, this method returns a copy of the \c ArrayHandle. But - // because \c ArrayHandle acts like a shared pointer, it is valid to - // do the copy. - return this->CastToTypeStorage(); - } - - /// Given a references to an ArrayHandle object, casts this array to the - /// ArrayHandle's type and sets the given ArrayHandle to this array. Throws - /// \c ErrorBadType if the cast does not work. Use \c - /// ArrayHandleType to check if the cast can happen. - /// - /// Note that this is a shallow copy. The data are not copied and a change - /// in the data in one array will be reflected in the other. - /// - template - VTKM_CONT void CopyTo(ArrayHandleType& array) const - { - VTKM_IS_ARRAY_HANDLE(ArrayHandleType); - array = this->Cast(); - } - - /// Changes the types to try casting to when resolving this dynamic array, - /// which is specified with a list tag like those in TypeListTag.h. Since C++ - /// does not allow you to actually change the template arguments, this method - /// returns a new dynamic array object. This method is particularly useful to - /// narrow down (or expand) the types when using an array of particular - /// constraints. - /// - template - VTKM_CONT DynamicArrayHandleBase ResetTypeList( - NewTypeList = NewTypeList()) const - { - VTKM_IS_LIST_TAG(NewTypeList); - return DynamicArrayHandleBase(*this); - } - - /// Changes the array storage types to try casting to when resolving this - /// dynamic array, which is specified with a list tag like those in - /// StorageListTag.h. Since C++ does not allow you to actually change the - /// template arguments, this method returns a new dynamic array object. This - /// method is particularly useful to narrow down (or expand) the types when - /// using an array of particular constraints. - /// - template - VTKM_CONT DynamicArrayHandleBase ResetStorageList( - NewStorageList = NewStorageList()) const - { - VTKM_IS_LIST_TAG(NewStorageList); - return DynamicArrayHandleBase(*this); - } - - /// Changes the value, and array storage types to try casting to when - /// resolving this dynamic array. Since C++ does not allow you to actually - /// change the template arguments, this method returns a new dynamic array - /// object. This method is particularly useful when you have both custom - /// types and traits. - /// - template - VTKM_CONT DynamicArrayHandleBase ResetTypeAndStorageLists( - NewTypeList = NewTypeList(), - NewStorageList = NewStorageList()) const - { - VTKM_IS_LIST_TAG(NewTypeList); - VTKM_IS_LIST_TAG(NewStorageList); - return DynamicArrayHandleBase(*this); - } - - /// Attempts to cast the held array to a specific value type and storage, - /// then call the given functor with the cast array. The types and storage - /// tried in the cast are those in the lists defined by the TypeList and - /// StorageList, respectively. The default \c DynamicArrayHandle sets these - /// two lists to VTKM_DEFAULT_TYPE_LIST_TAG and VTK_DEFAULT_STORAGE_LIST_TAG, - /// respectively. - /// - template - VTKM_CONT void CastAndCall(Functor&& f, Args&&...) const; - - /// \brief Create a new array of the same type as this array. - /// - /// This method creates a new array that is the same type as this one and - /// returns a new dynamic array handle for it. This method is convenient when - /// creating output arrays that should be the same type as some input array. - /// - VTKM_CONT - DynamicArrayHandleBase NewInstance() const - { - DynamicArrayHandleBase newArray; - newArray.ArrayContainer = this->ArrayContainer->NewInstance(); - return newArray; - } - - /// \brief Get the number of components in each array value. - /// - /// This method will query the array type for the number of components in - /// each value of the array. The number of components is determined by - /// the \c VecTraits::NUM_COMPONENTS trait class. - /// - VTKM_CONT - vtkm::IdComponent GetNumberOfComponents() const - { - return this->ArrayContainer->GetNumberOfComponents(); - } - - /// \brief Get the number of values in the array. - /// - VTKM_CONT - vtkm::Id GetNumberOfValues() const { return this->ArrayContainer->GetNumberOfValues(); } - - VTKM_CONT - void PrintSummary(std::ostream& out) const { this->ArrayContainer->PrintSummary(out); } - -private: - std::shared_ptr ArrayContainer; - - friend struct detail::DynamicArrayHandleCopyHelper; -}; - -using DynamicArrayHandle = - vtkm::cont::DynamicArrayHandleBase; - -namespace detail -{ - -struct DynamicArrayHandleTry -{ - template - void operator()(brigand::list, - Functor&& f, - bool& called, - const PolymorphicArrayHandleContainerBase* const container, - Args&&... args) const - { - if (!called) - { - using downcastType = const vtkm::cont::detail::PolymorphicArrayHandleContainer* const; - downcastType downcastContainer = dynamic_cast(container); - if (downcastContainer) - { - VTKM_LOG_CAST_SUCC(*container, *downcastContainer); - f(downcastContainer->Array, std::forward(args)...); - called = true; - } - } - } -}; - -VTKM_CONT_EXPORT void ThrowCastAndCallException(PolymorphicArrayHandleContainerBase*, - const std::type_info*, - const std::type_info*); -} // namespace detail - - -template -struct IsUndefinedStorage -{ -}; -template -struct IsUndefinedStorage> : vtkm::cont::internal::IsInValidArrayHandle -{ -}; - -template -struct ListTagDynamicTypes : vtkm::detail::ListRoot -{ - using crossProduct = typename vtkm::ListCrossProduct; - // using list = typename crossProduct::list; - using list = ::brigand::remove_if>; -}; - - -template -template -VTKM_CONT void DynamicArrayHandleBase::CastAndCall(Functor&& f, - Args&&... args) const -{ - //For optimizations we should compile once the cross product for the default types - //and make it extern - using crossProduct = ListTagDynamicTypes; - - bool called = false; - auto* ptr = this->ArrayContainer.get(); - vtkm::ListForEach(detail::DynamicArrayHandleTry{}, - crossProduct{}, - std::forward(f), - called, - ptr, - std::forward(args)...); - if (!called) - { - // throw an exception - VTKM_LOG_CAST_FAIL(*this, crossProduct); - detail::ThrowCastAndCallException(ptr, &typeid(TypeList), &typeid(StorageList)); - } -} - -namespace internal -{ - -template -struct DynamicTransformTraits> -{ - using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall; -}; - -} // namespace internal -} - -} // namespace vtkm::cont - - -//============================================================================= -// Specializations of serialization related classes -namespace diy -{ - -namespace internal -{ - -struct DynamicArrayHandleSerializeFunctor -{ - template - void operator()(const ArrayHandleType& ah, BinaryBuffer& bb) const - { - diy::save(bb, vtkm::cont::TypeString::Get()); - diy::save(bb, ah); - } -}; - -template -struct DynamicArrayHandleDeserializeFunctor -{ - template - void operator()(brigand::list, - vtkm::cont::DynamicArrayHandleBase& dh, - const std::string& typeString, - bool& success, - BinaryBuffer& bb) const - { - using ArrayHandleType = vtkm::cont::ArrayHandle; - - if (!success && (typeString == vtkm::cont::TypeString::Get())) - { - ArrayHandleType ah; - diy::load(bb, ah); - dh = vtkm::cont::DynamicArrayHandleBase(ah); - success = true; - } - } -}; - -} // internal - -template -struct Serialization> -{ -private: - using Type = vtkm::cont::DynamicArrayHandleBase; - -public: - static VTKM_CONT void save(BinaryBuffer& bb, const Type& obj) - { - obj.CastAndCall(internal::DynamicArrayHandleSerializeFunctor{}, bb); - } - - static VTKM_CONT void load(BinaryBuffer& bb, Type& obj) - { - using CrossProduct = vtkm::cont::ListTagDynamicTypes; - - std::string typeString; - diy::load(bb, typeString); - - bool success = false; - vtkm::ListForEach(internal::DynamicArrayHandleDeserializeFunctor{}, - CrossProduct{}, - obj, - typeString, - success, - bb); - - if (!success) - { - throw vtkm::cont::ErrorBadType( - "Error deserializing DynamicArrayHandle. Message TypeString: " + typeString); - } - } -}; - -} // diy - -#endif //vtk_m_cont_DynamicArrayHandle_h diff --git a/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx b/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx index 1639a51d60da9aa90612c71feecde453a60a5f64..814157dd47d4751ffb1d37eab13f7f2422788a07 100644 --- a/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx +++ b/vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx @@ -21,8 +21,8 @@ #include "vtkm/cont/internal/DynamicTransform.h" #include "vtkm/cont/ArrayHandle.h" -#include "vtkm/cont/DynamicArrayHandle.h" #include "vtkm/cont/DynamicCellSet.h" +#include "vtkm/cont/VariantArrayHandle.h" #include "vtkm/internal/FunctionInterface.h" @@ -31,7 +31,7 @@ namespace vtkm { -// DynamicArrayHandle requires its value type to have a defined VecTraits +// VariantArrayHandle 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 @@ -71,10 +71,15 @@ struct ScalarFunctor struct ArrayHandleScalarFunctor { template - void operator()(const vtkm::cont::ArrayHandle&) const + void operator()(const vtkm::cont::ArrayHandleVirtual&) const { VTKM_TEST_FAIL("Called wrong form of functor operator."); } + void operator()(const vtkm::cont::ArrayHandleVirtual&) const + { + std::cout << " In ArrayHandleVirtual functor." << std::endl; + g_FunctionCalls++; + } void operator()(const vtkm::cont::ArrayHandle&) const { std::cout << " In ArrayHandle functor." << std::endl; @@ -84,9 +89,9 @@ struct ArrayHandleScalarFunctor struct ArrayHandleStringFunctor { - void operator()(const vtkm::cont::ArrayHandle&) const + void operator()(const vtkm::cont::ArrayHandleVirtual&) const { - std::cout << " In ArrayHandle functor." << std::endl; + std::cout << " In ArrayHandleVirtual functor." << std::endl; g_FunctionCalls++; } }; @@ -121,6 +126,16 @@ struct FunctionInterfaceFunctor std::cout << " In FunctionInterface<...> functor." << std::endl; g_FunctionCalls++; } + + void operator()( + const vtkm::internal::FunctionInterface, + vtkm::cont::ArrayHandleVirtual, + vtkm::cont::ArrayHandleVirtual, + vtkm::cont::CellSetStructured<3>)>&) const + { + std::cout << " In FunctionInterface<...> functor." << std::endl; + g_FunctionCalls++; + } }; void TestBasicTransform() @@ -138,13 +153,13 @@ void TestBasicTransform() TRY_TRANSFORM(transform(concreteArray, ArrayHandleScalarFunctor(), indexTag)); std::cout << " Trying scalar dynamic array." << std::endl; - vtkm::cont::DynamicArrayHandle dynamicArray = concreteArray; + vtkm::cont::VariantArrayHandle dynamicArray = concreteArray; TRY_TRANSFORM(transform(dynamicArray, ArrayHandleScalarFunctor(), indexTag)); std::cout << " Trying with unusual (string) dynamic array." << std::endl; dynamicArray = vtkm::cont::ArrayHandle(); - TRY_TRANSFORM(transform( - dynamicArray.ResetTypeList(TypeListTagString()), ArrayHandleStringFunctor(), indexTag)); + TRY_TRANSFORM( + transform(dynamicArray.ResetTypes(TypeListTagString()), ArrayHandleStringFunctor(), indexTag)); std::cout << " Trying with structured cell set." << std::endl; vtkm::cont::CellSetStructured<3> concreteCellSet; @@ -171,8 +186,8 @@ void TestFunctionTransform() TRY_TRANSFORM( vtkm::internal::make_FunctionInterface( scalarArray, - vtkm::cont::DynamicArrayHandle(scalarArray), - vtkm::cont::DynamicArrayHandle(stringArray).ResetTypeList(TypeListTagString()), + vtkm::cont::VariantArrayHandle(scalarArray), + vtkm::cont::VariantArrayHandle(stringArray).ResetTypes(TypeListTagString()), vtkm::cont::DynamicCellSet(structuredCellSet)) .DynamicTransformCont(vtkm::cont::internal::DynamicTransform(), FunctionInterfaceFunctor())); } diff --git a/vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx b/vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx index 4186de56340b420f61a65d4df2c1717e66a4a1be..c7fcb3d2341c69f72b2d4d44082cf8b1a2100b41 100644 --- a/vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx +++ b/vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx @@ -236,7 +236,7 @@ struct TestArrayHandleGroupVecVariable vtkm::cont::make_ArrayHandle(comps)); RunTest(array); - // cannot make a DynamicArrayHandle containing ArrayHandleGroupVecVariable + // cannot make a VariantArrayHandle containing ArrayHandleGroupVecVariable // because of the variable number of components of its values. // RunTest(MakeTestVariantArrayHandle(array)); } diff --git a/vtkm/filter/ZFPCompressor1D.hxx b/vtkm/filter/ZFPCompressor1D.hxx index f089eb64132694bbdd743aca4f270f7d186b68b1..90bcb2027d0e599a167f247437603c3efc276280 100644 --- a/vtkm/filter/ZFPCompressor1D.hxx +++ b/vtkm/filter/ZFPCompressor1D.hxx @@ -21,7 +21,6 @@ #include #include #include -#include #include #include diff --git a/vtkm/filter/ZFPCompressor2D.hxx b/vtkm/filter/ZFPCompressor2D.hxx index 4ba890b0080ca67c27ea52fee3bef8e261e13021..2987a6ddd63088388e723a55ba85bf71093f4c81 100644 --- a/vtkm/filter/ZFPCompressor2D.hxx +++ b/vtkm/filter/ZFPCompressor2D.hxx @@ -21,7 +21,6 @@ #include #include #include -#include #include #include diff --git a/vtkm/filter/ZFPCompressor3D.hxx b/vtkm/filter/ZFPCompressor3D.hxx index 9e78954a8a5cf268e1f5e7704d389cdea87c816d..86701ea24edf9abce6234f055ab1e2bc10cf0c2e 100644 --- a/vtkm/filter/ZFPCompressor3D.hxx +++ b/vtkm/filter/ZFPCompressor3D.hxx @@ -21,7 +21,6 @@ #include #include #include -#include #include #include diff --git a/vtkm/filter/ZFPDecompressor1D.hxx b/vtkm/filter/ZFPDecompressor1D.hxx index 1c0fadd1cbfb9a1f187cf6fb51f2ba8b2b027a6d..aaecad963247aab8a83b10f7ccbc2b69af15e49a 100644 --- a/vtkm/filter/ZFPDecompressor1D.hxx +++ b/vtkm/filter/ZFPDecompressor1D.hxx @@ -21,7 +21,6 @@ #include #include #include -#include #include #include diff --git a/vtkm/filter/ZFPDecompressor2D.hxx b/vtkm/filter/ZFPDecompressor2D.hxx index 27cc029a9677588ffef436d45a1eda7c32f959cc..8c052ba8124364c8fbe0d7b283d6f0e47439140c 100644 --- a/vtkm/filter/ZFPDecompressor2D.hxx +++ b/vtkm/filter/ZFPDecompressor2D.hxx @@ -21,7 +21,6 @@ #include #include #include -#include #include #include diff --git a/vtkm/filter/ZFPDecompressor3D.hxx b/vtkm/filter/ZFPDecompressor3D.hxx index 9fa6ce736a6974d5776c064b2523893d79a1c933..650dbba7108b9b3c60c1d9a548178ce2aec803a3 100644 --- a/vtkm/filter/ZFPDecompressor3D.hxx +++ b/vtkm/filter/ZFPDecompressor3D.hxx @@ -21,7 +21,6 @@ #include #include #include -#include #include #include diff --git a/vtkm/filter/testing/UnitTestZFP.cxx b/vtkm/filter/testing/UnitTestZFP.cxx index 16f5e540f65404356a36ba8807d5bb431348aa22..7a46e8da8a2a2c9f05191d21483f4312e421b2c7 100644 --- a/vtkm/filter/testing/UnitTestZFP.cxx +++ b/vtkm/filter/testing/UnitTestZFP.cxx @@ -24,7 +24,6 @@ #include #include #include -#include #include #include