Change function signatures to use 'using' aliases.

Also cleaned up some lingering type typedefs.

benchmarking/BenchmarkFieldAlgorithms.cxx

@@ -65,12 +65,9 @@ class BlackScholes : public vtkm::worklet::WorkletMapField
   T Volatility;
 
 public:
-  typedef void ControlSignature(FieldIn<Scalar>,
-                                FieldIn<Scalar>,
-                                FieldIn<Scalar>,
-                                FieldOut<Scalar>,
-                                FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2, _3, _4, _5);
+  using ControlSignature =
+    void(FieldIn<Scalar>, FieldIn<Scalar>, FieldIn<Scalar>, FieldOut<Scalar>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2, _3, _4, _5);
 
   BlackScholes(T risk, T volatility)
     : Riskfree(risk)
@@ -131,8 +128,8 @@ public:
 class Mag : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2);
 
   template <typename T, typename U>
   VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& vec, U& result) const
@@ -144,8 +141,8 @@ public:
 class Square : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Scalar>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2);
 
   template <typename T, typename U>
   VTKM_EXEC void operator()(T input, U& output) const
@@ -157,8 +154,8 @@ public:
 class Sin : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Scalar>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2);
 
   template <typename T, typename U>
   VTKM_EXEC void operator()(T input, U& output) const
@@ -170,8 +167,8 @@ public:
 class Cos : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Scalar>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2);
 
   template <typename T, typename U>
   VTKM_EXEC void operator()(T input, U& output) const
@@ -183,8 +180,8 @@ public:
 class FusedMath : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2);
 
   template <typename T>
   VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& vec, T& result) const
@@ -203,8 +200,8 @@ public:
 class GenerateEdges : public vtkm::worklet::WorkletMapPointToCell
 {
 public:
-  typedef void ControlSignature(CellSetIn cellset, WholeArrayOut<> edgeIds);
-  typedef void ExecutionSignature(PointIndices, ThreadIndices, _2);
+  using ControlSignature = void(CellSetIn cellset, WholeArrayOut<> edgeIds);
+  using ExecutionSignature = void(PointIndices, ThreadIndices, _2);
   using InputDomain = _1;
 
   template <typename ConnectivityInVec, typename ThreadIndicesType, typename IdPairTableType>
@@ -229,11 +226,11 @@ public:
 class InterpolateField : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Id2Type> interpolation_ids,
+  using ControlSignature = void(FieldIn<Id2Type> interpolation_ids,
                                 FieldIn<Scalar> interpolation_weights,
                                 WholeArrayIn<> inputField,
                                 FieldOut<> output);
-  typedef void ExecutionSignature(_1, _2, _3, _4);
+  using ExecutionSignature = void(_1, _2, _3, _4);
   using InputDomain = _1;
 
   template <typename WeightType, typename T, typename S, typename D>
@@ -262,8 +259,8 @@ template <typename ImplicitFunction>
 class EvaluateImplicitFunction : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2);
 
   EvaluateImplicitFunction(const ImplicitFunction* function)
     : Function(function)
@@ -284,8 +281,8 @@ template <typename T1, typename T2>
 class Evaluate2ImplicitFunctions : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
+  using ExecutionSignature = void(_1, _2);
 
   Evaluate2ImplicitFunctions(const T1* f1, const T2* f2)
     : Function1(f1)

benchmarking/BenchmarkTopologyAlgorithms.cxx

