From f68635941e037363d04256610a0ac6651b6580a3 Mon Sep 17 00:00:00 2001 From: Robert Maynard Date: Wed, 16 Aug 2017 11:34:21 -0400 Subject: [PATCH] Convert VTK-m over to use 'using' instead of 'typedef' --- vtkm/cont/ArrayHandleCartesianProduct.h | 44 +++--- vtkm/cont/ArrayHandleConcatenate.h | 39 +++--- vtkm/cont/ArrayHandleGroupVec.h | 50 ++++--- vtkm/cont/ArrayHandlePermutation.h | 28 ++-- vtkm/cont/ArrayHandleReverse.h | 26 ++-- vtkm/cont/ArrayHandleStreaming.h | 2 +- vtkm/cont/ArrayHandleTransform.h | 97 +++++++------ .../cont/ArrayHandleUniformPointCoordinates.h | 2 +- vtkm/cont/ArrayHandleZip.h | 39 +++--- vtkm/cont/ArrayPortal.h | 2 +- vtkm/cont/ArrayRangeCompute.hxx | 2 +- vtkm/cont/CellSetExplicit.h | 80 +++++------ vtkm/cont/CellSetExplicit.hxx | 2 +- vtkm/cont/CellSetPermutation.h | 2 +- vtkm/cont/CellSetSingleType.h | 7 +- vtkm/cont/CellSetStructured.h | 8 +- vtkm/cont/CellSetStructured.hxx | 4 +- vtkm/cont/CoordinateSystem.h | 26 ++-- vtkm/cont/DataSetBuilderRectilinear.h | 2 +- vtkm/cont/DataSetBuilderUniform.h | 2 +- vtkm/cont/DynamicArrayHandle.h | 13 +- vtkm/cont/DynamicCellSet.h | 6 +- vtkm/cont/Storage.h | 6 +- vtkm/cont/StorageBasic.h | 4 +- vtkm/cont/StorageImplicit.h | 2 +- vtkm/cont/TryExecute.h | 2 +- .../testing/UnitTestTransportCellSetIn.cxx | 10 +- .../testing/UnitTestTransportWholeArray.cxx | 32 ++--- .../arg/testing/UnitTestTypeCheckArray.cxx | 28 ++-- .../cuda/internal/ArrayManagerExecutionCuda.h | 10 +- .../ArrayManagerExecutionThrustDevice.h | 12 +- .../internal/DeviceAdapterAlgorithmCuda.h | 5 +- .../internal/DeviceAdapterAlgorithmThrust.h | 9 +- vtkm/cont/cuda/internal/MakeThrustIterator.h | 22 +-- .../cuda/internal/ThrustExceptionHandler.h | 2 +- .../internal/ArrayManagerExecutionSerial.h | 2 +- .../tbb/internal/ArrayManagerExecutionTBB.h | 2 +- .../tbb/internal/DeviceAdapterAlgorithmTBB.h | 8 +- vtkm/cont/tbb/internal/FunctorsTBB.h | 6 +- vtkm/cont/testing/MakeTestDataSet.h | 22 +-- vtkm/cont/testing/TestingArrayHandles.h | 2 +- vtkm/cont/testing/TestingDataSetSingleType.h | 2 +- vtkm/cont/testing/TestingDeviceAdapter.h | 32 ++--- vtkm/cont/testing/TestingFancyArrayHandles.h | 74 +++++----- vtkm/cont/testing/TestingImplicitFunction.h | 2 +- .../UnitTestArrayHandleCompositeVector.cxx | 14 +- .../UnitTestArrayHandleConcatenate.cxx | 4 +- .../testing/UnitTestArrayHandleCounting.cxx | 6 +- .../UnitTestArrayHandlePermutation.cxx | 4 +- .../testing/UnitTestArrayHandleTransform.cxx | 9 +- ...TestArrayHandleUniformPointCoordinates.cxx | 2 +- .../testing/UnitTestDataSetPermutation.cxx | 8 +- .../UnitTestDeviceAdapterAlgorithmGeneral.cxx | 6 +- .../testing/UnitTestDynamicArrayHandle.cxx | 2 +- vtkm/cont/testing/UnitTestStorageBasic.cxx | 15 +- vtkm/cont/testing/UnitTestStorageImplicit.cxx | 2 +- vtkm/cont/testing/UnitTestTryExecute.cxx | 4 +- vtkm/exec/CellDerivative.h | 40 +++--- vtkm/exec/CellInterpolate.h | 22 +-- vtkm/exec/ConnectivityExplicit.h | 4 +- vtkm/exec/ConnectivityPermuted.h | 6 +- vtkm/exec/ConnectivityStructured.h | 12 +- vtkm/exec/Jacobian.h | 6 +- vtkm/exec/ParametricCoordinates.h | 40 +++--- vtkm/exec/arg/CellShape.h | 6 +- vtkm/exec/arg/Fetch.h | 2 +- vtkm/exec/arg/FetchTagArrayTopologyMapIn.h | 34 +++-- vtkm/exec/arg/FetchTagCellSetIn.h | 4 +- vtkm/exec/arg/FromCount.h | 6 +- vtkm/exec/arg/FromIndices.h | 6 +- vtkm/exec/arg/ThreadIndicesTopologyMap.h | 2 +- vtkm/exec/arg/ValueCount.h | 2 +- .../testing/UnitTestFetchArrayDirectIn.cxx | 11 +- .../testing/UnitTestFetchArrayDirectInOut.cxx | 11 +- .../testing/UnitTestFetchArrayDirectOut.cxx | 11 +- .../UnitTestFetchArrayTopologyMapIn.cxx | 23 ++-- .../arg/testing/UnitTestFetchExecObject.cxx | 9 +- .../arg/testing/UnitTestFetchWorkIndex.cxx | 11 +- .../cuda/internal/ArrayPortalFromThrust.h | 24 ++-- .../cuda/internal/IteratorFromArrayPortal.h | 2 +- vtkm/exec/cuda/internal/ThrustPatches.h | 2 +- vtkm/exec/cuda/internal/WrappedOperators.h | 22 +-- .../testing/UnitTestTaskSingularCuda.cu | 128 +++++++++++------- .../testing/UnitTestTextureMemorySupport.cu | 28 ++-- .../exec/internal/testing/TestingTaskTiling.h | 44 +++--- .../internal/testing/UnitTestTaskSingular.cxx | 50 ++++--- .../testing/UnitTestWorkletInvokeFunctor.cxx | 18 +-- vtkm/exec/testing/UnitTestCellInterpolate.cxx | 2 +- .../testing/UnitTestParametricCoordinates.cxx | 12 +- 89 files changed, 722 insertions(+), 733 deletions(-) diff --git a/vtkm/cont/ArrayHandleCartesianProduct.h b/vtkm/cont/ArrayHandleCartesianProduct.h index 910fcd701..978fce3f8 100644 --- a/vtkm/cont/ArrayHandleCartesianProduct.h +++ b/vtkm/cont/ArrayHandleCartesianProduct.h @@ -170,15 +170,15 @@ struct ArrayHandleCartesianProductTraits { /// The ValueType (a pair containing the value types of the two arrays). /// - typedef vtkm::Vec ValueType; + using ValueType = vtkm::Vec; /// The appropriately templated tag. /// - typedef StorageTagCartesianProduct Tag; + using Tag = StorageTagCartesianProduct; /// The superclass for ArrayHandleCartesianProduct. /// - typedef vtkm::cont::ArrayHandle Superclass; + using Superclass = vtkm::cont::ArrayHandle; }; template @@ -191,18 +191,16 @@ class Storage - PortalType; - typedef vtkm::exec::internal::ArrayPortalCartesianProduct< - ValueType, - typename FirstHandleType::PortalConstControl, - typename SecondHandleType::PortalConstControl, - typename ThirdHandleType::PortalConstControl> - PortalConstType; + using PortalType = + vtkm::exec::internal::ArrayPortalCartesianProduct; + using PortalConstType = + vtkm::exec::internal::ArrayPortalCartesianProduct; VTKM_CONT Storage() @@ -288,8 +286,8 @@ class ArrayTransfer, Device> { - typedef StorageTagCartesianProduct StorageTag; - typedef vtkm::cont::internal::Storage StorageType; + using StorageTag = StorageTagCartesianProduct; + using StorageType = vtkm::cont::internal::Storage; public: using ValueType = T; @@ -297,19 +295,17 @@ public: using PortalControl = typename StorageType::PortalType; using PortalConstControl = typename StorageType::PortalConstType; - typedef vtkm::exec::internal::ArrayPortalCartesianProduct< + using PortalExecution = vtkm::exec::internal::ArrayPortalCartesianProduct< ValueType, typename FirstHandleType::template ExecutionTypes::Portal, typename SecondHandleType::template ExecutionTypes::Portal, - typename ThirdHandleType::template ExecutionTypes::Portal> - PortalExecution; + typename ThirdHandleType::template ExecutionTypes::Portal>; - typedef vtkm::exec::internal::ArrayPortalCartesianProduct< + using PortalConstExecution = vtkm::exec::internal::ArrayPortalCartesianProduct< ValueType, typename FirstHandleType::template ExecutionTypes::PortalConst, typename SecondHandleType::template ExecutionTypes::PortalConst, - typename ThirdHandleType::template ExecutionTypes::PortalConst> - PortalConstExecution; + typename ThirdHandleType::template ExecutionTypes::PortalConst>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -404,7 +400,7 @@ public: ThirdHandleType>::Superclass)); private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT diff --git a/vtkm/cont/ArrayHandleConcatenate.h b/vtkm/cont/ArrayHandleConcatenate.h index 81c7dc98e..a9d6cbcdb 100644 --- a/vtkm/cont/ArrayHandleConcatenate.h +++ b/vtkm/cont/ArrayHandleConcatenate.h @@ -35,7 +35,7 @@ template class VTKM_ALWAYS_EXPORT ArrayPortalConcatenate { public: - typedef typename PortalType1::ValueType ValueType; + using ValueType = typename PortalType1::ValueType; VTKM_EXEC_CONT ArrayPortalConcatenate() @@ -109,13 +109,11 @@ class Storage> { public: - typedef typename ArrayHandleType1::ValueType ValueType; - typedef ArrayPortalConcatenate - PortalType; - typedef ArrayPortalConcatenate - PortalConstType; + using ValueType = typename ArrayHandleType1::ValueType; + using PortalType = ArrayPortalConcatenate; + using PortalConstType = ArrayPortalConcatenate; VTKM_CONT Storage() @@ -204,23 +202,22 @@ class ArrayTransfer { public: - typedef typename ArrayHandleType1::ValueType ValueType; + using ValueType = typename ArrayHandleType1::ValueType; private: - typedef StorageTagConcatenate StorageTag; - typedef vtkm::cont::internal::Storage StorageType; + using StorageTag = StorageTagConcatenate; + using StorageType = vtkm::cont::internal::Storage; public: - typedef typename StorageType::PortalType PortalControl; - typedef typename StorageType::PortalConstType PortalConstControl; + using PortalControl = typename StorageType::PortalType; + using PortalConstControl = typename StorageType::PortalConstType; - typedef ArrayPortalConcatenate::Portal, - typename ArrayHandleType2::template ExecutionTypes::Portal> - PortalExecution; - typedef ArrayPortalConcatenate< - typename ArrayHandleType1::template ExecutionTypes::PortalConst, - typename ArrayHandleType2::template ExecutionTypes::PortalConst> - PortalConstExecution; + using PortalExecution = + ArrayPortalConcatenate::Portal, + typename ArrayHandleType2::template ExecutionTypes::Portal>; + using PortalConstExecution = + ArrayPortalConcatenate::PortalConst, + typename ArrayHandleType2::template ExecutionTypes::PortalConst>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -306,7 +303,7 @@ public: StorageTagConcatenate>)); protected: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT diff --git a/vtkm/cont/ArrayHandleGroupVec.h b/vtkm/cont/ArrayHandleGroupVec.h index 0beab4385..b7f6adb8b 100644 --- a/vtkm/cont/ArrayHandleGroupVec.h +++ b/vtkm/cont/ArrayHandleGroupVec.h @@ -37,10 +37,10 @@ class VTKM_ALWAYS_EXPORT ArrayPortalGroupVec { public: static const vtkm::IdComponent NUM_COMPONENTS = _NUM_COMPONENTS; - typedef _SourcePortalType SourcePortalType; + using SourcePortalType = _SourcePortalType; - typedef typename std::remove_const::type ComponentType; - typedef vtkm::Vec ValueType; + using ComponentType = typename std::remove_const::type; + using ValueType = vtkm::Vec; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT @@ -128,17 +128,17 @@ template class Storage, vtkm::cont::internal::StorageTagGroupVec> { - typedef typename SourceArrayHandleType::ValueType ComponentType; + using ComponentType = typename SourceArrayHandleType::ValueType; public: - typedef vtkm::Vec ValueType; + using ValueType = vtkm::Vec; - typedef vtkm::exec::internal::ArrayPortalGroupVec - PortalType; - typedef vtkm::exec::internal:: - ArrayPortalGroupVec - PortalConstType; + using PortalType = + vtkm::exec::internal::ArrayPortalGroupVec; + using PortalConstType = + vtkm::exec::internal::ArrayPortalGroupVec; VTKM_CONT Storage() @@ -222,26 +222,24 @@ class ArrayTransfer { public: - typedef typename SourceArrayHandleType::ValueType ComponentType; - typedef vtkm::Vec ValueType; + using ComponentType = typename SourceArrayHandleType::ValueType; + using ValueType = vtkm::Vec; private: - typedef vtkm::cont::internal::StorageTagGroupVec - StorageTag; - typedef vtkm::cont::internal::Storage StorageType; + using StorageTag = + vtkm::cont::internal::StorageTagGroupVec; + using StorageType = vtkm::cont::internal::Storage; public: - typedef typename StorageType::PortalType PortalControl; - typedef typename StorageType::PortalConstType PortalConstControl; + using PortalControl = typename StorageType::PortalType; + using PortalConstControl = typename StorageType::PortalConstType; - typedef vtkm::exec::internal::ArrayPortalGroupVec< + using PortalExecution = vtkm::exec::internal::ArrayPortalGroupVec< typename SourceArrayHandleType::template ExecutionTypes::Portal, - NUM_COMPONENTS> - PortalExecution; - typedef vtkm::exec::internal::ArrayPortalGroupVec< + NUM_COMPONENTS>; + using PortalConstExecution = vtkm::exec::internal::ArrayPortalGroupVec< typename SourceArrayHandleType::template ExecutionTypes::PortalConst, - NUM_COMPONENTS> - PortalConstExecution; + NUM_COMPONENTS>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -341,10 +339,10 @@ public: vtkm::Vec, vtkm::cont::internal::StorageTagGroupVec>)); - typedef typename SourceArrayHandleType::ValueType ComponentType; + using ComponentType = typename SourceArrayHandleType::ValueType; private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT diff --git a/vtkm/cont/ArrayHandlePermutation.h b/vtkm/cont/ArrayHandlePermutation.h index 757fe5171..317319bc4 100644 --- a/vtkm/cont/ArrayHandlePermutation.h +++ b/vtkm/cont/ArrayHandlePermutation.h @@ -127,12 +127,12 @@ class Storage - PortalType; - typedef vtkm::exec::internal::ArrayPortalPermutation - PortalConstType; + using PortalType = + vtkm::exec::internal::ArrayPortalPermutation; + using PortalConstType = + vtkm::exec::internal::ArrayPortalPermutation; VTKM_CONT Storage() @@ -212,21 +212,19 @@ public: using ValueType = typename ValueArrayType::ValueType; private: - typedef StorageTagPermutation StorageTag; - typedef vtkm::cont::internal::Storage StorageType; + using StorageTag = StorageTagPermutation; + using StorageType = vtkm::cont::internal::Storage; public: using PortalControl = typename StorageType::PortalType; using PortalConstControl = typename StorageType::PortalConstType; - typedef vtkm::exec::internal::ArrayPortalPermutation< + using PortalExecution = vtkm::exec::internal::ArrayPortalPermutation< typename IndexArrayType::template ExecutionTypes::PortalConst, - typename ValueArrayType::template ExecutionTypes::Portal> - PortalExecution; - typedef vtkm::exec::internal::ArrayPortalPermutation< + typename ValueArrayType::template ExecutionTypes::Portal>; + using PortalConstExecution = vtkm::exec::internal::ArrayPortalPermutation< typename IndexArrayType::template ExecutionTypes::PortalConst, - typename ValueArrayType::template ExecutionTypes::PortalConst> - PortalConstExecution; + typename ValueArrayType::template ExecutionTypes::PortalConst>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -350,7 +348,7 @@ public: internal::StorageTagPermutation>)); private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT diff --git a/vtkm/cont/ArrayHandleReverse.h b/vtkm/cont/ArrayHandleReverse.h index 0a64495df..91b00bb73 100644 --- a/vtkm/cont/ArrayHandleReverse.h +++ b/vtkm/cont/ArrayHandleReverse.h @@ -91,9 +91,9 @@ template class Storage> { public: - typedef typename ArrayHandleType::ValueType ValueType; - typedef ArrayPortalReverse PortalType; - typedef ArrayPortalReverse PortalConstType; + using ValueType = typename ArrayHandleType::ValueType; + using PortalType = ArrayPortalReverse; + using PortalConstType = ArrayPortalReverse; VTKM_CONT Storage() @@ -145,20 +145,20 @@ template class ArrayTransfer, Device> { public: - typedef typename ArrayHandleType::ValueType ValueType; + using ValueType = typename ArrayHandleType::ValueType; private: - typedef StorageTagReverse StorageTag; - typedef vtkm::cont::internal::Storage StorageType; + using StorageTag = StorageTagReverse; + using StorageType = vtkm::cont::internal::Storage; public: - typedef typename StorageType::PortalType PortalControl; - typedef typename StorageType::PortalConstType PortalConstControl; + using PortalControl = typename StorageType::PortalType; + using PortalConstControl = typename StorageType::PortalConstType; - typedef ArrayPortalReverse::Portal> - PortalExecution; - typedef ArrayPortalReverse::PortalConst> - PortalConstExecution; + using PortalExecution = + ArrayPortalReverse::Portal>; + using PortalConstExecution = + ArrayPortalReverse::PortalConst>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -223,7 +223,7 @@ public: StorageTagReverse>)); protected: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: ArrayHandleReverse(const ArrayHandleType& handle) diff --git a/vtkm/cont/ArrayHandleStreaming.h b/vtkm/cont/ArrayHandleStreaming.h index 4c88bf7f3..28d6f089a 100644 --- a/vtkm/cont/ArrayHandleStreaming.h +++ b/vtkm/cont/ArrayHandleStreaming.h @@ -235,7 +235,7 @@ public: StorageTagStreaming>)); private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT diff --git a/vtkm/cont/ArrayHandleTransform.h b/vtkm/cont/ArrayHandleTransform.h index faf2f99af..4ad612e00 100644 --- a/vtkm/cont/ArrayHandleTransform.h +++ b/vtkm/cont/ArrayHandleTransform.h @@ -48,7 +48,7 @@ namespace exec namespace internal { -typedef vtkm::cont::internal::NullFunctorType NullFunctorType; +using NullFunctorType = vtkm::cont::internal::NullFunctorType; /// \brief An array portal that transforms a value from another portal. /// @@ -63,9 +63,9 @@ class VTKM_ALWAYS_EXPORT ArrayPortalTransform { public: - typedef PortalType_ PortalType; - typedef ValueType_ ValueType; - typedef FunctorType_ FunctorType; + using PortalType = PortalType_; + using ValueType = ValueType_; + using FunctorType = FunctorType_; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT @@ -127,11 +127,11 @@ class VTKM_ALWAYS_EXPORT ArrayPortalTransform : public ArrayPortalTransform { public: - typedef ArrayPortalTransform Superclass; - typedef PortalType_ PortalType; - typedef ValueType_ ValueType; - typedef FunctorType_ FunctorType; - typedef InverseFunctorType_ InverseFunctorType; + using Superclass = ArrayPortalTransform; + using PortalType = PortalType_; + using ValueType = ValueType_; + using FunctorType = FunctorType_; + using InverseFunctorType = InverseFunctorType_; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT @@ -199,20 +199,20 @@ class Storage::ValueT StorageTagTransform> { public: - typedef typename StorageTagTransform::ValueType ValueType; + using ValueType = typename StorageTagTransform::ValueType; // This is meant to be invalid. Because Transform arrays are read only, you // should only be able to use the const version. struct PortalType { - typedef void* ValueType; - typedef void* IteratorType; + using ValueType = void*; + using IteratorType = void*; }; - typedef vtkm::exec::internal::ArrayPortalTransform - PortalConstType; + using PortalConstType = + vtkm::exec::internal::ArrayPortalTransform; VTKM_CONT Storage() @@ -291,19 +291,19 @@ class Storage< StorageTagTransform> { public: - typedef typename StorageTagTransform::ValueType - ValueType; + using ValueType = + typename StorageTagTransform::ValueType; - typedef vtkm::exec::internal::ArrayPortalTransform - PortalType; - typedef vtkm::exec::internal::ArrayPortalTransform - PortalConstType; + using PortalType = + vtkm::exec::internal::ArrayPortalTransform; + using PortalConstType = + vtkm::exec::internal::ArrayPortalTransform; VTKM_CONT Storage() @@ -386,22 +386,21 @@ class ArrayTransfer:: StorageTagTransform, Device> { - typedef StorageTagTransform StorageTag; + using StorageTag = StorageTagTransform; public: - typedef typename StorageTagTransform::ValueType ValueType; - typedef vtkm::cont::internal::Storage StorageType; + using ValueType = typename StorageTagTransform::ValueType; + using StorageType = vtkm::cont::internal::Storage; - typedef typename StorageType::PortalType PortalControl; - typedef typename StorageType::PortalConstType PortalConstControl; + using PortalControl = typename StorageType::PortalType; + using PortalConstControl = typename StorageType::PortalConstType; //meant to be an invalid writeable execution portal - typedef typename StorageType::PortalType PortalExecution; - typedef vtkm::exec::internal::ArrayPortalTransform< + using PortalExecution = typename StorageType::PortalType; + using PortalConstExecution = vtkm::exec::internal::ArrayPortalTransform< ValueType, typename ArrayHandleType::template ExecutionTypes::PortalConst, - FunctorType> - PortalConstExecution; + FunctorType>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -464,27 +463,25 @@ class ArrayTransfer< StorageTagTransform, Device> { - typedef StorageTagTransform StorageTag; + using StorageTag = StorageTagTransform; public: - typedef typename StorageTagTransform::ValueType ValueType; - typedef vtkm::cont::internal::Storage StorageType; + using ValueType = typename StorageTagTransform::ValueType; + using StorageType = vtkm::cont::internal::Storage; - typedef typename StorageType::PortalType PortalControl; - typedef typename StorageType::PortalConstType PortalConstControl; + using PortalControl = typename StorageType::PortalType; + using PortalConstControl = typename StorageType::PortalConstType; - typedef vtkm::exec::internal::ArrayPortalTransform< + using PortalExecution = vtkm::exec::internal::ArrayPortalTransform< ValueType, typename ArrayHandleType::template ExecutionTypes::Portal, FunctorType, - InverseFunctorType> - PortalExecution; - typedef vtkm::exec::internal::ArrayPortalTransform< + InverseFunctorType>; + using PortalConstExecution = vtkm::exec::internal::ArrayPortalTransform< ValueType, typename ArrayHandleType::template ExecutionTypes::PortalConst, FunctorType, - InverseFunctorType> - PortalConstExecution; + InverseFunctorType>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -574,7 +571,7 @@ public: internal::StorageTagTransform>)); private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT @@ -616,7 +613,7 @@ public: internal::StorageTagTransform>)); private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: ArrayHandleTransform(const ArrayHandleType& handle, diff --git a/vtkm/cont/ArrayHandleUniformPointCoordinates.h b/vtkm/cont/ArrayHandleUniformPointCoordinates.h index 7a1f638c9..659d80295 100644 --- a/vtkm/cont/ArrayHandleUniformPointCoordinates.h +++ b/vtkm/cont/ArrayHandleUniformPointCoordinates.h @@ -47,7 +47,7 @@ public: vtkm::cont::StorageTagImplicit>)); private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT diff --git a/vtkm/cont/ArrayHandleZip.h b/vtkm/cont/ArrayHandleZip.h index cdfc6c6e1..b94cc5a71 100644 --- a/vtkm/cont/ArrayHandleZip.h +++ b/vtkm/cont/ArrayHandleZip.h @@ -118,16 +118,16 @@ struct ArrayHandleZipTraits { /// The ValueType (a pair containing the value types of the two arrays). /// - typedef vtkm::Pair - ValueType; + using ValueType = + vtkm::Pair; /// The appropriately templated tag. /// - typedef StorageTagZip Tag; + using Tag = StorageTagZip; /// The superclass for ArrayHandleZip. /// - typedef vtkm::cont::ArrayHandle Superclass; + using Superclass = vtkm::cont::ArrayHandle; }; template @@ -139,14 +139,13 @@ class Storage> public: using ValueType = T; - typedef vtkm::exec::internal::ArrayPortalZip - PortalType; - typedef vtkm::exec::internal::ArrayPortalZip - PortalConstType; + using PortalType = vtkm::exec::internal::ArrayPortalZip; + using PortalConstType = + vtkm::exec::internal::ArrayPortalZip; VTKM_CONT Storage() @@ -217,8 +216,8 @@ private: template class ArrayTransfer, Device> { - typedef StorageTagZip StorageTag; - typedef vtkm::cont::internal::Storage StorageType; + using StorageTag = StorageTagZip; + using StorageType = vtkm::cont::internal::Storage; public: using ValueType = T; @@ -226,17 +225,15 @@ public: using PortalControl = typename StorageType::PortalType; using PortalConstControl = typename StorageType::PortalConstType; - typedef vtkm::exec::internal::ArrayPortalZip< + using PortalExecution = vtkm::exec::internal::ArrayPortalZip< ValueType, typename FirstHandleType::template ExecutionTypes::Portal, - typename SecondHandleType::template ExecutionTypes::Portal> - PortalExecution; + typename SecondHandleType::template ExecutionTypes::Portal>; - typedef vtkm::exec::internal::ArrayPortalZip< + using PortalConstExecution = vtkm::exec::internal::ArrayPortalZip< ValueType, typename FirstHandleType::template ExecutionTypes::PortalConst, - typename SecondHandleType::template ExecutionTypes::PortalConst> - PortalConstExecution; + typename SecondHandleType::template ExecutionTypes::PortalConst>; VTKM_CONT ArrayTransfer(StorageType* storage) @@ -324,7 +321,7 @@ public: (typename internal::ArrayHandleZipTraits::Superclass)); private: - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: VTKM_CONT diff --git a/vtkm/cont/ArrayPortal.h b/vtkm/cont/ArrayPortal.h index 374ae222e..cab9945cf 100644 --- a/vtkm/cont/ArrayPortal.h +++ b/vtkm/cont/ArrayPortal.h @@ -61,7 +61,7 @@ class ArrayPortal public: /// The type of each value in the array. /// - typedef T ValueType; + using ValueType = T; /// The total number of values in the array. They are index from 0 to /// GetNumberOfValues()-1. diff --git a/vtkm/cont/ArrayRangeCompute.hxx b/vtkm/cont/ArrayRangeCompute.hxx index a84f63452..2d5e28a51 100644 --- a/vtkm/cont/ArrayRangeCompute.hxx +++ b/vtkm/cont/ArrayRangeCompute.hxx @@ -59,7 +59,7 @@ struct ArrayRangeComputeFunctor using VecTraits = vtkm::VecTraits; const vtkm::IdComponent NumberOfComponents = VecTraits::NUM_COMPONENTS; - typedef vtkm::cont::DeviceAdapterAlgorithm Algorithm; + using Algorithm = vtkm::cont::DeviceAdapterAlgorithm; this->RangeArray.Allocate(NumberOfComponents); diff --git a/vtkm/cont/CellSetExplicit.h b/vtkm/cont/CellSetExplicit.h index 74c174710..092dbbbda 100644 --- a/vtkm/cont/CellSetExplicit.h +++ b/vtkm/cont/CellSetExplicit.h @@ -41,7 +41,7 @@ namespace detail template struct CellSetExplicitConnectivityChooser { - typedef vtkm::cont::internal::ConnectivityExplicitInternals<> ConnectivityType; + using ConnectivityType = vtkm::cont::internal::ConnectivityExplicitInternals<>; }; } // namespace detail @@ -68,36 +68,36 @@ template class VTKM_ALWAYS_EXPORT CellSetExplicit : public CellSet { - typedef CellSetExplicit - Thisclass; + using Thisclass = CellSetExplicit; template struct ConnectivityChooser { - typedef - typename detail::CellSetExplicitConnectivityChooser:: - ConnectivityType ConnectivityType; + using ConnectivityType = + typename detail::CellSetExplicitConnectivityChooser::ConnectivityType; - typedef typename ConnectivityType::ShapeArrayType ShapeArrayType; - typedef typename ConnectivityType::NumIndicesArrayType NumIndicesArrayType; - typedef typename ConnectivityType::ConnectivityArrayType ConnectivityArrayType; - typedef typename ConnectivityType::IndexOffsetArrayType IndexOffsetArrayType; + using ShapeArrayType = typename ConnectivityType::ShapeArrayType; + using NumIndicesArrayType = typename ConnectivityType::NumIndicesArrayType; + using ConnectivityArrayType = typename ConnectivityType::ConnectivityArrayType; + using IndexOffsetArrayType = typename ConnectivityType::IndexOffsetArrayType; }; public: - typedef vtkm::Id SchedulingRangeType; + using SchedulingRangeType = vtkm::Id; //point to cell is used when iterating cells and asking for point properties - typedef ConnectivityChooser - PointToCellConnectivityType; + using PointToCellConnectivityType = + ConnectivityChooser; - typedef typename PointToCellConnectivityType::ShapeArrayType ShapeArrayType; - typedef typename PointToCellConnectivityType::NumIndicesArrayType NumIndicesArrayType; - typedef typename PointToCellConnectivityType::ConnectivityArrayType ConnectivityArrayType; - typedef typename PointToCellConnectivityType::IndexOffsetArrayType IndexOffsetArrayType; + using ShapeArrayType = typename PointToCellConnectivityType::ShapeArrayType; + using NumIndicesArrayType = typename PointToCellConnectivityType::NumIndicesArrayType; + using ConnectivityArrayType = typename PointToCellConnectivityType::ConnectivityArrayType; + using IndexOffsetArrayType = typename PointToCellConnectivityType::IndexOffsetArrayType; VTKM_CONT CellSetExplicit(const std::string& name = std::string()); VTKM_CONT CellSetExplicit(const Thisclass& src); @@ -148,22 +148,24 @@ public: VTKM_IS_TOPOLOGY_ELEMENT_TAG(FromTopology); VTKM_IS_TOPOLOGY_ELEMENT_TAG(ToTopology); - typedef ConnectivityChooser ConnectivityTypes; + using ConnectivityTypes = ConnectivityChooser; - typedef typename ConnectivityTypes::ShapeArrayType::template ExecutionTypes< - DeviceAdapter>::PortalConst ShapePortalType; - typedef typename ConnectivityTypes::NumIndicesArrayType::template ExecutionTypes< - DeviceAdapter>::PortalConst IndicePortalType; - typedef typename ConnectivityTypes::ConnectivityArrayType::template ExecutionTypes< - DeviceAdapter>::PortalConst ConnectivityPortalType; - typedef typename ConnectivityTypes::IndexOffsetArrayType::template ExecutionTypes< - DeviceAdapter>::PortalConst IndexOffsetPortalType; + using ShapePortalType = typename ConnectivityTypes::ShapeArrayType::template ExecutionTypes< + DeviceAdapter>::PortalConst; + using IndicePortalType = + typename ConnectivityTypes::NumIndicesArrayType::template ExecutionTypes< + DeviceAdapter>::PortalConst; + using ConnectivityPortalType = + typename ConnectivityTypes::ConnectivityArrayType::template ExecutionTypes< + DeviceAdapter>::PortalConst; + using IndexOffsetPortalType = + typename ConnectivityTypes::IndexOffsetArrayType::template ExecutionTypes< + DeviceAdapter>::PortalConst; - typedef vtkm::exec::ConnectivityExplicit - ExecObjectType; + using ExecObjectType = vtkm::exec::ConnectivityExplicit; }; template @@ -245,9 +247,8 @@ struct CellSetExplicitConnectivityChooser< vtkm::TopologyElementTagPoint, vtkm::TopologyElementTagCell> { - typedef vtkm::cont::internal:: - ConnectivityExplicitInternals - ConnectivityType; + using ConnectivityType = + vtkm::cont::internal::ConnectivityExplicitInternals; }; template @@ -257,9 +258,8 @@ struct CellSetExplicitConnectivityChooser::StorageTag> - ConnectivityType; + using ConnectivityType = vtkm::cont::internal::ConnectivityExplicitInternals< + typename ArrayHandleConstant::StorageTag>; }; } // namespace detail diff --git a/vtkm/cont/CellSetExplicit.hxx b/vtkm/cont/CellSetExplicit.hxx index 1591fa8a7..03dde4f1c 100644 --- a/vtkm/cont/CellSetExplicit.hxx +++ b/vtkm/cont/CellSetExplicit.hxx @@ -355,7 +355,7 @@ auto CellSetExplicitGetConnectivity(FromTopology(), ToTopology()); VTKM_ASSERT(connectivity.ElementsValid); - typedef typename ExecutionTypes::ExecObjectType ExecObjType; + using ExecObjType = typename ExecutionTypes::ExecObjectType; return ExecObjType(connectivity.Shapes.PrepareForInput(Device()), connectivity.NumIndices.PrepareForInput(Device()), connectivity.Connectivity.PrepareForInput(Device()), diff --git a/vtkm/cont/CellSetPermutation.h b/vtkm/cont/CellSetPermutation.h index df4ae06aa..70a60e0a0 100644 --- a/vtkm/cont/CellSetPermutation.h +++ b/vtkm/cont/CellSetPermutation.h @@ -50,7 +50,7 @@ struct WriteConnectivity : public vtkm::worklet::WorkletMapPointToCell FieldInCell offset, WholeArrayOut<> connectivity); typedef void ExecutionSignature(PointCount, PointIndices, _2, _3); - typedef _1 InputDomain; + using InputDomain = _1; template VTKM_EXEC void operator()(vtkm::IdComponent pointcount, diff --git a/vtkm/cont/CellSetSingleType.h b/vtkm/cont/CellSetSingleType.h index 6a607393d..58bd2179d 100644 --- a/vtkm/cont/CellSetSingleType.h +++ b/vtkm/cont/CellSetSingleType.h @@ -47,13 +47,12 @@ class VTKM_ALWAYS_EXPORT CellSetSingleType typename vtkm::cont::ArrayHandleCounting::StorageTag //IndexOffsetStorageTag > { - typedef vtkm::cont::CellSetSingleType Thisclass; - typedef vtkm::cont::CellSetExplicit< + using Thisclass = vtkm::cont::CellSetSingleType; + using Superclass = vtkm::cont::CellSetExplicit< typename vtkm::cont::ArrayHandleConstant::StorageTag, typename vtkm::cont::ArrayHandleConstant::StorageTag, ConnectivityStorageTag, - typename vtkm::cont::ArrayHandleCounting::StorageTag> - Superclass; + typename vtkm::cont::ArrayHandleCounting::StorageTag>; public: VTKM_CONT diff --git a/vtkm/cont/CellSetStructured.h b/vtkm/cont/CellSetStructured.h index 62b241659..498776190 100644 --- a/vtkm/cont/CellSetStructured.h +++ b/vtkm/cont/CellSetStructured.h @@ -37,13 +37,13 @@ template class VTKM_ALWAYS_EXPORT CellSetStructured : public CellSet { private: - typedef vtkm::cont::CellSetStructured Thisclass; - typedef vtkm::internal::ConnectivityStructuredInternals InternalsType; + using Thisclass = vtkm::cont::CellSetStructured; + using InternalsType = vtkm::internal::ConnectivityStructuredInternals; public: static const vtkm::IdComponent Dimension = DIMENSION; - typedef typename InternalsType::SchedulingRangeType SchedulingRangeType; + using SchedulingRangeType = typename InternalsType::SchedulingRangeType; CellSetStructured(const std::string& name = std::string()) : CellSet(name) @@ -88,7 +88,7 @@ public: VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapter); VTKM_IS_TOPOLOGY_ELEMENT_TAG(FromTopology); VTKM_IS_TOPOLOGY_ELEMENT_TAG(ToTopology); - typedef vtkm::exec::ConnectivityStructured ExecObjectType; + using ExecObjectType = vtkm::exec::ConnectivityStructured; }; template diff --git a/vtkm/cont/CellSetStructured.hxx b/vtkm/cont/CellSetStructured.hxx index 8358f9088..259bb3d01 100644 --- a/vtkm/cont/CellSetStructured.hxx +++ b/vtkm/cont/CellSetStructured.hxx @@ -54,8 +54,8 @@ typename CellSetStructured< DIMENSION>::template ExecutionTypes::ExecObjectType CellSetStructured::PrepareForInput(DeviceAdapter, FromTopology, ToTopology) const { - typedef typename ExecutionTypes::ExecObjectType - ConnectivityType; + using ConnectivityType = + typename ExecutionTypes::ExecObjectType; return ConnectivityType(this->Structure); } diff --git a/vtkm/cont/CoordinateSystem.h b/vtkm/cont/CoordinateSystem.h index c40ccf7aa..44b5690a6 100644 --- a/vtkm/cont/CoordinateSystem.h +++ b/vtkm/cont/CoordinateSystem.h @@ -44,15 +44,15 @@ namespace cont namespace detail { -typedef vtkm::cont::ArrayHandleCompositeVectorType, - vtkm::cont::ArrayHandle, - vtkm::cont::ArrayHandle>::type - ArrayHandleCompositeVectorFloat32_3Default; +using ArrayHandleCompositeVectorFloat32_3Default = + vtkm::cont::ArrayHandleCompositeVectorType, + vtkm::cont::ArrayHandle, + vtkm::cont::ArrayHandle>::type; -typedef vtkm::cont::ArrayHandleCompositeVectorType, - vtkm::cont::ArrayHandle, - vtkm::cont::ArrayHandle>::type - ArrayHandleCompositeVectorFloat64_3Default; +using ArrayHandleCompositeVectorFloat64_3Default = + vtkm::cont::ArrayHandleCompositeVectorType, + vtkm::cont::ArrayHandle, + vtkm::cont::ArrayHandle>::type; } // namespace detail @@ -73,13 +73,13 @@ struct StorageListTagCoordinateSystemDefault { }; -typedef vtkm::cont::DynamicArrayHandleBase - DynamicArrayHandleCoordinateSystem; +using DynamicArrayHandleCoordinateSystem = + vtkm::cont::DynamicArrayHandleBase; class VTKM_CONT_EXPORT CoordinateSystem : public vtkm::cont::Field { - typedef vtkm::cont::Field Superclass; + using Superclass = vtkm::cont::Field; public: VTKM_CONT @@ -226,7 +226,7 @@ namespace internal template <> struct DynamicTransformTraits { - typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag; + using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall; }; } // namespace internal diff --git a/vtkm/cont/DataSetBuilderRectilinear.h b/vtkm/cont/DataSetBuilderRectilinear.h index 8da0cf0b4..be5d54b1b 100644 --- a/vtkm/cont/DataSetBuilderRectilinear.h +++ b/vtkm/cont/DataSetBuilderRectilinear.h @@ -43,7 +43,7 @@ class DataSetBuilderRectilinear VTKM_CONT static void CopyInto(const vtkm::cont::ArrayHandle& input, vtkm::cont::ArrayHandle& output) { - typedef vtkm::cont::DeviceAdapterAlgorithm Algorithm; + using Algorithm = vtkm::cont::DeviceAdapterAlgorithm; Algorithm::Copy(input, output); } diff --git a/vtkm/cont/DataSetBuilderUniform.h b/vtkm/cont/DataSetBuilderUniform.h index 74e705c9b..ccd629168 100644 --- a/vtkm/cont/DataSetBuilderUniform.h +++ b/vtkm/cont/DataSetBuilderUniform.h @@ -30,7 +30,7 @@ namespace cont class DataSetBuilderUniform { - typedef vtkm::Vec VecType; + using VecType = vtkm::Vec; public: VTKM_CONT diff --git a/vtkm/cont/DynamicArrayHandle.h b/vtkm/cont/DynamicArrayHandle.h index 12badae5b..dc49d9c30 100644 --- a/vtkm/cont/DynamicArrayHandle.h +++ b/vtkm/cont/DynamicArrayHandle.h @@ -74,7 +74,7 @@ template struct VTKM_ALWAYS_EXPORT PolymorphicArrayHandleContainer : public PolymorphicArrayHandleContainerBase { - typedef vtkm::cont::ArrayHandle ArrayHandleType; + using ArrayHandleType = vtkm::cont::ArrayHandle; ArrayHandleType Array; @@ -400,9 +400,8 @@ private: friend struct detail::DynamicArrayHandleCopyHelper; }; -typedef vtkm::cont::DynamicArrayHandleBase - DynamicArrayHandle; +using DynamicArrayHandle = + vtkm::cont::DynamicArrayHandleBase; namespace detail { @@ -471,7 +470,7 @@ struct DynamicArrayHandleTryType { return; } - typedef DynamicArrayHandleTryStorage TryStorageType; + using TryStorageType = DynamicArrayHandleTryStorage; TryStorageType tryStorage = TryStorageType(*this->Array, this->Function); vtkm::ListForEach(tryStorage, StorageList()); @@ -493,7 +492,7 @@ VTKM_CONT void DynamicArrayHandleBase::CastAndCall(const { VTKM_IS_LIST_TAG(TypeList); VTKM_IS_LIST_TAG(StorageList); - typedef detail::DynamicArrayHandleTryType TryTypeType; + using TryTypeType = detail::DynamicArrayHandleTryType; // We cast this to a DynamicArrayHandle because at this point we are ignoring // the type/storage lists in it. There is no sense in adding more unnecessary @@ -525,7 +524,7 @@ DynamicArrayHandleBase TryTypeType; + using TryTypeType = detail::DynamicArrayHandleTryType; // We can remove the copy, as the current DynamicArrayHandle is already // the default one, and no reason to do an atomic increment and increase diff --git a/vtkm/cont/DynamicCellSet.h b/vtkm/cont/DynamicCellSet.h index 292d63b53..ec54f0dcd 100644 --- a/vtkm/cont/DynamicCellSet.h +++ b/vtkm/cont/DynamicCellSet.h @@ -312,7 +312,7 @@ template template VTKM_CONT void DynamicCellSetBase::CastAndCall(const Functor& f) const { - typedef detail::DynamicCellSetTryCellSet TryCellSetType; + using TryCellSetType = detail::DynamicCellSetTryCellSet; TryCellSetType tryCellSet = TryCellSetType(this->CellSetContainer.get(), f); vtkm::ListForEach(tryCellSet, CellSetList()); @@ -322,7 +322,7 @@ VTKM_CONT void DynamicCellSetBase::CastAndCall(const Functor& f) co } } -typedef DynamicCellSetBase DynamicCellSet; +using DynamicCellSet = DynamicCellSetBase; namespace internal { @@ -330,7 +330,7 @@ namespace internal template struct DynamicTransformTraits> { - typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag; + using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall; }; } // namespace internal diff --git a/vtkm/cont/Storage.h b/vtkm/cont/Storage.h index c72f02e94..832221ce3 100644 --- a/vtkm/cont/Storage.h +++ b/vtkm/cont/Storage.h @@ -106,21 +106,21 @@ public: public: /// The type of each item in the array. /// - typedef T ValueType; + using ValueType = T; /// \brief The type of portal objects for the array. /// /// The actual portal object can take any form. This is a simple example of a /// portal to a C array. /// - typedef ::vtkm::cont::internal::ArrayPortalFromIterators PortalType; + using PortalType = ::vtkm::cont::internal::ArrayPortalFromIterators; /// \brief The type of portal objects (const version) for the array. /// /// The actual portal object can take any form. This is a simple example of a /// portal to a C array. /// - typedef ::vtkm::cont::internal::ArrayPortalFromIterators PortalConstType; + using PortalConstType = ::vtkm::cont::internal::ArrayPortalFromIterators; /// Returns a portal to the array. /// diff --git a/vtkm/cont/StorageBasic.h b/vtkm/cont/StorageBasic.h index c92e91fce..97e730e1f 100644 --- a/vtkm/cont/StorageBasic.h +++ b/vtkm/cont/StorageBasic.h @@ -72,7 +72,7 @@ struct AlignedAllocator template struct rebind { - typedef AlignedAllocator other; + using other = AlignedAllocator; }; AlignedAllocator() {} @@ -183,7 +183,7 @@ public: /// whether that would ever be useful. So, instead of jumping through hoops /// implementing them, just fix the allocator for now. /// - typedef AlignedAllocator AllocatorType; + using AllocatorType = AlignedAllocator; public: VTKM_CONT diff --git a/vtkm/cont/StorageImplicit.h b/vtkm/cont/StorageImplicit.h index f9749cd22..f920955ab 100644 --- a/vtkm/cont/StorageImplicit.h +++ b/vtkm/cont/StorageImplicit.h @@ -102,7 +102,7 @@ class ArrayTransfer, DeviceAdapterTag> { private: using StorageTag = StorageTagImplicit; - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; public: using ValueType = T; diff --git a/vtkm/cont/TryExecute.h b/vtkm/cont/TryExecute.h index 2832bfb13..f35f8e9b7 100644 --- a/vtkm/cont/TryExecute.h +++ b/vtkm/cont/TryExecute.h @@ -123,7 +123,7 @@ struct TryExecuteImpl { if (!this->Success) { - typedef vtkm::cont::DeviceAdapterTraits DeviceTraits; + using DeviceTraits = vtkm::cont::DeviceAdapterTraits; this->Success = detail::TryExecuteRunIfValid::Run( this->Functor, this->Tracker); diff --git a/vtkm/cont/arg/testing/UnitTestTransportCellSetIn.cxx b/vtkm/cont/arg/testing/UnitTestTransportCellSetIn.cxx index 723b36be1..69e8e8017 100644 --- a/vtkm/cont/arg/testing/UnitTestTransportCellSetIn.cxx +++ b/vtkm/cont/arg/testing/UnitTestTransportCellSetIn.cxx @@ -69,11 +69,13 @@ void TransportWholeCellSetIn(Device) contObject.AddCell(vtkm::CELL_SHAPE_QUAD, 4, vtkm::make_Vec(2, 1, 3, 4)); contObject.CompleteAddingCells(nVerts); - typedef vtkm::TopologyElementTagPoint FromType; - typedef vtkm::TopologyElementTagCell ToType; + using FromType = vtkm::TopologyElementTagPoint; + using ToType = vtkm::TopologyElementTagCell; - typedef typename vtkm::cont::CellSetExplicit<>:: - template ExecutionTypes::ExecObjectType ExecObjectType; + using ExecObjectType = + typename vtkm::cont::CellSetExplicit<>::template ExecutionTypes::ExecObjectType; vtkm::cont::arg::Transport, vtkm::cont::CellSetExplicit<>, diff --git a/vtkm/cont/arg/testing/UnitTestTransportWholeArray.cxx b/vtkm/cont/arg/testing/UnitTestTransportWholeArray.cxx index 992211857..bf596dedd 100644 --- a/vtkm/cont/arg/testing/UnitTestTransportWholeArray.cxx +++ b/vtkm/cont/arg/testing/UnitTestTransportWholeArray.cxx @@ -117,20 +117,18 @@ struct TryWholeArrayType template void operator()(T) const { - typedef vtkm::cont::ArrayHandle ArrayHandleType; + using ArrayHandleType = vtkm::cont::ArrayHandle; - typedef vtkm::cont::arg::Transport - InTransportType; - typedef vtkm::cont::arg::Transport - InOutTransportType; - typedef vtkm::cont::arg::Transport - OutTransportType; + using InTransportType = vtkm::cont::arg::Transport; + using InOutTransportType = + vtkm::cont::arg::Transport; + using OutTransportType = vtkm::cont::arg::Transport; ArrayHandleType array; array.Allocate(ARRAY_SIZE); @@ -172,12 +170,10 @@ struct TryAtomicArrayType template void operator()(T) const { - typedef vtkm::cont::ArrayHandle ArrayHandleType; + using ArrayHandleType = vtkm::cont::ArrayHandle; - typedef vtkm::cont::arg::Transport - TransportType; + using TransportType = + vtkm::cont::arg::Transport; ArrayHandleType array; array.Allocate(1); diff --git a/vtkm/cont/arg/testing/UnitTestTypeCheckArray.cxx b/vtkm/cont/arg/testing/UnitTestTypeCheckArray.cxx index daddcbe22..a219e45f6 100644 --- a/vtkm/cont/arg/testing/UnitTestTypeCheckArray.cxx +++ b/vtkm/cont/arg/testing/UnitTestTypeCheckArray.cxx @@ -36,23 +36,23 @@ struct TryArraysOfType void operator()(T) const { using vtkm::cont::arg::TypeCheck; - typedef vtkm::cont::arg::TypeCheckTagArray TypeCheckTagArray; + using TypeCheckTagArray = vtkm::cont::arg::TypeCheckTagArray; - typedef vtkm::cont::ArrayHandle StandardArray; + using StandardArray = vtkm::cont::ArrayHandle; VTKM_TEST_ASSERT((TypeCheck::value), "Standard array type check failed."); - typedef vtkm::cont::ArrayHandleCounting CountingArray; + using CountingArray = vtkm::cont::ArrayHandleCounting; VTKM_TEST_ASSERT((TypeCheck::value), "Counting array type check failed."); - typedef typename vtkm::cont::ArrayHandleCompositeVectorType::type - CompositeArray; + using CompositeArray = + typename vtkm::cont::ArrayHandleCompositeVectorType::type; VTKM_TEST_ASSERT((TypeCheck::value), "Composite array type check failed."); // Just some type that is not a valid array. - typedef typename StandardArray::PortalControl NotAnArray; + using NotAnArray = typename StandardArray::PortalControl; VTKM_TEST_ASSERT(!(TypeCheck::value), "Not an array type check failed."); @@ -67,25 +67,25 @@ void TestCheckAtomicArray() using vtkm::cont::arg::TypeCheck; using vtkm::cont::arg::TypeCheckTagAtomicArray; - typedef vtkm::cont::ArrayHandle Int32Array; - typedef vtkm::cont::ArrayHandle Int64Array; - typedef vtkm::cont::ArrayHandle FloatArray; + using Int32Array = vtkm::cont::ArrayHandle; + using Int64Array = vtkm::cont::ArrayHandle; + using FloatArray = vtkm::cont::ArrayHandle; - typedef TypeCheckTagAtomicArray<> DefaultTypeCheck; + using DefaultTypeCheck = TypeCheckTagAtomicArray<>; VTKM_TEST_ASSERT((TypeCheck::value), "Check for 32-bit int failed."); VTKM_TEST_ASSERT((TypeCheck::value), "Check for 64-bit int failed."); VTKM_TEST_ASSERT(!(TypeCheck::value), "Check for float failed."); - typedef TypeCheckTagAtomicArray ExpandedTypeCheck; + using ExpandedTypeCheck = TypeCheckTagAtomicArray; VTKM_TEST_ASSERT((TypeCheck::value), "Check for 32-bit int failed."); VTKM_TEST_ASSERT((TypeCheck::value), "Check for 64-bit int failed."); VTKM_TEST_ASSERT(!(TypeCheck::value), "Check for float failed."); - typedef TypeCheckTagAtomicArray> RestrictedTypeCheck; + using RestrictedTypeCheck = TypeCheckTagAtomicArray>; VTKM_TEST_ASSERT((TypeCheck::value), "Check for 32-bit int failed."); VTKM_TEST_ASSERT(!(TypeCheck::value), @@ -101,13 +101,13 @@ void TestCheckArray() using vtkm::cont::arg::TypeCheck; using vtkm::cont::arg::TypeCheckTagArray; - typedef vtkm::cont::ArrayHandle ScalarArray; + using ScalarArray = vtkm::cont::ArrayHandle; VTKM_TEST_ASSERT((TypeCheck, ScalarArray>::value), "Scalar for scalar check failed."); VTKM_TEST_ASSERT(!(TypeCheck, ScalarArray>::value), "Scalar for vector check failed."); - typedef vtkm::cont::ArrayHandle> VecArray; + using VecArray = vtkm::cont::ArrayHandle>; VTKM_TEST_ASSERT((TypeCheck, VecArray>::value), "Vector for vector check failed."); VTKM_TEST_ASSERT(!(TypeCheck, VecArray>::value), diff --git a/vtkm/cont/cuda/internal/ArrayManagerExecutionCuda.h b/vtkm/cont/cuda/internal/ArrayManagerExecutionCuda.h index 3023bd83e..a8f3cd58c 100644 --- a/vtkm/cont/cuda/internal/ArrayManagerExecutionCuda.h +++ b/vtkm/cont/cuda/internal/ArrayManagerExecutionCuda.h @@ -41,11 +41,11 @@ class ArrayManagerExecution : public vtkm::cont::cuda::internal::ArrayManagerExecutionThrustDevice { public: - typedef vtkm::cont::cuda::internal::ArrayManagerExecutionThrustDevice Superclass; - typedef typename Superclass::ValueType ValueType; - typedef typename Superclass::PortalType PortalType; - typedef typename Superclass::PortalConstType PortalConstType; - typedef typename Superclass::StorageType StorageType; + using Superclass = vtkm::cont::cuda::internal::ArrayManagerExecutionThrustDevice; + using ValueType = typename Superclass::ValueType; + using PortalType = typename Superclass::PortalType; + using PortalConstType = typename Superclass::PortalConstType; + using StorageType = typename Superclass::StorageType; VTKM_CONT ArrayManagerExecution(StorageType* storage) diff --git a/vtkm/cont/cuda/internal/ArrayManagerExecutionThrustDevice.h b/vtkm/cont/cuda/internal/ArrayManagerExecutionThrustDevice.h index 8798ad260..57426c8f1 100644 --- a/vtkm/cont/cuda/internal/ArrayManagerExecutionThrustDevice.h +++ b/vtkm/cont/cuda/internal/ArrayManagerExecutionThrustDevice.h @@ -59,14 +59,14 @@ template class ArrayManagerExecutionThrustDevice { public: - typedef T ValueType; - typedef typename thrust::system::cuda::pointer PointerType; - typedef typename PointerType::difference_type difference_type; + using ValueType = T; + using PointerType = typename thrust::system::cuda::pointer; + using difference_type = typename PointerType::difference_type; - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; - typedef vtkm::exec::cuda::internal::ArrayPortalFromThrust PortalType; - typedef vtkm::exec::cuda::internal::ConstArrayPortalFromThrust PortalConstType; + using PortalType = vtkm::exec::cuda::internal::ArrayPortalFromThrust; + using PortalConstType = vtkm::exec::cuda::internal::ConstArrayPortalFromThrust; VTKM_CONT ArrayManagerExecutionThrustDevice(StorageType* storage) diff --git a/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmCuda.h b/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmCuda.h index 887ed304e..df9cea648 100644 --- a/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmCuda.h +++ b/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmCuda.h @@ -213,8 +213,9 @@ public: } private: - typedef typename vtkm::cont::ArrayHandle::template ExecutionTypes< - vtkm::cont::DeviceAdapterTagCuda>::Portal PortalType; + using PortalType = + typename vtkm::cont::ArrayHandle::template ExecutionTypes< + vtkm::cont::DeviceAdapterTagCuda>::Portal; PortalType Portal; inline __device__ vtkm::Int64 vtkmAtomicAdd(vtkm::Int64* address, const vtkm::Int64& value) const diff --git a/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h b/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h index f340312ca..95d2111a4 100644 --- a/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h +++ b/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h @@ -216,9 +216,10 @@ private: OutputPortal output, UnaryPredicate unary_predicate) { - using ValueType = typename StencilPortal::ValueType; + using IteratorType = typename detail::IteratorTraits::IteratorType; + IteratorType outputBegin = IteratorBegin(output); - auto outputBegin = IteratorBegin(output); + using ValueType = typename StencilPortal::ValueType; vtkm::exec::cuda::internal::WrappedUnaryPredicate up( unary_predicate); @@ -626,7 +627,7 @@ private: template VTKM_CONT static void SortByKeyPortal(const KeysPortal& keys, const ValuesPortal& values) { - typedef typename KeysPortal::ValueType ValueType; + using ValueType = typename KeysPortal::ValueType; SortByKeyPortal(keys, values, ::thrust::less()); } @@ -710,7 +711,7 @@ private: const OutputPortal& output, BinaryCompare binary_compare) { - typedef typename OutputPortal::ValueType ValueType; + using ValueType = typename OutputPortal::ValueType; vtkm::exec::cuda::internal::WrappedBinaryPredicate bop( binary_compare); diff --git a/vtkm/cont/cuda/internal/MakeThrustIterator.h b/vtkm/cont/cuda/internal/MakeThrustIterator.h index f6280eb78..5a0ba0f08 100644 --- a/vtkm/cont/cuda/internal/MakeThrustIterator.h +++ b/vtkm/cont/cuda/internal/MakeThrustIterator.h @@ -59,17 +59,17 @@ struct ThrustIteratorDevicePtrTag template struct ThrustIteratorTag { - typedef ThrustIteratorFromArrayPortalTag Type; + using Type = ThrustIteratorFromArrayPortalTag; }; template struct ThrustIteratorTag> { - typedef ThrustIteratorDevicePtrTag Type; + using Type = ThrustIteratorDevicePtrTag; }; template struct ThrustIteratorTag> { - typedef ThrustIteratorDevicePtrTag Type; + using Type = ThrustIteratorDevicePtrTag; }; template @@ -77,22 +77,22 @@ struct IteratorChooser; template struct IteratorChooser { - typedef vtkm::exec::cuda::internal::IteratorFromArrayPortal Type; + using Type = vtkm::exec::cuda::internal::IteratorFromArrayPortal; }; template struct IteratorChooser { - typedef vtkm::cont::ArrayPortalToIterators PortalToIteratorType; + using PortalToIteratorType = vtkm::cont::ArrayPortalToIterators; - typedef typename PortalToIteratorType::IteratorType Type; + using Type = typename PortalToIteratorType::IteratorType; }; template struct IteratorTraits { - typedef vtkm::cont::ArrayPortalToIterators PortalToIteratorType; - typedef typename detail::ThrustIteratorTag::Type Tag; - typedef typename IteratorChooser::Type IteratorType; + using PortalToIteratorType = vtkm::cont::ArrayPortalToIterators; + using Tag = typename detail::ThrustIteratorTag::Type; + using IteratorType = typename IteratorChooser::Type; }; template @@ -136,14 +136,14 @@ VTKM_CONT typename IteratorTraits::IteratorType MakeIteratorEnd( template VTKM_CONT typename detail::IteratorTraits::IteratorType IteratorBegin(PortalType portal) { - typedef typename detail::IteratorTraits::Tag IteratorTag; + using IteratorTag = typename detail::IteratorTraits::Tag; return detail::MakeIteratorBegin(portal, IteratorTag()); } template VTKM_CONT typename detail::IteratorTraits::IteratorType IteratorEnd(PortalType portal) { - typedef typename detail::IteratorTraits::Tag IteratorTag; + using IteratorTag = typename detail::IteratorTraits::Tag; return detail::MakeIteratorEnd(portal, IteratorTag()); } } diff --git a/vtkm/cont/cuda/internal/ThrustExceptionHandler.h b/vtkm/cont/cuda/internal/ThrustExceptionHandler.h index ec0f210a7..56df31b88 100644 --- a/vtkm/cont/cuda/internal/ThrustExceptionHandler.h +++ b/vtkm/cont/cuda/internal/ThrustExceptionHandler.h @@ -58,4 +58,4 @@ static inline void throwAsVTKmException() } } -#endif \ No newline at end of file +#endif //vtk_m_cont_cuda_interal_ThrustExecptionHandler_h diff --git a/vtkm/cont/serial/internal/ArrayManagerExecutionSerial.h b/vtkm/cont/serial/internal/ArrayManagerExecutionSerial.h index aa77a7ec6..cf99dea55 100644 --- a/vtkm/cont/serial/internal/ArrayManagerExecutionSerial.h +++ b/vtkm/cont/serial/internal/ArrayManagerExecutionSerial.h @@ -37,7 +37,7 @@ class ArrayManagerExecution : public vtkm::cont::internal::ArrayManagerExecutionShareWithControl { public: - typedef vtkm::cont::internal::ArrayManagerExecutionShareWithControl Superclass; + using Superclass = vtkm::cont::internal::ArrayManagerExecutionShareWithControl; using ValueType = typename Superclass::ValueType; using PortalType = typename Superclass::PortalType; using PortalConstType = typename Superclass::PortalConstType; diff --git a/vtkm/cont/tbb/internal/ArrayManagerExecutionTBB.h b/vtkm/cont/tbb/internal/ArrayManagerExecutionTBB.h index ce61a00c7..1789435b3 100644 --- a/vtkm/cont/tbb/internal/ArrayManagerExecutionTBB.h +++ b/vtkm/cont/tbb/internal/ArrayManagerExecutionTBB.h @@ -41,7 +41,7 @@ class ArrayManagerExecution : public vtkm::cont::internal::ArrayManagerExecutionShareWithControl { public: - typedef vtkm::cont::internal::ArrayManagerExecutionShareWithControl Superclass; + using Superclass = vtkm::cont::internal::ArrayManagerExecutionShareWithControl; using ValueType = typename Superclass::ValueType; using PortalType = typename Superclass::PortalType; using PortalConstType = typename Superclass::PortalConstType; diff --git a/vtkm/cont/tbb/internal/DeviceAdapterAlgorithmTBB.h b/vtkm/cont/tbb/internal/DeviceAdapterAlgorithmTBB.h index 1fe3f6a3c..f5909880c 100644 --- a/vtkm/cont/tbb/internal/DeviceAdapterAlgorithmTBB.h +++ b/vtkm/cont/tbb/internal/DeviceAdapterAlgorithmTBB.h @@ -136,8 +136,8 @@ public: VTKM_CONT static void Sort(vtkm::cont::ArrayHandle& values, BinaryCompare binary_compare) { - typedef typename vtkm::cont::ArrayHandle::template ExecutionTypes< - vtkm::cont::DeviceAdapterTagTBB>::Portal PortalType; + using PortalType = typename vtkm::cont::ArrayHandle::template ExecutionTypes< + vtkm::cont::DeviceAdapterTagTBB>::Portal; PortalType arrayPortal = values.PrepareForInPlace(vtkm::cont::DeviceAdapterTagTBB()); using IteratorsType = vtkm::cont::ArrayPortalToIterators; @@ -167,7 +167,7 @@ public: using ValueType = vtkm::cont::ArrayHandle; using IndexType = vtkm::cont::ArrayHandle; - typedef vtkm::cont::ArrayHandleZip ZipHandleType; + using ZipHandleType = vtkm::cont::ArrayHandleZip; IndexType indexArray; ValueType valuesScattered; @@ -187,7 +187,7 @@ public: else { using ValueType = vtkm::cont::ArrayHandle; - typedef vtkm::cont::ArrayHandleZip ZipHandleType; + using ZipHandleType = vtkm::cont::ArrayHandleZip; ZipHandleType zipHandle = vtkm::cont::make_ArrayHandleZip(keys, values); Sort(zipHandle, vtkm::cont::internal::KeyCompare(comp)); diff --git a/vtkm/cont/tbb/internal/FunctorsTBB.h b/vtkm/cont/tbb/internal/FunctorsTBB.h index 6d82f4aec..18d9fc131 100644 --- a/vtkm/cont/tbb/internal/FunctorsTBB.h +++ b/vtkm/cont/tbb/internal/FunctorsTBB.h @@ -171,7 +171,7 @@ VTKM_CONT static T ReducePortals(InputPortalType inputPortal, T initialValue, BinaryOperationType binaryOperation) { - typedef internal::WrappedBinaryOperator WrappedBinaryOp; + using WrappedBinaryOp = internal::WrappedBinaryOperator; WrappedBinaryOp wrappedBinaryOp(binaryOperation); ReduceBody body(inputPortal, initialValue, wrappedBinaryOp); @@ -399,7 +399,7 @@ ScanInclusivePortals(InputPortalType inputPortal, { using ValueType = typename std::remove_reference::type; - typedef internal::WrappedBinaryOperator WrappedBinaryOp; + using WrappedBinaryOp = internal::WrappedBinaryOperator; WrappedBinaryOp wrappedBinaryOp(binaryOperation); ScanInclusiveBody body( @@ -422,7 +422,7 @@ ScanExclusivePortals( { using ValueType = typename std::remove_reference::type; - typedef internal::WrappedBinaryOperator WrappedBinaryOp; + using WrappedBinaryOp = internal::WrappedBinaryOperator; WrappedBinaryOp wrappedBinaryOp(binaryOperation); ScanExclusiveBody body( diff --git a/vtkm/cont/testing/MakeTestDataSet.h b/vtkm/cont/testing/MakeTestDataSet.h index 0851d79b6..f57d7ef08 100644 --- a/vtkm/cont/testing/MakeTestDataSet.h +++ b/vtkm/cont/testing/MakeTestDataSet.h @@ -91,7 +91,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet0() inline vtkm::cont::DataSet MakeTestDataSet::Make1DExplicitDataSet0() { const int nVerts = 5; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coords(nVerts); coords[0] = CoordType(0.0f, 0.f, 0.f); coords[1] = CoordType(1.0f, 0.f, 0.f); @@ -349,7 +349,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DExplicitDataSet0() // Coordinates const int nVerts = 16; const int nCells = 7; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coords(nVerts); coords[0] = CoordType(0, 0, 0); @@ -441,7 +441,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet0() vtkm::cont::DataSetBuilderExplicit dsb; const int nVerts = 5; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coords(nVerts); coords[0] = CoordType(0, 0, 0); coords[1] = CoordType(1, 0, 0); @@ -522,7 +522,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet1() vtkm::cont::DataSetBuilderExplicit dsb; const int nVerts = 5; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coords(nVerts); coords[0] = CoordType(0, 0, 0); @@ -560,7 +560,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet2() vtkm::cont::DataSet dataSet; const int nVerts = 8; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; CoordType coordinates[nVerts] = { CoordType(0, 0, 0), // 0 CoordType(1, 0, 0), // 1 @@ -608,7 +608,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet4() vtkm::cont::DataSet dataSet; const int nVerts = 12; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; CoordType coordinates[nVerts] = { CoordType(0, 0, 0), //0 CoordType(1, 0, 0), //1 @@ -670,7 +670,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet3() vtkm::cont::DataSet dataSet; const int nVerts = 4; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; CoordType coordinates[nVerts] = { CoordType(0, 0, 0), CoordType(1, 0, 0), CoordType(1, 0, 1), CoordType(0, 1, 0) }; @@ -707,7 +707,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet5() vtkm::cont::DataSet dataSet; const int nVerts = 11; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; CoordType coordinates[nVerts] = { CoordType(0, 0, 0), //0 CoordType(1, 0, 0), //1 @@ -787,7 +787,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet6() // Coordinates const int nVerts = 8; const int nCells = 8; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coords = { { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, { 0.000f, -0.146f, 0.854f }, { -0.707f, 0.354f, 0.354f }, { 10.0f, 10.0f, 10.0f }, { 5.0f, 5.0f, 5.0f }, @@ -864,7 +864,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetPolygonal() // Coordinates const int nVerts = 8; const int nCells = 8; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coords = { { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, { 0.000f, -0.146f, 0.854f }, { -0.707f, 0.354f, 0.354f }, { 0.000f, 0.146f, -0.854f }, { 0.000f, 0.854f, -0.146f }, @@ -943,7 +943,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetCowNose() { // prepare data array const int nVerts = 17; - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; CoordType coordinates[nVerts] = { CoordType(0.0480879, 0.151874, 0.107334), CoordType(0.0293568, 0.245532, 0.125337), CoordType(0.0224398, 0.246495, 0.1351), CoordType(0.0180085, 0.20436, 0.145316), diff --git a/vtkm/cont/testing/TestingArrayHandles.h b/vtkm/cont/testing/TestingArrayHandles.h index cf3b3eabf..6ac67c709 100644 --- a/vtkm/cont/testing/TestingArrayHandles.h +++ b/vtkm/cont/testing/TestingArrayHandles.h @@ -123,7 +123,7 @@ private: using Algorithm = vtkm::cont::DeviceAdapterAlgorithm; - typedef vtkm::worklet::DispatcherMapField DispatcherPassThrough; + using DispatcherPassThrough = vtkm::worklet::DispatcherMapField; struct VerifyEmptyArrays { template diff --git a/vtkm/cont/testing/TestingDataSetSingleType.h b/vtkm/cont/testing/TestingDataSetSingleType.h index 5842afe66..9c8ec56dc 100644 --- a/vtkm/cont/testing/TestingDataSetSingleType.h +++ b/vtkm/cont/testing/TestingDataSetSingleType.h @@ -68,7 +68,7 @@ private: static inline vtkm::cont::DataSet make_SingleTypeDataSet() { - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coordinates; coordinates.push_back(CoordType(0, 0, 0)); coordinates.push_back(CoordType(1, 0, 0)); diff --git a/vtkm/cont/testing/TestingDeviceAdapter.h b/vtkm/cont/testing/TestingDeviceAdapter.h index 78509fb77..3826df73f 100644 --- a/vtkm/cont/testing/TestingDeviceAdapter.h +++ b/vtkm/cont/testing/TestingDeviceAdapter.h @@ -72,14 +72,14 @@ struct TestingDeviceAdapter private: using StorageTag = vtkm::cont::StorageTagBasic; - typedef vtkm::cont::ArrayHandle IdArrayHandle; + using IdArrayHandle = vtkm::cont::ArrayHandle; - typedef vtkm::cont::ArrayHandle ScalarArrayHandle; + using ScalarArrayHandle = vtkm::cont::ArrayHandle; - typedef vtkm::cont::internal::ArrayManagerExecution - IdArrayManagerExecution; + using IdArrayManagerExecution = + vtkm::cont::internal::ArrayManagerExecution; - typedef vtkm::cont::internal::Storage IdStorage; + using IdStorage = vtkm::cont::internal::Storage; using IdPortalType = typename IdArrayHandle::template ExecutionTypes::Portal; using IdPortalConstType = @@ -385,10 +385,10 @@ private: std::cout << "-------------------------------------------" << std::endl; std::cout << "Testing ArrayManagerExecution" << std::endl; - typedef vtkm::cont::internal::ArrayManagerExecution - ArrayManagerExecution; + using ArrayManagerExecution = + vtkm::cont::internal::ArrayManagerExecution; - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; // Create original input array. StorageType storage; @@ -907,8 +907,8 @@ private: std::cout << "-------------------------------------------------" << std::endl; std::cout << "Sort by keys" << std::endl; - typedef vtkm::Vec Vec3; - typedef vtkm::cont::ArrayHandle, StorageTag> Vec3ArrayHandle; + using Vec3 = vtkm::Vec; + using Vec3ArrayHandle = vtkm::cont::ArrayHandle, StorageTag>; std::vector testKeys(ARRAY_SIZE); std::vector testValues(testKeys.size()); @@ -1134,7 +1134,7 @@ private: vtkm::cont::ArrayHandleZip zipped(keys, values); //the output of reduce and scan inclusive should be the same - typedef vtkm::Pair ResultType; + using ResultType = vtkm::Pair; ResultType reduce_sum_with_intial_value = Algorithm::Reduce(zipped, ResultType(ARRAY_SIZE, ARRAY_SIZE)); @@ -1272,7 +1272,7 @@ private: }; // output values 2 IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength); - typedef vtkm::cont::ArrayHandle ValueArrayType; + using ValueArrayType = vtkm::cont::ArrayHandle; ValueArrayType values1 = vtkm::cont::make_ArrayHandle(inputValues1, inputLength); using ConstValueArrayType = vtkm::cont::ArrayHandleConstant; ConstValueArrayType constOneArray(1.f, inputLength); @@ -1625,8 +1625,8 @@ private: std::cout << "Testing Inclusive Scan with a vtkm::Vec" << std::endl; { - typedef vtkm::Vec Vec3; - typedef vtkm::cont::ArrayHandle, StorageTag> Vec3ArrayHandle; + using Vec3 = vtkm::Vec; + using Vec3ArrayHandle = vtkm::cont::ArrayHandle, StorageTag>; std::vector testValues(ARRAY_SIZE); @@ -1762,8 +1762,8 @@ private: std::cout << "Testing Exclusive Scan with a vtkm::Vec" << std::endl; { - typedef vtkm::Vec Vec3; - typedef vtkm::cont::ArrayHandle, StorageTag> Vec3ArrayHandle; + using Vec3 = vtkm::Vec; + using Vec3ArrayHandle = vtkm::cont::ArrayHandle, StorageTag>; std::vector testValues(ARRAY_SIZE); diff --git a/vtkm/cont/testing/TestingFancyArrayHandles.h b/vtkm/cont/testing/TestingFancyArrayHandles.h index 04aa76264..dafde723b 100644 --- a/vtkm/cont/testing/TestingFancyArrayHandles.h +++ b/vtkm/cont/testing/TestingFancyArrayHandles.h @@ -54,7 +54,7 @@ struct IndexSquared VTKM_EXEC_CONT ValueType operator()(vtkm::Id index) const { - typedef typename vtkm::VecTraits::ComponentType ComponentType; + using ComponentType = typename vtkm::VecTraits::ComponentType; return ValueType(static_cast(index * index)); } }; @@ -84,8 +84,8 @@ struct ValueScale template VTKM_EXEC_CONT ValueType operator()(const ValueType& v) const { - typedef vtkm::VecTraits Traits; - typedef typename Traits::ComponentType ComponentType; + using Traits = vtkm::VecTraits; + using ComponentType = typename Traits::ComponentType; ValueType result; for (vtkm::IdComponent i = 0; i < Traits::GetNumberOfComponents(v); ++i) @@ -156,10 +156,10 @@ private: //hard-coded to make a vtkm::Vec composite vector //for each ValueType. - typedef typename vtkm::cont::ArrayHandleCompositeVectorType< + using CompositeHandleType = typename vtkm::cont::ArrayHandleCompositeVectorType< vtkm::cont::ArrayHandle, vtkm::cont::ArrayHandle, - vtkm::cont::ArrayHandle>::type CompositeHandleType; + vtkm::cont::ArrayHandle>::type; const ValueType value = TestValue(13, ValueType()); std::vector compositeData(ARRAY_SIZE, value); @@ -224,7 +224,7 @@ private: template VTKM_CONT void operator()(const ValueType vtkmNotUsed(v)) const { - typedef typename vtkm::VecTraits::ComponentType ComponentType; + using ComponentType = typename vtkm::VecTraits::ComponentType; const vtkm::Id length = ARRAY_SIZE; @@ -262,7 +262,7 @@ private: VTKM_CONT void operator()(const ValueType vtkmNotUsed(v)) const { const vtkm::Id length = ARRAY_SIZE; - typedef ::fancy_array_detail::IndexSquared FunctorType; + using FunctorType = ::fancy_array_detail::IndexSquared; FunctorType functor; vtkm::cont::ArrayHandleImplicit implicit = @@ -295,12 +295,12 @@ private: { const vtkm::Id length = ARRAY_SIZE; - typedef ::fancy_array_detail::IndexSquared FunctorType; - typedef typename vtkm::VecTraits::ComponentType ComponentType; + using FunctorType = ::fancy_array_detail::IndexSquared; + using ComponentType = typename vtkm::VecTraits::ComponentType; - typedef vtkm::cont::ArrayHandleImplicit ValueHandleType; - typedef vtkm::cont::ArrayHandle BasicArrayType; - typedef vtkm::cont::ArrayHandleConcatenate ConcatenateType; + using ValueHandleType = vtkm::cont::ArrayHandleImplicit; + using BasicArrayType = vtkm::cont::ArrayHandle; + using ConcatenateType = vtkm::cont::ArrayHandleConcatenate; FunctorType functor; for (vtkm::Id start_pos = 0; start_pos < length; start_pos += length / 4) @@ -355,12 +355,12 @@ private: { const vtkm::Id length = ARRAY_SIZE; - typedef ::fancy_array_detail::IndexSquared FunctorType; + using FunctorType = ::fancy_array_detail::IndexSquared; - typedef vtkm::cont::ArrayHandleCounting KeyHandleType; - typedef vtkm::cont::ArrayHandleImplicit ValueHandleType; - typedef vtkm::cont::ArrayHandlePermutation - PermutationHandleType; + using KeyHandleType = vtkm::cont::ArrayHandleCounting; + using ValueHandleType = vtkm::cont::ArrayHandleImplicit; + using PermutationHandleType = + vtkm::cont::ArrayHandlePermutation; FunctorType functor; for (vtkm::Id start_pos = 0; start_pos < length; start_pos += length / 4) @@ -404,7 +404,7 @@ private: template VTKM_CONT void operator()(const ValueType vtkmNotUsed(v)) const { - typedef fancy_array_detail::ValueScale FunctorType; + using FunctorType = fancy_array_detail::ValueScale; const vtkm::Id length = ARRAY_SIZE; FunctorType functor(2.0); @@ -441,9 +441,9 @@ private: template VTKM_CONT void operator()(const ValueType vtkmNotUsed(v)) const { - typedef typename vtkm::VecTraits::ComponentType ComponentType; - typedef ComponentType OutputValueType; - typedef fancy_array_detail::ValueSquared FunctorType; + using ComponentType = typename vtkm::VecTraits::ComponentType; + using OutputValueType = ComponentType; + using FunctorType = fancy_array_detail::ValueSquared; vtkm::Id length = ARRAY_SIZE; FunctorType functor; @@ -485,7 +485,7 @@ private: template VTKM_CONT void operator()(CastToType vtkmNotUsed(type)) const { - typedef vtkm::cont::ArrayHandleIndex InputArrayType; + using InputArrayType = vtkm::cont::ArrayHandleIndex; InputArrayType input(ARRAY_SIZE); vtkm::cont::ArrayHandleCast castArray = @@ -515,7 +515,7 @@ private: template VTKM_CONT void operator()(ComponentType) const { - typedef vtkm::Vec ValueType; + using ValueType = vtkm::Vec; ComponentType testValues[ARRAY_SIZE * NUM_COMPONENTS]; @@ -564,7 +564,7 @@ private: template VTKM_CONT void operator()(ComponentType) const { - typedef vtkm::Vec ValueType; + using ValueType = vtkm::Vec; vtkm::cont::ArrayHandle baseArray; baseArray.Allocate(ARRAY_SIZE); @@ -721,9 +721,9 @@ private: template VTKM_CONT void operator()(vtkm::Pair vtkmNotUsed(pair)) const { - typedef vtkm::Pair PairType; - typedef typename vtkm::VecTraits::ComponentType KeyComponentType; - typedef typename vtkm::VecTraits::ComponentType ValueComponentType; + using PairType = vtkm::Pair; + using KeyComponentType = typename vtkm::VecTraits::ComponentType; + using ValueComponentType = typename vtkm::VecTraits::ComponentType; KeyType testKeys[ARRAY_SIZE]; ValueType testValues[ARRAY_SIZE]; @@ -768,7 +768,7 @@ private: using DiscardHandleType = vtkm::cont::ArrayHandleDiscard; using ComponentType = typename vtkm::VecTraits::ComponentType; - typedef typename vtkm::cont::ArrayHandle::PortalControl Portal; + using Portal = typename vtkm::cont::ArrayHandle::PortalControl; const vtkm::Id length = ARRAY_SIZE; @@ -798,14 +798,14 @@ private: { const vtkm::Id length = ARRAY_SIZE; - typedef vtkm::cont::ArrayHandleCounting KeyHandleType; - typedef vtkm::cont::ArrayHandle ValueHandleType; - typedef vtkm::cont::ArrayHandlePermutation - PermutationHandleType; + using KeyHandleType = vtkm::cont::ArrayHandleCounting; + using ValueHandleType = vtkm::cont::ArrayHandle; + using PermutationHandleType = + vtkm::cont::ArrayHandlePermutation; - typedef typename vtkm::VecTraits::ComponentType ComponentType; + using ComponentType = typename vtkm::VecTraits::ComponentType; vtkm::cont::ArrayHandle input; - typedef typename vtkm::cont::ArrayHandle::PortalControl Portal; + using Portal = typename vtkm::cont::ArrayHandle::PortalControl; input.Allocate(length); Portal inputPortal = input.GetPortalControl(); for (vtkm::Id i = 0; i < length; ++i) @@ -841,9 +841,9 @@ private: template VTKM_CONT void operator()(vtkm::Pair vtkmNotUsed(pair)) const { - typedef vtkm::Pair PairType; - typedef typename vtkm::VecTraits::ComponentType KeyComponentType; - typedef typename vtkm::VecTraits::ComponentType ValueComponentType; + using PairType = vtkm::Pair; + using KeyComponentType = typename vtkm::VecTraits::ComponentType; + using ValueComponentType = typename vtkm::VecTraits::ComponentType; PairType testKeysAndValues[ARRAY_SIZE]; for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i) diff --git a/vtkm/cont/testing/TestingImplicitFunction.h b/vtkm/cont/testing/TestingImplicitFunction.h index 3c4c26822..9e789402f 100644 --- a/vtkm/cont/testing/TestingImplicitFunction.h +++ b/vtkm/cont/testing/TestingImplicitFunction.h @@ -71,7 +71,7 @@ void EvaluateOnCoordinates(vtkm::cont::CoordinateSystem points, vtkm::cont::ArrayHandle& values, DeviceAdapter device) { - typedef vtkm::worklet::DispatcherMapField EvalDispatcher; + using EvalDispatcher = vtkm::worklet::DispatcherMapField; EvaluateImplicitFunction eval(function.PrepareForExecution(device)); EvalDispatcher(eval).Invoke(points, values); diff --git a/vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx b/vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx index 3a60d74ae..df2e6a679 100644 --- a/vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx +++ b/vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx @@ -67,7 +67,7 @@ vtkm::cont::ArrayHandle MakeInputArray(int arrayId) } // Make an array handle that points to this buffer. - typedef vtkm::cont::ArrayHandle ArrayHandleType; + using ArrayHandleType = vtkm::cont::ArrayHandle; ArrayHandleType bufferHandle = vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE); // When this function returns, the array is going to go out of scope, which @@ -87,7 +87,7 @@ void CheckArray(const vtkm::cont::ArrayHandle& outArray, { // ArrayHandleCompositeVector currently does not implement the ability to // get to values on the control side, so copy to an array that is accessible. - typedef vtkm::cont::ArrayHandle ArrayHandleType; + using ArrayHandleType = vtkm::cont::ArrayHandle; ArrayHandleType arrayCopy; vtkm::cont::DeviceAdapterAlgorithm::Copy(outArray, arrayCopy); @@ -113,8 +113,8 @@ void TryScalarArray() std::cout << "Creating a scalar array from one of " << inComponents << " components." << std::endl; - typedef vtkm::Vec InValueType; - typedef vtkm::cont::ArrayHandle InArrayType; + using InValueType = vtkm::Vec; + using InArrayType = vtkm::cont::ArrayHandle; int inArrayId = 0; InArrayType inArray = MakeInputArray(inArrayId); @@ -259,8 +259,8 @@ void TrySpecialArrays() using ArrayType2 = vtkm::cont::ArrayHandleConstant; ArrayType2 array2(295, ARRAY_SIZE); - typedef vtkm::cont::ArrayHandleCompositeVectorType::type - CompositeArrayType; + using CompositeArrayType = + vtkm::cont::ArrayHandleCompositeVectorType::type; CompositeArrayType compositeArray = vtkm::cont::make_ArrayHandleCompositeVector(array1, 0, array2, 0); @@ -281,7 +281,7 @@ void TestBadArrayLengths() { std::cout << "Checking behavior when size of input arrays do not agree." << std::endl; - typedef vtkm::cont::ArrayHandle InArrayType; + using InArrayType = vtkm::cont::ArrayHandle; InArrayType longInArray = MakeInputArray(0); InArrayType shortInArray = MakeInputArray(1); shortInArray.Shrink(ARRAY_SIZE / 2); diff --git a/vtkm/cont/testing/UnitTestArrayHandleConcatenate.cxx b/vtkm/cont/testing/UnitTestArrayHandleConcatenate.cxx index e7a1bb92b..4fa46728f 100644 --- a/vtkm/cont/testing/UnitTestArrayHandleConcatenate.cxx +++ b/vtkm/cont/testing/UnitTestArrayHandleConcatenate.cxx @@ -60,8 +60,8 @@ void TestConcatenateEmptyArray() using CoeffValueType = vtkm::Float64; using CoeffArrayTypeTmp = vtkm::cont::ArrayHandle; - typedef vtkm::cont::ArrayHandleConcatenate ArrayConcat; - typedef vtkm::cont::ArrayHandleConcatenate ArrayConcat2; + using ArrayConcat = vtkm::cont::ArrayHandleConcatenate; + using ArrayConcat2 = vtkm::cont::ArrayHandleConcatenate; CoeffArrayTypeTmp arr1 = vtkm::cont::make_ArrayHandle(vec); CoeffArrayTypeTmp arr2, arr3; diff --git a/vtkm/cont/testing/UnitTestArrayHandleCounting.cxx b/vtkm/cont/testing/UnitTestArrayHandleCounting.cxx index 07e160d67..a515ec701 100644 --- a/vtkm/cont/testing/UnitTestArrayHandleCounting.cxx +++ b/vtkm/cont/testing/UnitTestArrayHandleCounting.cxx @@ -90,9 +90,9 @@ struct TemplatedTests { using ArrayHandleType = vtkm::cont::ArrayHandleCounting; - typedef vtkm::cont:: - ArrayHandle::Tag> - ArrayHandleType2; + using ArrayHandleType2 = vtkm::cont::ArrayHandle< + ValueType, + typename vtkm::cont::internal::ArrayHandleCountingTraits::Tag>; using PortalType = typename ArrayHandleType::PortalConstControl; diff --git a/vtkm/cont/testing/UnitTestArrayHandlePermutation.cxx b/vtkm/cont/testing/UnitTestArrayHandlePermutation.cxx index e1be4f241..c1ae47476 100644 --- a/vtkm/cont/testing/UnitTestArrayHandlePermutation.cxx +++ b/vtkm/cont/testing/UnitTestArrayHandlePermutation.cxx @@ -186,8 +186,8 @@ template struct PermutationTests { using IndexArrayType = vtkm::cont::ArrayHandleImplicit; - typedef vtkm::cont::ArrayHandle ValueArrayType; - typedef vtkm::cont::ArrayHandlePermutation PermutationArrayType; + using ValueArrayType = vtkm::cont::ArrayHandle; + using PermutationArrayType = vtkm::cont::ArrayHandlePermutation; using Device = VTKM_DEFAULT_DEVICE_ADAPTER_TAG; using Algorithm = vtkm::cont::DeviceAdapterAlgorithm; diff --git a/vtkm/cont/testing/UnitTestArrayHandleTransform.cxx b/vtkm/cont/testing/UnitTestArrayHandleTransform.cxx index a0c067293..8baca8bd8 100644 --- a/vtkm/cont/testing/UnitTestArrayHandleTransform.cxx +++ b/vtkm/cont/testing/UnitTestArrayHandleTransform.cxx @@ -117,12 +117,11 @@ struct TransformTests using OutputValueType = typename vtkm::VecTraits::ComponentType; using FunctorType = MySquare; - typedef vtkm::cont::ArrayHandleTransform, FunctorType> - TransformHandle; + using TransformHandle = + vtkm::cont::ArrayHandleTransform, FunctorType>; - typedef vtkm::cont::ArrayHandleTransform, - FunctorType> - CountingTransformHandle; + using CountingTransformHandle = + vtkm::cont::ArrayHandleTransform, FunctorType>; using Device = VTKM_DEFAULT_DEVICE_ADAPTER_TAG; using Algorithm = vtkm::cont::DeviceAdapterAlgorithm; diff --git a/vtkm/cont/testing/UnitTestArrayHandleUniformPointCoordinates.cxx b/vtkm/cont/testing/UnitTestArrayHandleUniformPointCoordinates.cxx index a3e069197..4ca9bc5ff 100644 --- a/vtkm/cont/testing/UnitTestArrayHandleUniformPointCoordinates.cxx +++ b/vtkm/cont/testing/UnitTestArrayHandleUniformPointCoordinates.cxx @@ -25,7 +25,7 @@ namespace { -typedef vtkm::Vec Vector3; +using Vector3 = vtkm::Vec; const vtkm::Id3 DIMENSIONS(16, 18, 5); const vtkm::Id NUM_POINTS = 1440; diff --git a/vtkm/cont/testing/UnitTestDataSetPermutation.cxx b/vtkm/cont/testing/UnitTestDataSetPermutation.cxx index adb0edd26..115ed0202 100644 --- a/vtkm/cont/testing/UnitTestDataSetPermutation.cxx +++ b/vtkm/cont/testing/UnitTestDataSetPermutation.cxx @@ -56,7 +56,7 @@ bool TestArrayHandle(const vtkm::cont::ArrayHandle& ah, inline vtkm::cont::DataSet make_SingleTypeDataSet() { - typedef vtkm::Vec CoordType; + using CoordType = vtkm::Vec; std::vector coordinates; coordinates.push_back(CoordType(0, 0, 0)); coordinates.push_back(CoordType(1, 0, 0)); @@ -114,9 +114,9 @@ void TestDataSet_Explicit() subset.PrintSummary(std::cout); - typedef SubsetType::ExecutionTypes::ExecObjectType ExecObjectType; + using ExecObjectType = SubsetType::ExecutionTypes::ExecObjectType; ExecObjectType execConnectivity; execConnectivity = subset.PrepareForInput(vtkm::cont::DeviceAdapterTagSerial(), diff --git a/vtkm/cont/testing/UnitTestDeviceAdapterAlgorithmGeneral.cxx b/vtkm/cont/testing/UnitTestDeviceAdapterAlgorithmGeneral.cxx index acc913c9a..36cae5959 100644 --- a/vtkm/cont/testing/UnitTestDeviceAdapterAlgorithmGeneral.cxx +++ b/vtkm/cont/testing/UnitTestDeviceAdapterAlgorithmGeneral.cxx @@ -78,10 +78,8 @@ class ArrayManagerExecution { public: - typedef vtkm::cont::internal::ArrayManagerExecution - Superclass; + using Superclass = + vtkm::cont::internal::ArrayManagerExecution; using ValueType = typename Superclass::ValueType; using PortalType = typename Superclass::PortalType; using PortalConstType = typename Superclass::PortalConstType; diff --git a/vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx b/vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx index 3a284165e..717e0ad00 100644 --- a/vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx +++ b/vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx @@ -84,7 +84,7 @@ template class ArrayHandleWithUnusualStorage : public vtkm::cont::ArrayHandle>> { - typedef vtkm::cont::ArrayHandle>> Superclass; + using Superclass = vtkm::cont::ArrayHandle>>; public: VTKM_CONT diff --git a/vtkm/cont/testing/UnitTestStorageBasic.cxx b/vtkm/cont/testing/UnitTestStorageBasic.cxx index 3ac3ef150..a12bef271 100644 --- a/vtkm/cont/testing/UnitTestStorageBasic.cxx +++ b/vtkm/cont/testing/UnitTestStorageBasic.cxx @@ -44,9 +44,9 @@ const vtkm::Id ARRAY_SIZE = 10; template struct TemplatedTests { - typedef vtkm::cont::internal::Storage StorageType; - typedef typename StorageType::ValueType ValueType; - typedef typename StorageType::PortalType PortalType; + using StorageType = vtkm::cont::internal::Storage; + using ValueType = typename StorageType::ValueType; + using PortalType = typename StorageType::PortalType; void SetStorage(StorageType& array, const ValueType& value) { @@ -74,7 +74,7 @@ struct TemplatedTests void TestAlignedAllocatorSTL() { - typedef typename StorageType::AllocatorType Allocator; + using Allocator = typename StorageType::AllocatorType; std::vector vec(ARRAY_SIZE, ValueType()); StorageType store(&vec[0], ARRAY_SIZE); } @@ -83,10 +83,9 @@ struct TemplatedTests // STL containers void CompileSTLAllocator() { - typedef typename StorageType::AllocatorType Allocator; - typedef - typename StorageType::AllocatorType::template rebind>::other - PairAllocator; + using Allocator = typename StorageType::AllocatorType; + using PairAllocator = + typename StorageType::AllocatorType::template rebind>::other; std::vector v; v.push_back(ValueType()); diff --git a/vtkm/cont/testing/UnitTestStorageImplicit.cxx b/vtkm/cont/testing/UnitTestStorageImplicit.cxx index 69e0f6866..10ca17999 100644 --- a/vtkm/cont/testing/UnitTestStorageImplicit.cxx +++ b/vtkm/cont/testing/UnitTestStorageImplicit.cxx @@ -58,7 +58,7 @@ template struct TemplatedTests { using StorageTagType = vtkm::cont::StorageTagImplicit>; - typedef vtkm::cont::internal::Storage StorageType; + using StorageType = vtkm::cont::internal::Storage; using ValueType = typename StorageType::ValueType; using PortalType = typename StorageType::PortalType; diff --git a/vtkm/cont/testing/UnitTestTryExecute.cxx b/vtkm/cont/testing/UnitTestTryExecute.cxx index 22a009692..2f8609688 100644 --- a/vtkm/cont/testing/UnitTestTryExecute.cxx +++ b/vtkm/cont/testing/UnitTestTryExecute.cxx @@ -93,7 +93,7 @@ static void Run() TryExecuteWithList(SingleValidList(), true); std::cout << "Try a list with two valid devices." << std::endl; - typedef vtkm::ListTagBase DoubleValidList; + using DoubleValidList = vtkm::ListTagBase; TryExecuteWithList(DoubleValidList(), true); std::cout << "Try a list with only invalid device." << std::endl; @@ -101,7 +101,7 @@ static void Run() TryExecuteWithList(SingleInvalidList(), false); std::cout << "Try a list with an invalid and valid device." << std::endl; - typedef vtkm::ListTagBase InvalidAndValidList; + using InvalidAndValidList = vtkm::ListTagBase; TryExecuteWithList(InvalidAndValidList(), true); } diff --git a/vtkm/exec/CellDerivative.h b/vtkm/exec/CellDerivative.h index 5a0aa7ea1..5e41e3c52 100644 --- a/vtkm/exec/CellDerivative.h +++ b/vtkm/exec/CellDerivative.h @@ -57,8 +57,8 @@ VTKM_EXEC vtkm::Vec ParametricDerivativ const vtkm::Vec& pcoords, vtkm::CellShapeTagHexahedron) { - typedef typename FieldVecType::ComponentType FieldType; - typedef vtkm::Vec GradientType; + using FieldType = typename FieldVecType::ComponentType; + using GradientType = vtkm::Vec; GradientType pc(pcoords); GradientType rc = GradientType(FieldType(1)) - pc; @@ -83,8 +83,8 @@ VTKM_EXEC vtkm::Vec ParametricDerivativ { #if 0 // This is not working. Just leverage the hexahedron code that is working. - typedef typename FieldVecType::ComponentType FieldType; - typedef vtkm::Vec GradientType; + using FieldType = typename FieldVecType::ComponentType; + using GradientType = vtkm::Vec; GradientType pc(pcoords); GradientType rc = GradientType(1) - pc; @@ -107,8 +107,8 @@ VTKM_EXEC vtkm::Vec ParametricDerivativ { #if 0 // This is not working. Just leverage the hexahedron code that is working. - typedef typename FieldVecType::ComponentType FieldType; - typedef vtkm::Vec GradientType; + using FieldType = typename FieldVecType::ComponentType; + using GradientType = vtkm::Vec; GradientType pc(pcoords); GradientType rc = GradientType(1) - pc; @@ -135,8 +135,8 @@ VTKM_EXEC vtkm::Vec ParametricDerivativ const vtkm::Vec& pcoords, vtkm::CellShapeTagQuad) { - typedef typename FieldVecType::ComponentType FieldType; - typedef vtkm::Vec GradientType; + using FieldType = typename FieldVecType::ComponentType; + using GradientType = vtkm::Vec; GradientType pc(static_cast(pcoords[0]), static_cast(pcoords[1])); GradientType rc = GradientType(FieldType(1)) - pc; @@ -162,8 +162,8 @@ ParametricDerivative(const FieldVecType &field, const vtkm::Vec &pcoords, vtkm::CellShapeTagPolygon) { - typedef typename FieldVecType::ComponentType FieldType; - typedef vtkm::Vec GradientType; + using FieldType = typename FieldVecType::ComponentType; + using GradientType = vtkm::Vec; const vtkm::IdComponent numPoints = field.GetNumberOfComponents(); FieldType deltaAngle = static_cast(2*vtkm::Pi()/numPoints); @@ -213,8 +213,8 @@ VTKM_EXEC vtkm::Vec CellDerivativeFor3D const vtkm::Vec& pcoords, CellShapeTag) { - typedef typename FieldVecType::ComponentType FieldType; - typedef vtkm::Vec GradientType; + using FieldType = typename FieldVecType::ComponentType; + using GradientType = vtkm::Vec; // For reasons that should become apparent in a moment, we actually want // the transpose of the Jacobian. @@ -448,7 +448,7 @@ VTKM_EXEC vtkm::Vec CellDerivative( VTKM_ASSERT(field.GetNumberOfComponents() == 1); VTKM_ASSERT(wCoords.GetNumberOfComponents() == 1); - typedef vtkm::Vec GradientType; + using GradientType = vtkm::Vec; return vtkm::TypeTraits::ZeroInitialization(); } @@ -538,7 +538,7 @@ VTKM_EXEC vtkm::Vec CellDerivative( { VTKM_ASSERT(field.GetNumberOfComponents() == 2); - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; return vtkm::Vec((field[1] - field[0]) / wCoords.GetSpacing()[0], T(0), T(0)); } @@ -740,8 +740,8 @@ VTKM_EXEC vtkm::Vec PolygonDerivative( // have a non 1 to 1 mapping between parametric coordinates world coordinates // if the polygon is not planar or convex. - typedef typename FieldVecType::ComponentType FieldType; - typedef typename WorldCoordType::ComponentType WCoordType; + using FieldType = typename FieldVecType::ComponentType; + using WCoordType = typename WorldCoordType::ComponentType; // Find the interpolation for the center point. FieldType fieldCenter = field[0]; @@ -830,8 +830,8 @@ VTKM_EXEC vtkm::Vec CellDerivative( { VTKM_ASSERT(field.GetNumberOfComponents() == 4); - typedef typename FieldVecType::ComponentType T; - typedef vtkm::Vec VecT; + using T = typename FieldVecType::ComponentType; + using VecT = vtkm::Vec; VecT pc(static_cast(pcoords[0]), static_cast(pcoords[1])); VecT rc = VecT(T(1)) - pc; @@ -1021,8 +1021,8 @@ VTKM_EXEC vtkm::Vec CellDerivative( { VTKM_ASSERT(field.GetNumberOfComponents() == 8); - typedef typename FieldVecType::ComponentType T; - typedef vtkm::Vec VecT; + using T = typename FieldVecType::ComponentType; + using VecT = vtkm::Vec; VecT pc(static_cast(pcoords[0]), static_cast(pcoords[1]), static_cast(pcoords[2])); VecT rc = VecT(T(1)) - pc; diff --git a/vtkm/exec/CellInterpolate.h b/vtkm/exec/CellInterpolate.h index 8ffb992f0..d86e0397c 100644 --- a/vtkm/exec/CellInterpolate.h +++ b/vtkm/exec/CellInterpolate.h @@ -104,8 +104,8 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle( // similarly. // - typedef typename WorldCoordVector::ComponentType Vector3; - typedef typename Vector3::ComponentType T; + using Vector3 = typename WorldCoordVector::ComponentType; + using T = typename Vector3::ComponentType; Vector3 pcoords(T(0)); Vector3 triangleNormal = vtkm::TriangleNormal(pointWCoords[0], pointWCoords[1], pointWCoords[2]); @@ -193,7 +193,7 @@ VTKM_EXEC vtkm::Vec CellInterpolate( vtkm::CellShapeTagLine, const vtkm::exec::FunctorBase&) { - typedef vtkm::Vec T; + using T = vtkm::Vec; const T& origin = field.GetOrigin(); const T& spacing = field.GetSpacing(); @@ -211,7 +211,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate( const vtkm::exec::FunctorBase& vtkmNotUsed(worklet)) { VTKM_ASSERT(field.GetNumberOfComponents() == 3); - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; return static_cast((field[0] * (1 - pcoords[0] - pcoords[1])) + (field[1] * pcoords[0]) + (field[2] * pcoords[1])); } @@ -248,7 +248,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate( // have a non 1 to 1 mapping between parametric coordinates world coordinates // if the polygon is not planar or convex. - typedef typename FieldVecType::ComponentType FieldType; + using FieldType = typename FieldVecType::ComponentType; // Find the interpolation for the center point. FieldType fieldCenter = field[0]; @@ -321,7 +321,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate( { VTKM_ASSERT(field.GetNumberOfComponents() == 4); - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; T bottomInterp = vtkm::Lerp(field[0], field[1], pcoords[0]); T topInterp = vtkm::Lerp(field[3], field[2], pcoords[0]); @@ -336,7 +336,7 @@ VTKM_EXEC vtkm::Vec CellInterpolate( vtkm::CellShapeTagQuad, const vtkm::exec::FunctorBase&) { - typedef vtkm::Vec T; + using T = vtkm::Vec; const T& origin = field.GetOrigin(); const T& spacing = field.GetSpacing(); @@ -355,7 +355,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate( const vtkm::exec::FunctorBase& vtkmNotUsed(worklet)) { VTKM_ASSERT(field.GetNumberOfComponents() == 4); - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; return static_cast((field[0] * (1 - pcoords[0] - pcoords[1] - pcoords[2])) + (field[1] * pcoords[0]) + (field[2] * pcoords[1]) + (field[3] * pcoords[2])); @@ -371,7 +371,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate( { VTKM_ASSERT(field.GetNumberOfComponents() == 8); - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; T bottomFrontInterp = vtkm::Lerp(field[0], field[1], pcoords[0]); T bottomBackInterp = vtkm::Lerp(field[3], field[2], pcoords[0]); @@ -408,7 +408,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate( { VTKM_ASSERT(field.GetNumberOfComponents() == 6); - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; T bottomInterp = static_cast((field[0] * (1 - pcoords[0] - pcoords[1])) + (field[1] * pcoords[1]) + (field[2] * pcoords[0])); @@ -429,7 +429,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate( { VTKM_ASSERT(field.GetNumberOfComponents() == 5); - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; T frontInterp = vtkm::Lerp(field[0], field[1], pcoords[0]); T backInterp = vtkm::Lerp(field[3], field[2], pcoords[0]); diff --git a/vtkm/exec/ConnectivityExplicit.h b/vtkm/exec/ConnectivityExplicit.h index 1217f7a83..0a3151057 100644 --- a/vtkm/exec/ConnectivityExplicit.h +++ b/vtkm/exec/ConnectivityExplicit.h @@ -37,7 +37,7 @@ template Shapes.GetNumberOfValues(); } - typedef vtkm::CellShapeTagGeneric CellShapeTag; + using CellShapeTag = vtkm::CellShapeTagGeneric; VTKM_EXEC CellShapeTag GetCellShape(vtkm::Id index) const { return CellShapeTag(this->Shapes.Get(index)); } diff --git a/vtkm/exec/ConnectivityPermuted.h b/vtkm/exec/ConnectivityPermuted.h index cabdef7fd..15cf78144 100644 --- a/vtkm/exec/ConnectivityPermuted.h +++ b/vtkm/exec/ConnectivityPermuted.h @@ -35,7 +35,7 @@ template class ConnectivityPermutedPointToCell { public: - typedef typename OriginalConnectivity::SchedulingRangeType SchedulingRangeType; + using SchedulingRangeType = typename OriginalConnectivity::SchedulingRangeType; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT @@ -62,7 +62,7 @@ public: VTKM_EXEC vtkm::Id GetNumberOfElements() const { return this->Portal.GetNumberOfValues(); } - typedef typename OriginalConnectivity::CellShapeTag CellShapeTag; + using CellShapeTag = typename OriginalConnectivity::CellShapeTag; VTKM_EXEC CellShapeTag GetCellShape(vtkm::Id index) const @@ -77,7 +77,7 @@ public: return this->Connectivity.GetNumberOfIndices(this->Portal.Get(index)); } - typedef typename OriginalConnectivity::IndicesType IndicesType; + using IndicesType = typename OriginalConnectivity::IndicesType; template VTKM_EXEC IndicesType GetIndices(const IndexType& index) const diff --git a/vtkm/exec/ConnectivityStructured.h b/vtkm/exec/ConnectivityStructured.h index e0c986337..2aadf96ab 100644 --- a/vtkm/exec/ConnectivityStructured.h +++ b/vtkm/exec/ConnectivityStructured.h @@ -36,13 +36,13 @@ class ConnectivityStructured VTKM_IS_TOPOLOGY_ELEMENT_TAG(FromTopology); VTKM_IS_TOPOLOGY_ELEMENT_TAG(ToTopology); - typedef vtkm::internal::ConnectivityStructuredInternals InternalsType; + using InternalsType = vtkm::internal::ConnectivityStructuredInternals; - typedef vtkm::internal::ConnectivityStructuredIndexHelper - Helper; + using Helper = + vtkm::internal::ConnectivityStructuredIndexHelper; public: - typedef typename InternalsType::SchedulingRangeType SchedulingRangeType; + using SchedulingRangeType = typename InternalsType::SchedulingRangeType; VTKM_EXEC_CONT ConnectivityStructured() @@ -65,7 +65,7 @@ public: VTKM_EXEC vtkm::Id GetNumberOfElements() const { return Helper::GetNumberOfElements(this->Internals); } - typedef typename Helper::CellShapeTag CellShapeTag; + using CellShapeTag = typename Helper::CellShapeTag; VTKM_EXEC CellShapeTag GetCellShape(vtkm::Id) const { return CellShapeTag(); } @@ -75,7 +75,7 @@ public: return Helper::GetNumberOfIndices(this->Internals, index); } - typedef typename Helper::IndicesType IndicesType; + using IndicesType = typename Helper::IndicesType; template VTKM_EXEC IndicesType GetIndices(const IndexType& index) const diff --git a/vtkm/exec/Jacobian.h b/vtkm/exec/Jacobian.h index 8d55f03fd..6dda0d07a 100644 --- a/vtkm/exec/Jacobian.h +++ b/vtkm/exec/Jacobian.h @@ -36,8 +36,8 @@ namespace internal template struct Space2D { - typedef vtkm::Vec Vec3; - typedef vtkm::Vec Vec2; + using Vec3 = vtkm::Vec; + using Vec2 = vtkm::Vec; Vec3 Origin; Vec3 Basis0; @@ -94,7 +94,7 @@ template VTKM_EXEC vtkm::Vec PermutePyramidToHex( const FieldVecType& field) { - typedef typename FieldVecType::ComponentType T; + using T = typename FieldVecType::ComponentType; vtkm::Vec hexField; diff --git a/vtkm/exec/ParametricCoordinates.h b/vtkm/exec/ParametricCoordinates.h index 5599f251a..35138f735 100644 --- a/vtkm/exec/ParametricCoordinates.h +++ b/vtkm/exec/ParametricCoordinates.h @@ -593,10 +593,10 @@ namespace detail template class JacobianFunctorQuad { - typedef typename WorldCoordVector::ComponentType::ComponentType T; - typedef vtkm::Vec Vector2; - typedef vtkm::Matrix Matrix2x2; - typedef vtkm::exec::internal::Space2D SpaceType; + using T = typename WorldCoordVector::ComponentType::ComponentType; + using Vector2 = vtkm::Vec; + using Matrix2x2 = vtkm::Matrix; + using SpaceType = vtkm::exec::internal::Space2D; const WorldCoordVector* PointWCoords; const SpaceType* Space; @@ -625,10 +625,10 @@ public: template class CoordinatesFunctorQuad { - typedef typename WorldCoordVector::ComponentType::ComponentType T; - typedef vtkm::Vec Vector2; - typedef vtkm::Vec Vector3; - typedef vtkm::exec::internal::Space2D SpaceType; + using T = typename WorldCoordVector::ComponentType::ComponentType; + using Vector2 = vtkm::Vec; + using Vector3 = vtkm::Vec; + using SpaceType = vtkm::exec::internal::Space2D; const WorldCoordVector* PointWCoords; const SpaceType* Space; @@ -658,9 +658,9 @@ public: template class JacobianFunctor3DCell { - typedef typename WorldCoordVector::ComponentType::ComponentType T; - typedef vtkm::Vec Vector3; - typedef vtkm::Matrix Matrix3x3; + using T = typename WorldCoordVector::ComponentType::ComponentType; + using Vector3 = vtkm::Vec; + using Matrix3x3 = vtkm::Matrix; const WorldCoordVector* PointWCoords; @@ -683,8 +683,8 @@ public: template class CoordinatesFunctor3DCell { - typedef typename WorldCoordVector::ComponentType::ComponentType T; - typedef vtkm::Vec Vector3; + using T = typename WorldCoordVector::ComponentType::ComponentType; + using Vector3 = vtkm::Vec; const WorldCoordVector* PointWCoords; const vtkm::exec::FunctorBase* Worklet; @@ -784,8 +784,8 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords, // of this over the length of the segment, which is mag(vec). Thus, the // parametric coordinate is dot(vec,wcoords-pointWCoords[0])/mag(vec)^2. - typedef typename WorldCoordVector::ComponentType Vector3; - typedef typename Vector3::ComponentType T; + using Vector3 = typename WorldCoordVector::ComponentType; + using T = typename Vector3::ComponentType; Vector3 vec = pointWCoords[1] - pointWCoords[0]; T numerator = vtkm::dot(vec, wcoords - pointWCoords[0]); @@ -848,7 +848,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords, // have a non 1 to 1 mapping between parametric coordinates world coordinates // if the polygon is not planar or convex. - typedef typename WorldCoordVector::ComponentType WCoordType; + using WCoordType = typename WorldCoordVector::ComponentType; // Find the position of the center point. WCoordType wcoordCenter = pointWCoords[0]; @@ -944,9 +944,9 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords, { VTKM_ASSERT(pointWCoords.GetNumberOfComponents() == 4); - typedef typename WorldCoordVector::ComponentType::ComponentType T; - typedef vtkm::Vec Vector2; - typedef vtkm::Vec Vector3; + using T = typename WorldCoordVector::ComponentType::ComponentType; + using Vector2 = vtkm::Vec; + using Vector3 = vtkm::Vec; // We have an underdetermined system in 3D, so create a 2D space in the // plane that the polygon sits. @@ -1003,7 +1003,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords, // d = dot((wcoords - p0), planeNormal)/dot((p1-p0), planeNormal) // - typedef typename WorldCoordVector::ComponentType Vector3; + using Vector3 = typename WorldCoordVector::ComponentType; Vector3 pcoords; diff --git a/vtkm/exec/arg/CellShape.h b/vtkm/exec/arg/CellShape.h index 084f42296..732b016e8 100644 --- a/vtkm/exec/arg/CellShape.h +++ b/vtkm/exec/arg/CellShape.h @@ -45,7 +45,7 @@ struct AspectTagCellShape struct CellShape : vtkm::exec::arg::ExecutionSignatureTagBase { static const vtkm::IdComponent INDEX = 1; - typedef vtkm::exec::arg::AspectTagCellShape AspectTag; + using AspectTag = vtkm::exec::arg::AspectTagCellShape; }; template @@ -54,9 +54,9 @@ struct Fetch, ExecObjectType> { - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef typename ThreadIndicesType::CellShapeTag ValueType; + using ValueType = typename ThreadIndicesType::CellShapeTag; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC diff --git a/vtkm/exec/arg/Fetch.h b/vtkm/exec/arg/Fetch.h index b6d3b585a..0bb56cbce 100644 --- a/vtkm/exec/arg/Fetch.h +++ b/vtkm/exec/arg/Fetch.h @@ -68,7 +68,7 @@ struct Fetch /// ValueType that is the type of object returned from \c Load and passed to /// \c Store. /// - typedef typename ExecObjectType::ValueType ValueType; + using ValueType = typename ExecObjectType::ValueType; /// \brief Load data for a work instance. /// diff --git a/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h b/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h index 104c3e95b..82d1bde38 100644 --- a/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h +++ b/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h @@ -64,14 +64,14 @@ namespace detail template struct FetchArrayTopologyMapInImplementation { - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; // ThreadIndicesTopologyMap has special "from" indices that are stored in a // Vec-like object. - typedef typename ThreadIndicesType::IndicesFromType IndexVecType; + using IndexVecType = typename ThreadIndicesType::IndicesFromType; // The FieldExecObjectType is expected to behave like an ArrayPortal. - typedef FieldExecObjectType PortalType; + using PortalType = FieldExecObjectType; using ValueType = vtkm::VecFromPortalPermute; @@ -137,13 +137,12 @@ struct FetchArrayTopologyMapInImplementation< vtkm::internal::ArrayPortalUniformPointCoordinates> { - typedef vtkm::exec::ConnectivityStructured - ConnectivityType; - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ConnectivityType = vtkm::exec::ConnectivityStructured; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef vtkm::VecAxisAlignedPointCoordinates ValueType; + using ValueType = vtkm::VecAxisAlignedPointCoordinates; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC @@ -167,15 +166,14 @@ struct FetchArrayTopologyMapInImplementation< vtkm::internal::ArrayPortalUniformPointCoordinates> { - typedef vtkm::exec::ConnectivityPermutedPointToCell< + using ConnectivityType = vtkm::exec::ConnectivityPermutedPointToCell< PermutationPortal, vtkm::exec::ConnectivityStructured> - ConnectivityType; - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + NumDimensions>>; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef vtkm::VecAxisAlignedPointCoordinates ValueType; + using ValueType = vtkm::VecAxisAlignedPointCoordinates; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC @@ -200,12 +198,12 @@ struct Fetch, ExecObjectType> { - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef detail::FetchArrayTopologyMapInImplementation - Implementation; + using Implementation = + detail::FetchArrayTopologyMapInImplementation; - typedef typename Implementation::ValueType ValueType; + using ValueType = typename Implementation::ValueType; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC diff --git a/vtkm/exec/arg/FetchTagCellSetIn.h b/vtkm/exec/arg/FetchTagCellSetIn.h index a4c02ac77..30a49ba0d 100644 --- a/vtkm/exec/arg/FetchTagCellSetIn.h +++ b/vtkm/exec/arg/FetchTagCellSetIn.h @@ -47,9 +47,9 @@ struct Fetch, ExecObjectType> { - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef typename ThreadIndicesType::CellShapeTag ValueType; + using ValueType = typename ThreadIndicesType::CellShapeTag; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC diff --git a/vtkm/exec/arg/FromCount.h b/vtkm/exec/arg/FromCount.h index cee5e1815..c22d0e3db 100644 --- a/vtkm/exec/arg/FromCount.h +++ b/vtkm/exec/arg/FromCount.h @@ -51,7 +51,7 @@ struct AspectTagFromCount struct FromCount : vtkm::exec::arg::ExecutionSignatureTagBase { static const vtkm::IdComponent INDEX = 1; - typedef vtkm::exec::arg::AspectTagFromCount AspectTag; + using AspectTag = vtkm::exec::arg::AspectTagFromCount; }; template @@ -60,9 +60,9 @@ struct Fetch, ExecObjectType> { - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef vtkm::IdComponent ValueType; + using ValueType = vtkm::IdComponent; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC diff --git a/vtkm/exec/arg/FromIndices.h b/vtkm/exec/arg/FromIndices.h index 41cc3960a..3fbe5feea 100644 --- a/vtkm/exec/arg/FromIndices.h +++ b/vtkm/exec/arg/FromIndices.h @@ -51,7 +51,7 @@ struct AspectTagFromIndices struct FromIndices : vtkm::exec::arg::ExecutionSignatureTagBase { static const vtkm::IdComponent INDEX = 1; - typedef vtkm::exec::arg::AspectTagFromIndices AspectTag; + using AspectTag = vtkm::exec::arg::AspectTagFromIndices; }; template @@ -60,9 +60,9 @@ struct Fetch, ExecObjectType> { - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef typename ThreadIndicesType::IndicesFromType ValueType; + using ValueType = typename ThreadIndicesType::IndicesFromType; VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC diff --git a/vtkm/exec/arg/ThreadIndicesTopologyMap.h b/vtkm/exec/arg/ThreadIndicesTopologyMap.h index 3a544d3f9..b50dec0c3 100644 --- a/vtkm/exec/arg/ThreadIndicesTopologyMap.h +++ b/vtkm/exec/arg/ThreadIndicesTopologyMap.h @@ -71,7 +71,7 @@ struct CellShapeInitializer template class ThreadIndicesTopologyMap : public vtkm::exec::arg::ThreadIndicesBasic { - typedef vtkm::exec::arg::ThreadIndicesBasic Superclass; + using Superclass = vtkm::exec::arg::ThreadIndicesBasic; public: using IndicesFromType = typename ConnectivityType::IndicesType; diff --git a/vtkm/exec/arg/ValueCount.h b/vtkm/exec/arg/ValueCount.h index 4f6a463ac..447fed98a 100644 --- a/vtkm/exec/arg/ValueCount.h +++ b/vtkm/exec/arg/ValueCount.h @@ -50,7 +50,7 @@ struct AspectTagValueCount struct ValueCount : vtkm::exec::arg::ExecutionSignatureTagBase { static const vtkm::IdComponent INDEX = 1; - typedef vtkm::exec::arg::AspectTagValueCount AspectTag; + using AspectTag = vtkm::exec::arg::AspectTagValueCount; }; template diff --git a/vtkm/exec/arg/testing/UnitTestFetchArrayDirectIn.cxx b/vtkm/exec/arg/testing/UnitTestFetchArrayDirectIn.cxx index b3fc612f5..3e8ba7153 100644 --- a/vtkm/exec/arg/testing/UnitTestFetchArrayDirectIn.cxx +++ b/vtkm/exec/arg/testing/UnitTestFetchArrayDirectIn.cxx @@ -32,7 +32,7 @@ static const vtkm::Id ARRAY_SIZE = 10; template struct TestPortal { - typedef T ValueType; + using ValueType = T; VTKM_EXEC_CONT vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; } @@ -53,11 +53,10 @@ struct FetchArrayDirectInTests { TestPortal execObject; - typedef vtkm::exec::arg::Fetch> - FetchType; + using FetchType = vtkm::exec::arg::Fetch>; FetchType fetch; diff --git a/vtkm/exec/arg/testing/UnitTestFetchArrayDirectInOut.cxx b/vtkm/exec/arg/testing/UnitTestFetchArrayDirectInOut.cxx index a4bc41e15..3ae39552c 100644 --- a/vtkm/exec/arg/testing/UnitTestFetchArrayDirectInOut.cxx +++ b/vtkm/exec/arg/testing/UnitTestFetchArrayDirectInOut.cxx @@ -34,7 +34,7 @@ static vtkm::Id g_NumSets; template struct TestPortal { - typedef T ValueType; + using ValueType = T; VTKM_EXEC_CONT vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; } @@ -66,11 +66,10 @@ struct FetchArrayDirectInTests { TestPortal execObject; - typedef vtkm::exec::arg::Fetch> - FetchType; + using FetchType = vtkm::exec::arg::Fetch>; FetchType fetch; diff --git a/vtkm/exec/arg/testing/UnitTestFetchArrayDirectOut.cxx b/vtkm/exec/arg/testing/UnitTestFetchArrayDirectOut.cxx index 77884d63a..d6748b44b 100644 --- a/vtkm/exec/arg/testing/UnitTestFetchArrayDirectOut.cxx +++ b/vtkm/exec/arg/testing/UnitTestFetchArrayDirectOut.cxx @@ -34,7 +34,7 @@ static vtkm::Id g_NumSets; template struct TestPortal { - typedef T ValueType; + using ValueType = T; VTKM_EXEC_CONT vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; } @@ -58,11 +58,10 @@ struct FetchArrayDirectOutTests { TestPortal execObject; - typedef vtkm::exec::arg::Fetch> - FetchType; + using FetchType = vtkm::exec::arg::Fetch>; FetchType fetch; diff --git a/vtkm/exec/arg/testing/UnitTestFetchArrayTopologyMapIn.cxx b/vtkm/exec/arg/testing/UnitTestFetchArrayTopologyMapIn.cxx index 25d436ec6..9d60d7442 100644 --- a/vtkm/exec/arg/testing/UnitTestFetchArrayTopologyMapIn.cxx +++ b/vtkm/exec/arg/testing/UnitTestFetchArrayTopologyMapIn.cxx @@ -35,7 +35,7 @@ static const vtkm::Id ARRAY_SIZE = 10; template struct TestPortal { - typedef T ValueType; + using ValueType = T; VTKM_EXEC_CONT vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; } @@ -51,7 +51,7 @@ struct TestPortal struct TestIndexPortal { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC_CONT ValueType Get(vtkm::Id index) const { return index; } @@ -59,7 +59,7 @@ struct TestIndexPortal struct TestZeroPortal { - typedef vtkm::IdComponent ValueType; + using ValueType = vtkm::IdComponent; VTKM_EXEC_CONT ValueType Get(vtkm::Id) const { return 0; } @@ -72,14 +72,13 @@ struct FetchArrayTopologyMapInTests template void TryInvocation(const Invocation& invocation) const { - typedef typename Invocation::InputDomainType ConnectivityType; - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ConnectivityType = typename Invocation::InputDomainType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; - typedef vtkm::exec::arg::Fetch> - FetchType; + using FetchType = vtkm::exec::arg::Fetch>; FetchType fetch; @@ -147,8 +146,8 @@ struct TryType template void TryStructuredPointCoordinatesInvocation(const Invocation& invocation) { - typedef typename Invocation::InputDomainType ConnectivityType; - typedef vtkm::exec::arg::ThreadIndicesTopologyMap ThreadIndicesType; + using ConnectivityType = typename Invocation::InputDomainType; + using ThreadIndicesType = vtkm::exec::arg::ThreadIndicesTopologyMap; vtkm::exec::arg::Fetch - FetchType; + using FetchType = vtkm::exec::arg::Fetch; FetchType fetch; diff --git a/vtkm/exec/arg/testing/UnitTestFetchWorkIndex.cxx b/vtkm/exec/arg/testing/UnitTestFetchWorkIndex.cxx index 9769024e6..12b8e2678 100644 --- a/vtkm/exec/arg/testing/UnitTestFetchWorkIndex.cxx +++ b/vtkm/exec/arg/testing/UnitTestFetchWorkIndex.cxx @@ -33,12 +33,11 @@ void TestWorkIndexFetch() { std::cout << "Trying WorkIndex fetch." << std::endl; - typedef vtkm::exec::arg::Fetch< - vtkm::exec::arg::FetchTagArrayDirectIn, // Not used but probably common. - vtkm::exec::arg::AspectTagWorkIndex, - vtkm::exec::arg::ThreadIndicesTesting, - vtkm::internal::NullType> - FetchType; + using FetchType = + vtkm::exec::arg::Fetch; FetchType fetch; diff --git a/vtkm/exec/cuda/internal/ArrayPortalFromThrust.h b/vtkm/exec/cuda/internal/ArrayPortalFromThrust.h index e05874663..26ec6b3d7 100644 --- a/vtkm/exec/cuda/internal/ArrayPortalFromThrust.h +++ b/vtkm/exec/cuda/internal/ArrayPortalFromThrust.h @@ -201,7 +201,7 @@ struct load_through_texture< { static const vtkm::IdComponent WillUseTexture = 1; - typedef typename std::remove_const::type NonConstT; + using NonConstT = typename std::remove_const::type; __device__ static T get(const thrust::system::cuda::pointer& data) { @@ -217,7 +217,7 @@ struct load_through_texture< { //we need to fetch each component individually const vtkm::IdComponent NUM_COMPONENTS = T::NUM_COMPONENTS; - typedef typename T::ComponentType ComponentType; + using ComponentType = typename T::ComponentType; const ComponentType* recasted_data = (const ComponentType*)(data.get()); NonConstT result; #pragma unroll @@ -240,8 +240,8 @@ template class ArrayPortalFromThrust : public ArrayPortalFromThrustBase { public: - typedef T ValueType; - typedef thrust::system::cuda::pointer IteratorType; + using ValueType = T; + using IteratorType = thrust::system::cuda::pointer; VTKM_EXEC_CONT ArrayPortalFromThrust() {} @@ -274,14 +274,14 @@ public: VTKM_EXEC_CONT ValueType Get(vtkm::Id index) const { - typedef typename ::thrust::iterator_traits::difference_type SizeType; + using SizeType = typename ::thrust::iterator_traits::difference_type; return *(this->BeginIterator + static_cast(index)); } VTKM_EXEC_CONT void Set(vtkm::Id index, ValueType value) const { - typedef typename ::thrust::iterator_traits::difference_type SizeType; + using SizeType = typename ::thrust::iterator_traits::difference_type; *(this->BeginIterator + static_cast(index)) = value; } @@ -300,8 +300,8 @@ template class ConstArrayPortalFromThrust : public ArrayPortalFromThrustBase { public: - typedef T ValueType; - typedef thrust::system::cuda::pointer IteratorType; + using ValueType = T; + using IteratorType = thrust::system::cuda::pointer; VTKM_EXEC_CONT ConstArrayPortalFromThrust() {} @@ -385,10 +385,10 @@ namespace cont template class ArrayPortalToIterators> { - typedef vtkm::exec::cuda::internal::ArrayPortalFromThrust PortalType; + using PortalType = vtkm::exec::cuda::internal::ArrayPortalFromThrust; public: - typedef typename PortalType::IteratorType IteratorType; + using IteratorType = typename PortalType::IteratorType; VTKM_CONT ArrayPortalToIterators(const PortalType& portal) @@ -416,10 +416,10 @@ private: template class ArrayPortalToIterators> { - typedef vtkm::exec::cuda::internal::ConstArrayPortalFromThrust PortalType; + using PortalType = vtkm::exec::cuda::internal::ConstArrayPortalFromThrust; public: - typedef typename PortalType::IteratorType IteratorType; + using IteratorType = typename PortalType::IteratorType; VTKM_CONT ArrayPortalToIterators(const PortalType& portal) diff --git a/vtkm/exec/cuda/internal/IteratorFromArrayPortal.h b/vtkm/exec/cuda/internal/IteratorFromArrayPortal.h index 1b73b04d8..04a7b59a3 100644 --- a/vtkm/exec/cuda/internal/IteratorFromArrayPortal.h +++ b/vtkm/exec/cuda/internal/IteratorFromArrayPortal.h @@ -43,7 +43,7 @@ namespace internal template struct PortalValue { - typedef typename ArrayPortalType::ValueType ValueType; + using ValueType = typename ArrayPortalType::ValueType; VTKM_EXEC_CONT PortalValue(const ArrayPortalType& portal, vtkm::Id index) diff --git a/vtkm/exec/cuda/internal/ThrustPatches.h b/vtkm/exec/cuda/internal/ThrustPatches.h index 011d34a51..a9702a938 100644 --- a/vtkm/exec/cuda/internal/ThrustPatches.h +++ b/vtkm/exec/cuda/internal/ThrustPatches.h @@ -70,7 +70,7 @@ destructive_accumulate_n(ConcurrentGroup& g, T init, vtkm::exec::cuda::internal::WrappedBinaryOperator binary_op) { - typedef typename ConcurrentGroup::size_type size_type; + using size_type = typename ConcurrentGroup::size_type; size_type tid = g.this_exec.index(); diff --git a/vtkm/exec/cuda/internal/WrappedOperators.h b/vtkm/exec/cuda/internal/WrappedOperators.h index a4b7f27ef..7677ec959 100644 --- a/vtkm/exec/cuda/internal/WrappedOperators.h +++ b/vtkm/exec/cuda/internal/WrappedOperators.h @@ -47,11 +47,11 @@ namespace internal template struct WrappedUnaryPredicate { - typedef typename std::remove_const::type T; + using T = typename std::remove_const::type; //make typedefs that thust expects unary operators to have - typedef T first_argument_type; - typedef bool result_type; + using first_argument_type = T; + using result_type = bool; Function m_f; @@ -85,12 +85,12 @@ struct WrappedUnaryPredicate template struct WrappedBinaryOperator { - typedef typename std::remove_const::type T; + using T = typename std::remove_const::type; //make typedefs that thust expects binary operators to have - typedef T first_argument_type; - typedef T second_argument_type; - typedef T result_type; + using first_argument_type = T; + using second_argument_type = T; + using result_type = T; Function m_f; @@ -151,12 +151,12 @@ struct WrappedBinaryOperator template struct WrappedBinaryPredicate { - typedef typename std::remove_const::type T; + using T = typename std::remove_const::type; //make typedefs that thust expects binary operators to have - typedef T first_argument_type; - typedef T second_argument_type; - typedef bool result_type; + using first_argument_type = T; + using second_argument_type = T; + using result_type = bool; Function m_f; diff --git a/vtkm/exec/cuda/internal/testing/UnitTestTaskSingularCuda.cu b/vtkm/exec/cuda/internal/testing/UnitTestTaskSingularCuda.cu index ed8b56df3..e483a1069 100644 --- a/vtkm/exec/cuda/internal/testing/UnitTestTaskSingularCuda.cu +++ b/vtkm/exec/cuda/internal/testing/UnitTestTaskSingularCuda.cu @@ -54,14 +54,14 @@ struct TestExecObject struct MyOutputToInputMapPortal { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC_CONT vtkm::Id Get(vtkm::Id index) const { return index; } }; struct MyVisitArrayPortal { - typedef vtkm::IdComponent ValueType; + using ValueType = vtkm::IdComponent; vtkm::IdComponent Get(vtkm::Id) const { return 1; } }; @@ -75,11 +75,11 @@ struct TestFetchTagOutput // Missing TransportTag, but we are not testing that so we can leave it out. struct TestControlSignatureTagInput { - typedef TestFetchTagInput FetchTag; + using FetchTag = TestFetchTagInput; }; struct TestControlSignatureTagOutput { - typedef TestFetchTagOutput FetchTag; + using FetchTag = TestFetchTagOutput; }; } // anonymous namespace @@ -92,10 +92,12 @@ namespace arg { template <> -struct Fetch +struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic& indices, @@ -112,10 +114,12 @@ struct Fetch -struct Fetch +struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic&, const TestExecObject&) const @@ -125,7 +129,8 @@ struct Fetch TestControlInterface; +using TestControlInterface = vtkm::internal::FunctionInterface; typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface1; +using TestExecutionInterface1 = vtkm::internal::FunctionInterface; typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface2; +using TestExecutionInterface2 = vtkm::internal::FunctionInterface; typedef vtkm::internal::FunctionInterface ExecutionParameterInterface; -typedef vtkm::internal::Invocation - InvocationType1; +using InvocationType1 = vtkm::internal::Invocation; -typedef vtkm::internal::Invocation - InvocationType2; +using InvocationType2 = vtkm::internal::Invocation; template static __global__ void ScheduleTaskSingular(TaskType task, vtkm::Id start, vtkm::Id end) @@ -181,14 +190,20 @@ struct TestWorkletProxy : vtkm::exec::FunctorBase VTKM_EXEC vtkm::Id operator()(vtkm::Id input) const { return input + 200; } - template + template VTKM_EXEC vtkm::exec::arg::ThreadIndicesBasic GetThreadIndices( - const T& threadIndex, const OutToInArrayType& outToIn, const VisitArrayType& visit, - const InputDomainType&, const G& globalThreadIndexOffset) const + const T& threadIndex, + const OutToInArrayType& outToIn, + const VisitArrayType& visit, + const InputDomainType&, + const G& globalThreadIndexOffset) const { - return vtkm::exec::arg::ThreadIndicesBasic(threadIndex, outToIn.Get(threadIndex), - visit.Get(threadIndex), globalThreadIndexOffset); + return vtkm::exec::arg::ThreadIndicesBasic( + threadIndex, outToIn.Get(threadIndex), visit.Get(threadIndex), globalThreadIndexOffset); } }; @@ -200,39 +215,48 @@ struct TestWorkletErrorProxy : vtkm::exec::FunctorBase VTKM_EXEC void operator()(vtkm::Id, vtkm::Id) const { this->RaiseError(ERROR_MESSAGE); } - template + template VTKM_EXEC vtkm::exec::arg::ThreadIndicesBasic GetThreadIndices( - const T& threadIndex, const OutToInArrayType& outToIn, const VisitArrayType& visit, - const InputDomainType&, const G& globalThreadIndexOffset) const + const T& threadIndex, + const OutToInArrayType& outToIn, + const VisitArrayType& visit, + const InputDomainType&, + const G& globalThreadIndexOffset) const { - return vtkm::exec::arg::ThreadIndicesBasic(threadIndex, outToIn.Get(threadIndex), - visit.Get(threadIndex), globalThreadIndexOffset); + return vtkm::exec::arg::ThreadIndicesBasic( + threadIndex, outToIn.Get(threadIndex), visit.Get(threadIndex), globalThreadIndexOffset); } }; // Check behavior of InvocationToFetch helper class. VTKM_STATIC_ASSERT( - (std::is_same< - vtkm::exec::internal::detail::InvocationToFetch::type, - vtkm::exec::arg::Fetch>::type::value)); + (std::is_same::type, + vtkm::exec::arg::Fetch>::type::value)); VTKM_STATIC_ASSERT( - (std::is_same< - vtkm::exec::internal::detail::InvocationToFetch::type, - vtkm::exec::arg::Fetch>::type::value)); + (std::is_same::type, + vtkm::exec::arg::Fetch>::type::value)); VTKM_STATIC_ASSERT( - (std::is_same< - vtkm::exec::internal::detail::InvocationToFetch::type, - vtkm::exec::arg::Fetch>::type::value)); + (std::is_same::type, + vtkm::exec::arg::Fetch>::type::value)); template void TestNormalFunctorInvoke() @@ -253,7 +277,7 @@ void TestNormalFunctorInvoke() TestExecObject(output.PrepareForOutput(3, DeviceAdapter()))); std::cout << " Try void return." << std::endl; - typedef vtkm::exec::internal::TaskSingular TaskSingular1; + using TaskSingular1 = vtkm::exec::internal::TaskSingular; TestWorkletProxy worklet; InvocationType1 invocation1(execObjects); @@ -277,7 +301,7 @@ void TestNormalFunctorInvoke() TestExecObject(input.PrepareForInPlace(DeviceAdapter())), TestExecObject(output.PrepareForOutput(3, DeviceAdapter()))); - typedef vtkm::exec::internal::TaskSingular TaskSingular2; + using TaskSingular2 = vtkm::exec::internal::TaskSingular; InvocationType2 invocation2(execObjects); using TaskTypes = typename vtkm::cont::DeviceTaskTypes; @@ -311,7 +335,7 @@ void TestErrorFunctorInvoke() TestExecObject(input.PrepareForInPlace(DeviceAdapter())), TestExecObject(output.PrepareForInPlace(DeviceAdapter()))); - typedef vtkm::exec::internal::TaskSingular TaskSingular1; + using TaskSingular1 = vtkm::exec::internal::TaskSingular; TestWorkletErrorProxy worklet; InvocationType1 invocation(execObjects); diff --git a/vtkm/exec/cuda/internal/testing/UnitTestTextureMemorySupport.cu b/vtkm/exec/cuda/internal/testing/UnitTestTextureMemorySupport.cu index 97aa315ae..029146f04 100644 --- a/vtkm/exec/cuda/internal/testing/UnitTestTextureMemorySupport.cu +++ b/vtkm/exec/cuda/internal/testing/UnitTestTextureMemorySupport.cu @@ -31,11 +31,11 @@ struct customType void TestScalarTextureLoad() { using namespace vtkm::exec::cuda::internal; - typedef load_through_texture f; - typedef load_through_texture i; - typedef load_through_texture ui; + using f = load_through_texture; + using i = load_through_texture; + using ui = load_through_texture; - typedef load_through_texture ct; + using ct = load_through_texture; VTKM_TEST_ASSERT(f::WillUseTexture == 1, "Float32 can be loaded through texture memory"); VTKM_TEST_ASSERT(i::WillUseTexture == 1, "Int32 can be loaded through texture memory"); @@ -46,18 +46,18 @@ void TestScalarTextureLoad() void TestVecTextureLoad() { using namespace vtkm::exec::cuda::internal; - typedef load_through_texture> ui32_3; - typedef load_through_texture> f32_3; - typedef load_through_texture> ui8_3; - typedef load_through_texture> f64_3; + using ui32_3 = load_through_texture>; + using f32_3 = load_through_texture>; + using ui8_3 = load_through_texture>; + using f64_3 = load_through_texture>; - typedef load_through_texture> ui32_4; - typedef load_through_texture> f32_4; - typedef load_through_texture> ui8_4; - typedef load_through_texture> f64_4; + using ui32_4 = load_through_texture>; + using f32_4 = load_through_texture>; + using ui8_4 = load_through_texture>; + using f64_4 = load_through_texture>; - typedef load_through_texture> ct_3; - typedef load_through_texture> ct_4; + using ct_3 = load_through_texture>; + using ct_4 = load_through_texture>; VTKM_TEST_ASSERT(ui32_3::WillUseTexture == 1, "Can be loaded through texture loads"); VTKM_TEST_ASSERT(f32_3::WillUseTexture == 1, "Can be loaded through texture loads"); diff --git a/vtkm/exec/internal/testing/TestingTaskTiling.h b/vtkm/exec/internal/testing/TestingTaskTiling.h index 2aa834790..977221661 100644 --- a/vtkm/exec/internal/testing/TestingTaskTiling.h +++ b/vtkm/exec/internal/testing/TestingTaskTiling.h @@ -65,14 +65,14 @@ struct TestExecObject struct MyOutputToInputMapPortal { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC_CONT vtkm::Id Get(vtkm::Id index) const { return index; } }; struct MyVisitArrayPortal { - typedef vtkm::IdComponent ValueType; + using ValueType = vtkm::IdComponent; vtkm::IdComponent Get(vtkm::Id) const { return 1; } }; @@ -86,11 +86,11 @@ struct TestFetchTagOutput // Missing TransportTag, but we are not testing that so we can leave it out. struct TestControlSignatureTagInput { - typedef TestFetchTagInput FetchTag; + using FetchTag = TestFetchTagInput; }; struct TestControlSignatureTagOutput { - typedef TestFetchTagOutput FetchTag; + using FetchTag = TestFetchTagOutput; }; } } @@ -112,7 +112,7 @@ struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic& indices, @@ -134,7 +134,7 @@ struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic&, const TestExecObject&) const @@ -165,32 +165,30 @@ namespace testing { typedef void TestControlSignature(TestControlSignatureTagInput, TestControlSignatureTagOutput); -typedef vtkm::internal::FunctionInterface TestControlInterface; +using TestControlInterface = vtkm::internal::FunctionInterface; typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface1; +using TestExecutionInterface1 = vtkm::internal::FunctionInterface; typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface2; +using TestExecutionInterface2 = vtkm::internal::FunctionInterface; typedef vtkm::internal::FunctionInterface ExecutionParameterInterface; -typedef vtkm::internal::Invocation - InvocationType1; +using InvocationType1 = vtkm::internal::Invocation; -typedef vtkm::internal::Invocation - InvocationType2; +using InvocationType2 = vtkm::internal::Invocation; // Not a full worklet, but provides operators that we expect in a worklet. struct TestWorkletProxy : vtkm::exec::FunctorBase diff --git a/vtkm/exec/internal/testing/UnitTestTaskSingular.cxx b/vtkm/exec/internal/testing/UnitTestTaskSingular.cxx index c36681faf..ef8f6d8eb 100644 --- a/vtkm/exec/internal/testing/UnitTestTaskSingular.cxx +++ b/vtkm/exec/internal/testing/UnitTestTaskSingular.cxx @@ -53,14 +53,14 @@ struct TestExecObject struct MyOutputToInputMapPortal { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC_CONT vtkm::Id Get(vtkm::Id index) const { return index; } }; struct MyVisitArrayPortal { - typedef vtkm::IdComponent ValueType; + using ValueType = vtkm::IdComponent; vtkm::IdComponent Get(vtkm::Id) const { return 1; } }; @@ -74,11 +74,11 @@ struct TestFetchTagOutput // Missing TransportTag, but we are not testing that so we can leave it out. struct TestControlSignatureTagInput { - typedef TestFetchTagInput FetchTag; + using FetchTag = TestFetchTagInput; }; struct TestControlSignatureTagOutput { - typedef TestFetchTagOutput FetchTag; + using FetchTag = TestFetchTagOutput; }; } // anonymous namespace @@ -96,7 +96,7 @@ struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic& indices, @@ -118,7 +118,7 @@ struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic&, const TestExecObject&) const @@ -143,32 +143,30 @@ namespace { typedef void TestControlSignature(TestControlSignatureTagInput, TestControlSignatureTagOutput); -typedef vtkm::internal::FunctionInterface TestControlInterface; +using TestControlInterface = vtkm::internal::FunctionInterface; typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface1; +using TestExecutionInterface1 = vtkm::internal::FunctionInterface; typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface2; +using TestExecutionInterface2 = vtkm::internal::FunctionInterface; typedef vtkm::internal::FunctionInterface ExecutionParameterInterface; -typedef vtkm::internal::Invocation - InvocationType1; +using InvocationType1 = vtkm::internal::Invocation; -typedef vtkm::internal::Invocation - InvocationType2; +using InvocationType2 = vtkm::internal::Invocation; // Not a full worklet, but provides operators that we expect in a worklet. struct TestWorkletProxy : vtkm::exec::FunctorBase @@ -260,7 +258,7 @@ void TestNormalFunctorInvoke() std::cout << " Try void return." << std::endl; inputTestValue = 5; outputTestValue = static_cast(0xDEADDEAD); - typedef vtkm::exec::internal::TaskSingular TaskSingular1; + using TaskSingular1 = vtkm::exec::internal::TaskSingular; TestWorkletProxy worklet; InvocationType1 invocation1(execObjects); TaskSingular1 taskInvokeWorklet1(worklet, invocation1); @@ -272,7 +270,7 @@ void TestNormalFunctorInvoke() std::cout << " Try return value." << std::endl; inputTestValue = 6; outputTestValue = static_cast(0xDEADDEAD); - typedef vtkm::exec::internal::TaskSingular TaskSingular2; + using TaskSingular2 = vtkm::exec::internal::TaskSingular; InvocationType2 invocation2(execObjects); TaskSingular2 taskInvokeWorklet2(worklet, invocation2); @@ -291,7 +289,7 @@ void TestErrorFunctorInvoke() vtkm::internal::make_FunctionInterface(TestExecObject(&inputTestValue), TestExecObject(&outputTestValue)); - typedef vtkm::exec::internal::TaskSingular TaskSingular1; + using TaskSingular1 = vtkm::exec::internal::TaskSingular; TestWorkletErrorProxy worklet; InvocationType1 invocation(execObjects); TaskSingular1 taskInvokeWorklet1 = TaskSingular1(worklet, invocation); diff --git a/vtkm/exec/internal/testing/UnitTestWorkletInvokeFunctor.cxx b/vtkm/exec/internal/testing/UnitTestWorkletInvokeFunctor.cxx index 3cc08482b..b0e48ca87 100644 --- a/vtkm/exec/internal/testing/UnitTestWorkletInvokeFunctor.cxx +++ b/vtkm/exec/internal/testing/UnitTestWorkletInvokeFunctor.cxx @@ -53,14 +53,14 @@ struct TestExecObject struct MyOutputToInputMapPortal { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC_CONT vtkm::Id Get(vtkm::Id index) const { return index; } }; struct MyVisitArrayPortal { - typedef vtkm::IdComponent ValueType; + using ValueType = vtkm::IdComponent; vtkm::IdComponent Get(vtkm::Id) const { return 1; } }; @@ -74,11 +74,11 @@ struct TestFetchTagOutput // Missing TransportTag, but we are not testing that so we can leave it out. struct TestControlSignatureTagInput { - typedef TestFetchTagInput FetchTag; + using FetchTag = TestFetchTagInput; }; struct TestControlSignatureTagOutput { - typedef TestFetchTagOutput FetchTag; + using FetchTag = TestFetchTagOutput; }; } // anonymous namespace @@ -96,7 +96,7 @@ struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic& indices, @@ -118,7 +118,7 @@ struct Fetch { - typedef vtkm::Id ValueType; + using ValueType = vtkm::Id; VTKM_EXEC ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic&, const TestExecObject&) const @@ -143,13 +143,13 @@ namespace { typedef void TestControlSignature(TestControlSignatureTagInput, TestControlSignatureTagOutput); -typedef vtkm::internal::FunctionInterface TestControlInterface; +using TestControlInterface = vtkm::internal::FunctionInterface; typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface1; +using TestExecutionInterface1 = vtkm::internal::FunctionInterface; typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>); -typedef vtkm::internal::FunctionInterface TestExecutionInterface2; +using TestExecutionInterface2 = vtkm::internal::FunctionInterface; // Not a full worklet, but provides operators that we expect in a worklet. struct TestWorkletProxy : vtkm::exec::FunctorBase diff --git a/vtkm/exec/testing/UnitTestCellInterpolate.cxx b/vtkm/exec/testing/UnitTestCellInterpolate.cxx index 20ac7e8cd..fc2739dd1 100644 --- a/vtkm/exec/testing/UnitTestCellInterpolate.cxx +++ b/vtkm/exec/testing/UnitTestCellInterpolate.cxx @@ -60,7 +60,7 @@ void GetMinMaxPoints(CellShapeTag, template struct TestInterpolateFunctor { - typedef typename vtkm::VecTraits::ComponentType ComponentType; + using ComponentType = typename vtkm::VecTraits::ComponentType; template void DoTestWithField(CellShapeTag shape, const FieldVecType& fieldValues) const diff --git a/vtkm/exec/testing/UnitTestParametricCoordinates.cxx b/vtkm/exec/testing/UnitTestParametricCoordinates.cxx index bd58db04c..14d89997c 100644 --- a/vtkm/exec/testing/UnitTestParametricCoordinates.cxx +++ b/vtkm/exec/testing/UnitTestParametricCoordinates.cxx @@ -65,7 +65,7 @@ static void CompareCoordinates(const PointWCoordsType& pointWCoords, vtkm::Vec trueWCoords, CellShapeTag shape) { - typedef vtkm::Vec Vector3; + using Vector3 = vtkm::Vec; // Stuff to fake running in the execution environment. char messageBuffer[256]; @@ -90,8 +90,8 @@ static void CompareCoordinates(const PointWCoordsType& pointWCoords, template void TestPCoordsSpecial(const PointWCoordsType& pointWCoords, CellShapeTag shape) { - typedef typename PointWCoordsType::ComponentType Vector3; - typedef typename Vector3::ComponentType T; + using Vector3 = typename PointWCoordsType::ComponentType; + using T = typename Vector3::ComponentType; // Stuff to fake running in the execution environment. char messageBuffer[256]; @@ -130,7 +130,7 @@ void TestPCoordsSpecial(const PointWCoordsType& pointWCoords, CellShapeTag shape template void TestPCoordsSample(const PointWCoordsType& pointWCoords, CellShapeTag shape) { - typedef typename PointWCoordsType::ComponentType Vector3; + using Vector3 = typename PointWCoordsType::ComponentType; // Stuff to fake running in the execution environment. char messageBuffer[256]; @@ -185,8 +185,8 @@ static void TestPCoords(const PointWCoordsType& pointWCoords, CellShellTag shape template struct TestPCoordsFunctor { - typedef vtkm::Vec Vector3; - typedef vtkm::VecVariable PointWCoordType; + using Vector3 = vtkm::Vec; + using PointWCoordType = vtkm::VecVariable; template PointWCoordType MakePointWCoords(CellShapeTag, vtkm::IdComponent numPoints) const