@@ -55,10 +55,10 @@ enum BenchmarkName
 class AveragePointToCell : public vtkm::worklet::WorkletMapPointToCell
 {
 public:
-  typedef void ControlSignature(FieldInPoint<> inPoints,
+  using ControlSignature = void(FieldInPoint<> inPoints,
                                 CellSetIn cellset,
                                 FieldOutCell<> outCells);
-  typedef void ExecutionSignature(_1, PointCount, _3);
+  using ExecutionSignature = void(_1, PointCount, _3);
   using InputDomain = _2;
 
   template <typename PointValueVecType, typename OutType>
@@ -79,8 +79,8 @@ public:
 class AverageCellToPoint : public vtkm::worklet::WorkletMapCellToPoint
 {
 public:
-  typedef void ControlSignature(FieldInCell<> inCells, CellSetIn topology, FieldOut<> outPoints);
-  typedef void ExecutionSignature(_1, _3, CellCount);
+  using ControlSignature = void(FieldInCell<> inCells, CellSetIn topology, FieldOut<> outPoints);
+  using ExecutionSignature = void(_1, _3, CellCount);
   using InputDomain = _2;
 
   template <typename CellVecType, typename OutType>
@@ -106,10 +106,10 @@ template <typename T>
 class Classification : public vtkm::worklet::WorkletMapPointToCell
 {
 public:
-  typedef void ControlSignature(FieldInPoint<> inNodes,
+  using ControlSignature = void(FieldInPoint<> inNodes,
                                 CellSetIn cellset,
                                 FieldOutCell<IdComponentType> outCaseId);
-  typedef void ExecutionSignature(_1, _3);
+  using ExecutionSignature = void(_1, _3);
   using InputDomain = _2;
 
   T IsoValue;

examples/dynamic_dispatcher/main.cxx

@@ -31,13 +31,9 @@
 
 struct ExampleFieldWorklet : public vtkm::worklet::WorkletMapField
 {
-  typedef void ControlSignature(FieldIn<>,
-                                FieldIn<>,
-                                FieldIn<>,
-                                FieldOut<>,
-                                FieldOut<>,
-                                FieldOut<>);
-  typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6);
+  using ControlSignature =
+    void(FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>, FieldOut<>, FieldOut<>);
+  using ExecutionSignature = void(_1, _2, _3, _4, _5, _6);
 
   template <typename T, typename U, typename V>
   VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& vec,

examples/game_of_life/GameOfLife.cxx

@@ -78,12 +78,12 @@ struct UpdateLifeState : public vtkm::worklet::WorkletPointNeighborhood3x3x3
 {
   using CountingHandle = vtkm::cont::ArrayHandleCounting<vtkm::Id>;
 
-  typedef void ControlSignature(CellSetIn,
+  using ControlSignature = void(CellSetIn,
                                 FieldInNeighborhood<> prevstate,
                                 FieldOut<> state,
                                 FieldOut<> color);
 
-  typedef void ExecutionSignature(_2, _3, _4);
+  using ExecutionSignature = void(_2, _3, _4);
 
   template <typename NeighIn>
   VTKM_EXEC void operator()(const NeighIn& prevstate,

examples/hello_world/HelloWorld.cxx

@@ -144,8 +144,8 @@ struct HelloVTKMInterop
     {
     }
 
-    typedef void ControlSignature(FieldIn<>, FieldOut<>, FieldOut<>);
-    typedef void ExecutionSignature(_1, _2, _3);
+    using ControlSignature = void(FieldIn<>, FieldOut<>, FieldOut<>);
+    using ExecutionSignature = void(_1, _2, _3);
 
     VTKM_EXEC
     void operator()(const vtkm::Vec<T, 3>& input,

examples/isosurface/IsosurfaceUniformGrid.cxx

@@ -62,8 +62,8 @@ namespace
 class TangleField : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
+  using ExecutionSignature = void(_1, _2);
   using InputDomain = _1;
 
   const vtkm::Id xdim, ydim, zdim;

examples/multi_backend/IOGenerator.cxx

@@ -34,8 +34,8 @@
 
 struct WaveField : public vtkm::worklet::WorkletMapField
 {
-  typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Vec3>);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<Vec3>, FieldOut<Vec3>);
+  using ExecutionSignature = void(_1, _2);
 
   template <typename T>
   VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& input, vtkm::Vec<T, 3>& output) const

examples/tau_timing/TauTiming.cxx

@@ -69,8 +69,8 @@ using DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG;
 class TangleField : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
+  using ExecutionSignature = void(_1, _2);
   using InputDomain = _1;
 
   const vtkm::Id xdim, ydim, zdim;

examples/unified_memory/UnifiedMemory.cu

@@ -39,8 +39,8 @@ namespace
 class TangleField : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
-  typedef void ExecutionSignature(_1, _2);
+  using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
+  using ExecutionSignature = void(_1, _2);
   using InputDomain = _1;
 
   const vtkm::Id xdim, ydim, zdim;
@@ -126,8 +126,8 @@ namespace worklet
 class SineWorklet : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<>, FieldOut<>);
-  typedef _2 ExecutionSignature(_1, WorkIndex);
+  using ControlSignature = void(FieldIn<>, FieldOut<>);
+  using ExecutionSignature = _2(_1, WorkIndex);
 
   VTKM_EXEC
   vtkm::Float32 operator()(vtkm::Int64 x, vtkm::Id&) const

vtkm/cont/CellLocator.h

@@ -77,12 +77,12 @@ public:
                                                                 DIM>;
 
   public:
-    typedef void ControlSignature(FieldIn<Vec3> points,
+    using ControlSignature = void(FieldIn<Vec3> points,
                                   WholeCellSetIn<> cellSet,
                                   WholeArrayIn<Vec3> coordinates,
                                   FieldOut<IdType> cellIds,
                                   FieldOut<Vec3> parametricCoordinates);
-    typedef void ExecutionSignature(_1, _2, _3, _4, _5);
+    using ExecutionSignature = void(_1, _2, _3, _4, _5);
 
     template <typename CoordsPortalType, vtkm::IdComponent DIM>
     VTKM_EXEC void operator()(const vtkm::Vec<vtkm::FloatDefault, 3>& point,

vtkm/cont/CellLocatorTwoLevelUniformGrid.h

@@ -282,10 +282,10 @@ public:
   class CountBinsL1 : public vtkm::worklet::WorkletMapPointToCell
   {
   public:
-    typedef void ControlSignature(CellSetIn cellset,
+    using ControlSignature = void(CellSetIn cellset,
                                   FieldInPoint<Vec3> coords,
                                   FieldOutCell<IdType> bincount);
-    typedef void ExecutionSignature(_2, _3);
+    using ExecutionSignature = void(_2, _3);
 
     CountBinsL1(const Grid& grid)
       : L1Grid(grid)
@@ -307,11 +307,11 @@ public:
   class FindBinsL1 : public vtkm::worklet::WorkletMapPointToCell
   {
   public:
-    typedef void ControlSignature(CellSetIn cellset,
+    using ControlSignature = void(CellSetIn cellset,
                                   FieldInPoint<Vec3> coords,
                                   FieldInCell<IdType> offsets,
                                   WholeArrayOut<IdType> binIds);
-    typedef void ExecutionSignature(_2, _3, _4);
+    using ExecutionSignature = void(_2, _3, _4);
 
     FindBinsL1(const Grid& grid)
       : L1Grid(grid)
@@ -340,10 +340,10 @@ public:
   class GenerateBinsL1 : public vtkm::worklet::WorkletMapField
   {
   public:
-    typedef void ControlSignature(FieldIn<IdType> binIds,
+    using ControlSignature = void(FieldIn<IdType> binIds,
                                   FieldIn<IdType> cellCounts,
                                   WholeArrayOut<vtkm::ListTagBase<DimVec3>> dimensions);
-    typedef void ExecutionSignature(_1, _2, _3);
+    using ExecutionSignature = void(_1, _2, _3);
 
     using InputDomain = _1;
 
@@ -369,11 +369,11 @@ public:
   class CountBinsL2 : public vtkm::worklet::WorkletMapPointToCell
   {
   public:
-    typedef void ControlSignature(CellSetIn cellset,
+    using ControlSignature = void(CellSetIn cellset,
                                   FieldInPoint<Vec3> coords,
                                   WholeArrayIn<vtkm::ListTagBase<DimVec3>> binDimensions,
                                   FieldOutCell<IdType> bincount);
-    typedef void ExecutionSignature(_2, _3, _4);
+    using ExecutionSignature = void(_2, _3, _4);
 
     CountBinsL2(const Grid& grid)
       : L1Grid(grid)
@@ -404,14 +404,14 @@ public:
   class FindBinsL2 : public vtkm::worklet::WorkletMapPointToCell
   {
   public:
-    typedef void ControlSignature(CellSetIn cellset,
+    using ControlSignature = void(CellSetIn cellset,
                                   FieldInPoint<Vec3> coords,
                                   WholeArrayIn<vtkm::ListTagBase<DimVec3>> binDimensions,
                                   WholeArrayIn<IdType> binStarts,
                                   FieldInCell<IdType> offsets,
                                   WholeArrayOut<IdType> binIds,
                                   WholeArrayOut<IdType> cellIds);
-    typedef void ExecutionSignature(InputIndex, _2, _3, _4, _5, _6, _7);
+    using ExecutionSignature = void(InputIndex, _2, _3, _4, _5, _6, _7);
 
     FindBinsL2(const Grid& grid)
       : L1Grid(grid)
@@ -456,12 +456,12 @@ public:
   class GenerateBinsL2 : public vtkm::worklet::WorkletMapField
   {
   public:
-    typedef void ControlSignature(FieldIn<IdType> binIds,
+    using ControlSignature = void(FieldIn<IdType> binIds,
                                   FieldIn<IdType> startsIn,
                                   FieldIn<IdType> countsIn,
                                   WholeArrayOut<IdType> startsOut,
                                   WholeArrayOut<IdType> countsOut);
-    typedef void ExecutionSignature(_1, _2, _3, _4, _5);
+    using ExecutionSignature = void(_1, _2, _3, _4, _5);
 
     using InputDomain = _1;
 
@@ -639,13 +639,13 @@ public:
   class FindCellWorklet : public vtkm::worklet::WorkletMapField
   {
   public:
-    typedef void ControlSignature(FieldIn<Vec3> points,
+    using ControlSignature = void(FieldIn<Vec3> points,
                                   WholeCellSetIn<> cellSet,
                                   WholeArrayIn<Vec3> coordinates,
                                   ExecObject lookupStruct,
                                   FieldOut<IdType> cellIds,
                                   FieldOut<Vec3> parametricCoordinates);
-    typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6);
+    using ExecutionSignature = void(_1, _2, _3, _4, _5, _6);
 
     using InputDomain = _1;
 

vtkm/cont/CellSetPermutation.h

@@ -46,10 +46,10 @@ namespace internal
 
 struct WriteConnectivity : public vtkm::worklet::WorkletMapPointToCell
 {
-  typedef void ControlSignature(CellSetIn cellset,
+  using ControlSignature = void(CellSetIn cellset,
                                 FieldInCell<IdType> offset,
                                 WholeArrayOut<> connectivity);
-  typedef void ExecutionSignature(PointCount, PointIndices, _2, _3);
+  using ExecutionSignature = void(PointCount, PointIndices, _2, _3);
   using InputDomain = _1;
 
   template <typename PointIndicesType, typename OutPortalType>

vtkm/cont/PointLocatorUniformGrid.h

@@ -46,9 +46,9 @@ public:
   class BinPointsWorklet : public vtkm::worklet::WorkletMapField
   {
   public:
-    typedef void ControlSignature(FieldIn<> coord, FieldOut<> label);
+    using ControlSignature = void(FieldIn<> coord, FieldOut<> label);
 
-    typedef void ExecutionSignature(_1, _2);
+    using ExecutionSignature = void(_1, _2);
 
     VTKM_CONT
     BinPointsWorklet(vtkm::Vec<T, 3> _min, vtkm::Vec<T, 3> _max, vtkm::Vec<vtkm::Id, 3> _dims)
@@ -74,7 +74,7 @@ public:
   class UniformGridSearch : public vtkm::worklet::WorkletMapField
   {
   public:
-    typedef void ControlSignature(FieldIn<> query,
+    using ControlSignature = void(FieldIn<> query,
                                   WholeArrayIn<> coordIn,
                                   WholeArrayIn<IdType> pointId,
                                   WholeArrayIn<IdType> cellLower,
@@ -82,7 +82,7 @@ public:
                                   FieldOut<IdType> neighborId,
                                   FieldOut<> distance);
 
-    typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7);
+    using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7);
 
     VTKM_CONT
     UniformGridSearch(const vtkm::Vec<T, 3>& _min,

vtkm/cont/internal/ConnectivityExplicitInternals.h

@@ -176,11 +176,11 @@ struct ConnectivityExplicitInternals
 class ExpandIndices : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<> cellIndex,
+  using ControlSignature = void(FieldIn<> cellIndex,
                                 FieldIn<> offset,
                                 FieldIn<> numIndices,
                                 WholeArrayOut<> cellIndices);
-  typedef void ExecutionSignature(_1, _2, _3, _4);
+  using ExecutionSignature = void(_1, _2, _3, _4);
   using InputDomain = _1;
 
   VTKM_CONT
@@ -204,8 +204,8 @@ public:
 class ScatterValues : public vtkm::worklet::WorkletMapField
 {
 public:
-  typedef void ControlSignature(FieldIn<> index, FieldIn<> value, WholeArrayOut<> output);
-  typedef void ExecutionSignature(_1, _2, _3);
+  using ControlSignature = void(FieldIn<> index, FieldIn<> value, WholeArrayOut<> output);
+  using ExecutionSignature = void(_1, _2, _3);
   using InputDomain = _1;
 
   template <typename T, typename PortalType>

vtkm/cont/tbb/internal/ParallelSortTBB.cxx

@@ -488,7 +488,7 @@ void ParallelRadixSortInternal<PlainType, CompareType, UnsignedType, Encoder, Va
     }
   };
 
-  typedef RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>> RunTaskType;
+  using RunTaskType = RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>>;
 
   RunTaskType& root =
     *new (::tbb::task::allocate_root()) RunTaskType(0, 1, lambda, num_elems_, num_threads_);
@@ -563,7 +563,7 @@ void ParallelRadixSortInternal<PlainType, CompareType, UnsignedType, Encoder, Va
     }
   };
 
-  typedef RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>> RunTaskType;
+  using RunTaskType = RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>>;
 
   RunTaskType& root =
     *new (::tbb::task::allocate_root()) RunTaskType(0, 1, lambda, num_elems_, num_threads_);

vtkm/cont/testing/TestingArrayHandleVirtualCoordinates.h

@@ -39,8 +39,8 @@ namespace
 
 struct CopyWorklet : public vtkm::worklet::WorkletMapField
 {
-  typedef void ControlSignature(FieldIn<FieldCommon> in, FieldOut<FieldCommon> out);
-  typedef _2 ExecutionSignature(_1);
+  using ControlSignature = void(FieldIn<FieldCommon> in, FieldOut<FieldCommon> out);
+  using ExecutionSignature = _2(_1);
 
   template <typename T>
   VTKM_EXEC T operator()(const T& in) const

vtkm/cont/testing/TestingArrayHandles.h

@@ -90,8 +90,8 @@ struct TestingArrayHandles
 
   struct PassThrough : public vtkm::worklet::WorkletMapField
   {
-    typedef void ControlSignature(FieldIn<>, FieldOut<>);
-    typedef _2 ExecutionSignature(_1);
+    using ControlSignature = void(FieldIn<>, FieldOut<>);
+    using ExecutionSignature = _2(_1);
 
     template <class ValueType>
     VTKM_EXEC ValueType operator()(const ValueType& inValue) const

vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h

@@ -47,11 +47,11 @@ std::default_random_engine RandomGenerator;
 class ParametricToWorldCoordinates : public vtkm::worklet::WorkletMapPointToCell
 {
 public:
-  typedef void ControlSignature(CellSetIn cellset,
+  using ControlSignature = void(CellSetIn cellset,
                                 FieldInPoint<Vec3> coords,
                                 FieldInOutCell<Vec3> pcs,
                                 FieldOutCell<Vec3> wcs);
-  typedef void ExecutionSignature(CellShape, _2, _3, _4);
+  using ExecutionSignature = void(CellShape, _2, _3, _4);
 
   using ScatterType = vtkm::worklet::ScatterPermutation<>;
 

vtkm/cont/testing/TestingDeviceAdapter.h

@@ -145,8 +145,8 @@ public:
   struct ClearArrayMapKernel //: public vtkm::exec::WorkletMapField
   {
 
-    // typedef void ControlSignature(Field(Out));
-    // typedef void ExecutionSignature(_1);
+    // using ControlSignature = void(Field(Out));
+    // using ExecutionSignature = void(_1);
 
     template <typename T>
     VTKM_EXEC void operator()(T& value) const

vtkm/cont/testing/TestingFancyArrayHandles.h

@@ -123,8 +123,8 @@ private:
 public:
   struct PassThrough : public vtkm::worklet::WorkletMapField
   {
-    typedef void ControlSignature(FieldIn<>, FieldOut<>);
-    typedef _2 ExecutionSignature(_1);
+    using ControlSignature = void(FieldIn<>, FieldOut<>);
+    using ExecutionSignature = _2(_1);
 
     template <class ValueType>
     VTKM_EXEC ValueType operator()(const ValueType& inValue) const
@@ -135,8 +135,8 @@ public:
 
   struct InplaceFunctorPair : public vtkm::worklet::WorkletMapField
   {
-    typedef void ControlSignature(FieldInOut<>);
-    typedef void ExecutionSignature(_1);
+    using ControlSignature = void(FieldInOut<>);
+    using ExecutionSignature = void(_1);
 
     template <typename T>
     VTKM_EXEC void operator()(vtkm::Pair<T, T>& value) const
@@ -604,8 +604,8 @@ private:
   // worklets.
   struct GroupVariableInputWorklet : public vtkm::worklet::WorkletMapField
   {
-    typedef void ControlSignature(FieldIn<>);
-    typedef void ExecutionSignature(_1, WorkIndex);
+    using ControlSignature = void(FieldIn<>);
+    using ExecutionSignature = void(_1, WorkIndex);
 
     template <typename InputType>
     VTKM_EXEC void operator()(const InputType& input, vtkm::Id workIndex) const
@@ -659,8 +659,8 @@ private:
   // worklets.
   struct GroupVariableOutputWorklet : public vtkm::worklet::WorkletMapField
   {
-    typedef void ControlSignature(FieldIn<>, FieldOut<>);
-    typedef void ExecutionSignature(_2, WorkIndex);
+    using ControlSignature = void(FieldIn<>, FieldOut<>);
+    using ExecutionSignature = void(_2, WorkIndex);
 
     template <typename OutputType>
     VTKM_EXEC void operator()(OutputType& output, vtkm::Id workIndex) const

vtkm/cont/testing/TestingImplicitFunction.h

@@ -47,8 +47,8 @@ namespace implicit_function_detail
 class EvaluateImplicitFunction : public vtkm::worklet::WorkletMapField
 {
 public: