clang-format: reformat the repository with clang-format-9

benchmarking/Benchmarker.h

@@ -280,9 +280,7 @@ namespace bench
 namespace detail
 {
 
-static inline void NullApply(::benchmark::internal::Benchmark*)
-{
-}
+static inline void NullApply(::benchmark::internal::Benchmark*) {}
 
 /// Do not use directly. The VTKM_BENCHMARK_TEMPLATES macros should be used
 /// instead.

examples/contour_tree_augmented/ContourTreeApp.cxx

@@ -370,28 +370,14 @@ int main(int argc, char* argv[])
     VTKM_LOG_IF_S(vtkm::cont::LogLevel::Info,
                   numLevels > 0,
                   std::endl
-                    << "    ------------ Settings Isolevel Selection -----------"
-                    << std::endl
-                    << "    levels="
-                    << numLevels
-                    << std::endl
-                    << "    eps="
-                    << eps
-                    << std::endl
-                    << "    comp"
-                    << numComp
-                    << std::endl
-                    << "    type="
-                    << contourType
-                    << std::endl
-                    << "    method="
-                    << contourSelectMethod
-                    << std::endl
-                    << "    mc="
-                    << useMarchingCubes
-                    << std::endl
-                    << "    use"
-                    << (usePersistenceSorter ? "PersistenceSorter" : "VolumeSorter"));
+                    << "    ------------ Settings Isolevel Selection -----------" << std::endl
+                    << "    levels=" << numLevels << std::endl
+                    << "    eps=" << eps << std::endl
+                    << "    comp" << numComp << std::endl
+                    << "    type=" << contourType << std::endl
+                    << "    method=" << contourSelectMethod << std::endl
+                    << "    mc=" << useMarchingCubes << std::endl
+                    << "    use" << (usePersistenceSorter ? "PersistenceSorter" : "VolumeSorter"));
   }
   currTime = totalTime.GetElapsedTime();
   vtkm::Float64 startUpTime = currTime - prevTime;
@@ -558,18 +544,16 @@ int main(int argc, char* argv[])
   {
     VTKM_LOG_S(vtkm::cont::LogLevel::Info,
                std::endl
-                 << "    ---------------- Input Mesh Properties --------------"
-                 << std::endl
-                 << "    Number of dimensions: "
-                 << nDims);
+                 << "    ---------------- Input Mesh Properties --------------" << std::endl
+                 << "    Number of dimensions: " << nDims);
   }
 
   // Check if marching cubes is enabled for non 3D data
   bool invalidMCOption = (useMarchingCubes && nDims != 3);
-  VTKM_LOG_IF_S(
-    vtkm::cont::LogLevel::Error,
+  VTKM_LOG_IF_S(vtkm::cont::LogLevel::Error,
                 invalidMCOption && (rank == 0),
-    "The input mesh is " << nDims << "D. "
+                "The input mesh is "
+                  << nDims << "D. "
                   << "Contour tree using marching cubes is only supported for 3D data.");
 
   // If we found any errors in the setttings than finalize MPI and exit the execution
@@ -866,116 +850,47 @@ int main(int argc, char* argv[])
   currTime = totalTime.GetElapsedTime();
   VTKM_LOG_S(vtkm::cont::LogLevel::Info,
              std::endl
-               << "    -------------------------- Totals "
-               << rank
-               << " -----------------------------"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Start-up"
-               << ": "
-               << startUpTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Data Read"
-               << ": "
-               << dataReadTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Build VTKM Dataset"
-               << ": "
-               << buildDatasetTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Compute Contour Tree"
-               << ": "
-               << computeContourTreeTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Compute Branch Decomposition"
-               << ": "
-               << computeBranchDecompTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Total Time"
-               << ": "
-               << currTime
-               << " seconds");
+               << "    -------------------------- Totals " << rank
+               << " -----------------------------" << std::endl
+               << std::setw(42) << std::left << "    Start-up"
+               << ": " << startUpTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Data Read"
+               << ": " << dataReadTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Build VTKM Dataset"
+               << ": " << buildDatasetTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Compute Contour Tree"
+               << ": " << computeContourTreeTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Compute Branch Decomposition"
+               << ": " << computeBranchDecompTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Total Time"
+               << ": " << currTime << " seconds");
 
   const ctaug_ns::ContourTree& ct = filter.GetContourTree();
   VTKM_LOG_S(vtkm::cont::LogLevel::Info,
              std::endl
-               << "    ---------------- Contour Tree Array Sizes ---------------------"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Nodes"
-               << ": "
-               << ct.Nodes.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Arcs"
-               << ": "
-               << ct.Arcs.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Superparents"
-               << ": "
-               << ct.Superparents.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Superarcs"
-               << ": "
-               << ct.Superarcs.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Supernodes"
-               << ": "
-               << ct.Supernodes.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Hyperparents"
-               << ": "
-               << ct.Hyperparents.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #WhenTransferred"
-               << ": "
-               << ct.WhenTransferred.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Hypernodes"
-               << ": "
-               << ct.Hypernodes.GetNumberOfValues()
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    #Hyperarcs"
-               << ": "
-               << ct.Hyperarcs.GetNumberOfValues()
-               << std::endl);
+               << "    ---------------- Contour Tree Array Sizes ---------------------" << std::endl
+               << std::setw(42) << std::left << "    #Nodes"
+               << ": " << ct.Nodes.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #Arcs"
+               << ": " << ct.Arcs.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #Superparents"
+               << ": " << ct.Superparents.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #Superarcs"
+               << ": " << ct.Superarcs.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #Supernodes"
+               << ": " << ct.Supernodes.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #Hyperparents"
+               << ": " << ct.Hyperparents.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #WhenTransferred"
+               << ": " << ct.WhenTransferred.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #Hypernodes"
+               << ": " << ct.Hypernodes.GetNumberOfValues() << std::endl
+               << std::setw(42) << std::left << "    #Hyperarcs"
+               << ": " << ct.Hyperarcs.GetNumberOfValues() << std::endl);
   // Print hyperstructure statistics
   VTKM_LOG_S(vtkm::cont::LogLevel::Info,
              std::endl
-               << ct.PrintHyperStructureStatistics(false)
-               << std::endl);
+               << ct.PrintHyperStructureStatistics(false) << std::endl);
 
   // Flush ouput streams just to make sure everything has been logged (in particular when using MPI)
   std::cout << std::flush;

examples/contour_tree_distributed/ContourTreeApp.cxx

@@ -252,25 +252,14 @@ int main(int argc, char* argv[])
   {
     VTKM_LOG_S(vtkm::cont::LogLevel::Info,
                std::endl
-                 << "    ------------ Settings -----------"
-                 << std::endl
-                 << "    filename="
-                 << filename
-                 << std::endl
-                 << "    device="
-                 << device.GetName()
-                 << std::endl
-                 << "    mc="
-                 << useMarchingCubes
-                 << std::endl
+                 << "    ------------ Settings -----------" << std::endl
+                 << "    filename=" << filename << std::endl
+                 << "    device=" << device.GetName() << std::endl
+                 << "    mc=" << useMarchingCubes << std::endl
 #ifdef ENABLE_SET_NUM_THREADS
-                 << "    numThreads="
-                 << numThreads
-                 << std::endl
+                 << "    numThreads=" << numThreads << std::endl
 #endif
-                 << "    nblocks="
-                 << numBlocks
-                 << std::endl);
+                 << "    nblocks=" << numBlocks << std::endl);
   }
   currTime = totalTime.GetElapsedTime();
   vtkm::Float64 startUpTime = currTime - prevTime;
@@ -341,14 +330,9 @@ int main(int argc, char* argv[])
   {
     VTKM_LOG_S(vtkm::cont::LogLevel::Info,
                std::endl
-                 << "    ---------------- Input Mesh Properties --------------"
-                 << std::endl
-                 << "    Number of dimensions: "
-                 << nDims
-                 << std::endl
-                 << "    Number of mesh vertices: "
-                 << numVertices
-                 << std::endl);
+                 << "    ---------------- Input Mesh Properties --------------" << std::endl
+                 << "    Number of dimensions: " << nDims << std::endl
+                 << "    Number of mesh vertices: " << numVertices << std::endl);
   }
 
   // Check for fatal input errors
@@ -359,12 +343,13 @@ int main(int argc, char* argv[])
   // Log any errors if found on rank 0
   VTKM_LOG_IF_S(vtkm::cont::LogLevel::Error,
                 invalidNumDimensions && (rank == 0),
-                "The input mesh is " << nDims << "D. "
+                "The input mesh is " << nDims
+                                     << "D. "
                                         "The input data must be either 2D or 3D.");
-  VTKM_LOG_IF_S(
-    vtkm::cont::LogLevel::Error,
+  VTKM_LOG_IF_S(vtkm::cont::LogLevel::Error,
                 invalidMCOption && (rank == 0),
-    "The input mesh is " << nDims << "D. "
+                "The input mesh is "
+                  << nDims << "D. "
                   << "Contour tree using marching cubes is only supported for 3D data.");
   // If we found any errors in the setttings than finalize MPI and exit the execution
   if (invalidNumDimensions || invalidMCOption)
@@ -519,44 +504,18 @@ int main(int argc, char* argv[])
   currTime = totalTime.GetElapsedTime();
   VTKM_LOG_S(vtkm::cont::LogLevel::Info,
              std::endl
-               << "    -------------------------- Totals "
-               << rank
-               << " -----------------------------"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Start-up"
-               << ": "
-               << startUpTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Data Read"
-               << ": "
-               << dataReadTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Build VTKM Dataset"
-               << ": "
-               << buildDatasetTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Compute Contour Tree"
-               << ": "
-               << computeContourTreeTime
-               << " seconds"
-               << std::endl
-               << std::setw(42)
-               << std::left
-               << "    Total Time"
-               << ": "
-               << currTime
-               << " seconds");
+               << "    -------------------------- Totals " << rank
+               << " -----------------------------" << std::endl
+               << std::setw(42) << std::left << "    Start-up"
+               << ": " << startUpTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Data Read"
+               << ": " << dataReadTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Build VTKM Dataset"
+               << ": " << buildDatasetTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Compute Contour Tree"
+               << ": " << computeContourTreeTime << " seconds" << std::endl
+               << std::setw(42) << std::left << "    Total Time"
+               << ": " << currTime << " seconds");
 
   // Flush ouput streams just to make sure everything has been logged (in particular when using MPI)
   std::cout << std::flush;

examples/demo/Demo.cxx

@@ -25,10 +25,10 @@
 // write that image to a file. It then computes an isosurface on the input data set and renders
 // this output data set in a separate image file
 
-using vtkm::rendering::MapperVolume;
-using vtkm::rendering::MapperRayTracer;
-using vtkm::rendering::MapperWireframer;
 using vtkm::rendering::CanvasRayTracer;
+using vtkm::rendering::MapperRayTracer;
+using vtkm::rendering::MapperVolume;
+using vtkm::rendering::MapperWireframer;
 
 int main(int argc, char* argv[])
 {

examples/ising/Ising.cxx

@@ -66,8 +66,8 @@ struct UpdateSpins : public vtkm::worklet::WorkletCellNeighborhood
     const auto mySpin = prevspin.Get(0, 0, 0);
 
     // 1. Calculate the energy of flipping, E_flip
-    vtkm::Float32 E_flip =
-      J * mySpin * (prevspin.Get(-1, -1, 0) + prevspin.Get(-1, 0, 0) + prevspin.Get(-1, 1, 0) +
+    vtkm::Float32 E_flip = J * mySpin *
+      (prevspin.Get(-1, -1, 0) + prevspin.Get(-1, 0, 0) + prevspin.Get(-1, 1, 0) +
        prevspin.Get(0, -1, 0) + prevspin.Get(0, 1, 0) + prevspin.Get(1, -1, 0) +
        prevspin.Get(1, 0, 0) + prevspin.Get(1, 1, 0));
 

examples/redistribute_points/RedistributePoints.h

@@ -223,7 +223,8 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet RedistributePoints::PrepareForEx
   vtkmdiy::RegularDecomposer<vtkmdiy::ContinuousBounds> decomposer(
     /*dim*/ 3, internal::convert(gbounds), assigner.nblocks());
 
-  vtkmdiy::Master master(comm,
+  vtkmdiy::Master master(
+    comm,
     /*threads*/ 1,
     /*limit*/ -1,
     []() -> void* { return new vtkm::cont::DataSet(); },

vtkm/List.h

@@ -226,8 +226,7 @@ template <vtkm::IdComponent NumSearched,
           typename... Ts>
 struct FindFirstOfType<NumSearched, Target, T0, T1, T2, T3, T4, T5, Ts...>
   : FindFirstOfSplit4<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
-                       std::is_same<Target, T2>::value ||
-                       std::is_same<Target, T3>::value),
+                       std::is_same<Target, T2>::value || std::is_same<Target, T3>::value),
                       NumSearched,
                       Target,
                       T0,
@@ -257,8 +256,7 @@ template <vtkm::IdComponent NumSearched,
           typename... Ts>
 struct FindFirstOfSplit8<true, NumSearched, Target, T0, T1, T2, T3, T4, T5, T6, T7, Ts...>
   : FindFirstOfSplit4<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
-                       std::is_same<Target, T2>::value ||
-                       std::is_same<Target, T3>::value),
+                       std::is_same<Target, T2>::value || std::is_same<Target, T3>::value),
                       NumSearched,
                       Target,
                       T0,
@@ -305,12 +303,9 @@ template <vtkm::IdComponent NumSearched,
           typename... Ts>
 struct FindFirstOfType<NumSearched, Target, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Ts...>
   : FindFirstOfSplit8<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
-                       std::is_same<Target, T2>::value ||
-                       std::is_same<Target, T3>::value ||
-                       std::is_same<Target, T4>::value ||
-                       std::is_same<Target, T5>::value ||
-                       std::is_same<Target, T6>::value ||
-                       std::is_same<Target, T7>::value),
+                       std::is_same<Target, T2>::value || std::is_same<Target, T3>::value ||
+                       std::is_same<Target, T4>::value || std::is_same<Target, T5>::value ||
+                       std::is_same<Target, T6>::value || std::is_same<Target, T7>::value),
                       NumSearched,
                       Target,
                       T0,

vtkm/cont/ArrayGetValues.h

@@ -101,8 +101,7 @@ VTKM_CONT void ArrayGetValues(const vtkm::cont::ArrayHandle<vtkm::Id, SIds>& ids
     { // Retry on any device if the first attempt failed.
       VTKM_LOG_S(vtkm::cont::LogLevel::Error,
                  "Failed to run ArrayGetValues on device '"
-                   << devId.GetName()
-                   << "'. Falling back to control-side copy.");
+                   << devId.GetName() << "'. Falling back to control-side copy.");
       copyComplete = vtkm::cont::Algorithm::Copy(vtkm::cont::DeviceAdapterTagAny{}, input, output);
     }
   }

vtkm/cont/ArrayHandle.h

@@ -173,7 +173,10 @@ struct GetTypeInParentheses<void(T)>
   }                                                                                                \
                                                                                                    \
   VTKM_CONT                                                                                        \
-  classname(Thisclass&& src) noexcept : Superclass(std::move(src)) {}                              \
+  classname(Thisclass&& src) noexcept                                                              \
+    : Superclass(std::move(src))                                                                   \
+  {                                                                                                \
+  }                                                                                                \
                                                                                                    \
   VTKM_CONT                                                                                        \
   classname(const vtkm::cont::ArrayHandle<typename__ Superclass::ValueType,                        \

vtkm/cont/ArrayHandleBitField.h

@@ -29,10 +29,16 @@ public:
   using ValueType = bool;
 
   VTKM_EXEC_CONT
-  explicit ArrayPortalBitField(const BitPortalType& portal) noexcept : BitPortal{ portal } {}
+  explicit ArrayPortalBitField(const BitPortalType& portal) noexcept
+    : BitPortal{ portal }
+  {
+  }
 
   VTKM_EXEC_CONT
-  explicit ArrayPortalBitField(BitPortalType&& portal) noexcept : BitPortal{ std::move(portal) } {}
+  explicit ArrayPortalBitField(BitPortalType&& portal) noexcept
+    : BitPortal{ std::move(portal) }
+  {
+  }
 
   ArrayPortalBitField() noexcept = default;
   ArrayPortalBitField(const ArrayPortalBitField&) noexcept = default;
@@ -78,7 +84,10 @@ public:
   {
   }
 
-  explicit VTKM_CONT Storage(vtkm::cont::BitField&& data) noexcept : Data{ std::move(data) } {}
+  explicit VTKM_CONT Storage(vtkm::cont::BitField&& data) noexcept
+    : Data{ std::move(data) }
+  {
+  }
 
   VTKM_CONT Storage() = default;
   VTKM_CONT Storage(const Storage&) = default;

vtkm/cont/ArrayHandleCast.h

@@ -135,14 +135,11 @@ struct Storage<TargetT, vtkm::cont::StorageTagCast<SourceT, SourceStorage>>
 
 template <typename TargetT, typename SourceT, typename SourceStorage, typename Device>
 struct ArrayTransfer<TargetT, vtkm::cont::StorageTagCast<SourceT, SourceStorage>, Device>
-  : detail::ArrayHandleCastTraits<TargetT,
-                                  SourceT,
-                                  SourceStorage>::template ArrayTransferSuperclass<Device>
+  : detail::ArrayHandleCastTraits<TargetT, SourceT, SourceStorage>::
+      template ArrayTransferSuperclass<Device>
 {
-  using Superclass =
-    typename detail::ArrayHandleCastTraits<TargetT,
-                                           SourceT,
-                                           SourceStorage>::template ArrayTransferSuperclass<Device>;
+  using Superclass = typename detail::ArrayHandleCastTraits<TargetT, SourceT, SourceStorage>::
+    template ArrayTransferSuperclass<Device>;
 
   using Superclass::Superclass;
 };

vtkm/cont/ArrayHandleCompositeVector.h

@@ -500,9 +500,9 @@ public:
   using PortalControl = typename StorageType::PortalType;
   using PortalConstControl = typename StorageType::PortalConstType;
 
-  using PortalExecution = ArrayPortalCompositeVector<
-    typename vtkm::cont::ArrayHandle<T,
-                                     StorageTags>::template ExecutionTypes<DeviceTag>::Portal...>;
+  using PortalExecution =
+    ArrayPortalCompositeVector<typename vtkm::cont::ArrayHandle<T, StorageTags>::
+                                 template ExecutionTypes<DeviceTag>::Portal...>;
   using PortalConstExecution =
     ArrayPortalCompositeVector<typename vtkm::cont::ArrayHandle<T, StorageTags>::
                                  template ExecutionTypes<DeviceTag>::PortalConst...>;

vtkm/cont/ArrayHandleMultiplexer.h

@@ -101,7 +101,8 @@ struct ArrayPortalMultiplexer
   ArrayPortalMultiplexer& operator=(const ArrayPortalMultiplexer&) = default;
 
   template <typename Portal>
-  VTKM_EXEC_CONT ArrayPortalMultiplexer(const Portal& src) noexcept : PortalVariant(src)
+  VTKM_EXEC_CONT ArrayPortalMultiplexer(const Portal& src) noexcept
+    : PortalVariant(src)
   {
   }
 

vtkm/cont/ArrayHandleSOA.h

@@ -183,13 +183,10 @@ struct ArrayHandleSOATraits
 
   using IsTrueVec = std::integral_constant<bool, (NUM_COMPONENTS > 1)>;
 
-  using PortalControl = typename detail::SOAPortalChooser<ValueType,
-                                                          typename BaseArrayType::WritePortalType,
-                                                          IsTrueVec>::Type;
-  using PortalConstControl =
-    typename detail::SOAPortalChooser<ValueType,
-                                      typename BaseArrayType::ReadPortalType,
-                                      IsTrueVec>::Type;
+  using PortalControl = typename detail::
+    SOAPortalChooser<ValueType, typename BaseArrayType::WritePortalType, IsTrueVec>::Type;
+  using PortalConstControl = typename detail::
+    SOAPortalChooser<ValueType, typename BaseArrayType::ReadPortalType, IsTrueVec>::Type;
 
   template <typename Device>
   using PortalExecution = typename detail::SOAPortalChooser<

vtkm/cont/AssignerPartitionedDataSet.cxx

@@ -50,9 +50,7 @@ AssignerPartitionedDataSet::AssignerPartitionedDataSet(vtkm::Id num_partitions)
 }
 
 VTKM_CONT
-AssignerPartitionedDataSet::~AssignerPartitionedDataSet()
-{
-}
+AssignerPartitionedDataSet::~AssignerPartitionedDataSet() {}
 
 VTKM_CONT
 void AssignerPartitionedDataSet::local_gids(int my_rank, std::vector<int>& gids) const

vtkm/cont/CellLocatorUniformBins.cxx

@@ -70,8 +70,9 @@ VTKM_EXEC static BinsBBox ComputeIntersectingBins(const Bounds cellBounds, const
 
 VTKM_EXEC static vtkm::Id GetNumberOfBins(const BinsBBox& binsBBox)
 {
-  return binsBBox.Empty() ? 0 : ((binsBBox.Max[0] - binsBBox.Min[0] + 1) *
-                                 (binsBBox.Max[1] - binsBBox.Min[1] + 1) *
+  return binsBBox.Empty()
+    ? 0
+    : ((binsBBox.Max[0] - binsBBox.Min[0] + 1) * (binsBBox.Max[1] - binsBBox.Min[1] + 1) *
        (binsBBox.Max[2] - binsBBox.Min[2] + 1));
 }
 

vtkm/cont/CellSet.cxx

@@ -15,8 +15,6 @@ namespace vtkm
 namespace cont
 {
 
-CellSet::~CellSet()
-{
-}
+CellSet::~CellSet() {}
 }
 } // namespace vtkm::cont

vtkm/cont/CellSetExplicit.h

@@ -131,9 +131,8 @@ class VTKM_ALWAYS_EXPORT CellSetExplicit : public CellSet
   struct ConnectivityChooser
   {
   private:
-    using Chooser = typename detail::CellSetExplicitConnectivityChooser<Thisclass,
-                                                                        VisitTopology,
-                                                                        IncidentTopology>;
+    using Chooser = typename detail::
+      CellSetExplicitConnectivityChooser<Thisclass, VisitTopology, IncidentTopology>;
 
   public:
     using ConnectivityType = typename Chooser::ConnectivityType;

vtkm/cont/CellSetExtrude.cxx

@@ -64,18 +64,18 @@ CellSetExtrude::CellSetExtrude(const CellSetExtrude& src)
 }
 
 CellSetExtrude::CellSetExtrude(CellSetExtrude&& src) noexcept
-  : CellSet(std::forward<CellSet>(src)),
-    IsPeriodic(src.IsPeriodic),
-    NumberOfPointsPerPlane(src.NumberOfPointsPerPlane),
-    NumberOfCellsPerPlane(src.NumberOfCellsPerPlane),
-    NumberOfPlanes(src.NumberOfPlanes),
-    Connectivity(std::move(src.Connectivity)),
-    NextNode(std::move(src.NextNode)),
-    ReverseConnectivityBuilt(src.ReverseConnectivityBuilt),
-    RConnectivity(std::move(src.RConnectivity)),
-    ROffsets(std::move(src.ROffsets)),
-    RCounts(std::move(src.RCounts)),
-    PrevNode(std::move(src.PrevNode))
+  : CellSet(std::forward<CellSet>(src))
+  , IsPeriodic(src.IsPeriodic)
+  , NumberOfPointsPerPlane(src.NumberOfPointsPerPlane)
+  , NumberOfCellsPerPlane(src.NumberOfCellsPerPlane)
+  , NumberOfPlanes(src.NumberOfPlanes)
+  , Connectivity(std::move(src.Connectivity))
+  , NextNode(std::move(src.NextNode))
+  , ReverseConnectivityBuilt(src.ReverseConnectivityBuilt)
+  , RConnectivity(std::move(src.RConnectivity))
+  , ROffsets(std::move(src.ROffsets))
+  , RCounts(std::move(src.RCounts))
+  , PrevNode(std::move(src.PrevNode))
 {
 }
 
@@ -117,9 +117,7 @@ CellSetExtrude& CellSetExtrude::operator=(CellSetExtrude&& src) noexcept
   return *this;
 }
 
-CellSetExtrude::~CellSetExtrude()
-{
-}
+CellSetExtrude::~CellSetExtrude() {}
 
 vtkm::Int32 CellSetExtrude::GetNumberOfPlanes() const
 {

vtkm/cont/CellSetPermutation.h

@@ -172,9 +172,8 @@ private:
 
 
 public:
-  using ConnectivityArrays = vtkm::cont::internal::RConnBuilderInputData<ConnectivityStorageTag,
-                                                                         OffsetsStorageTag,
-                                                                         NumIndicesStorageTag>;
+  using ConnectivityArrays = vtkm::cont::internal::
+    RConnBuilderInputData<ConnectivityStorageTag, OffsetsStorageTag, NumIndicesStorageTag>;
 
   template <typename Device>
   static ConnectivityArrays Get(const CellSetPermutationType& cellset, Device)

vtkm/cont/CellSetSingleType.h

@@ -61,10 +61,11 @@ public:
   }
 
   VTKM_CONT
-  CellSetSingleType(Thisclass&& src) noexcept : Superclass(std::forward<Superclass>(src)),
-                                                ExpectedNumberOfCellsAdded(-1),
-                                                CellShapeAsId(src.CellShapeAsId),
-                                                NumberOfPointsPerCell(src.NumberOfPointsPerCell)
+  CellSetSingleType(Thisclass&& src) noexcept
+    : Superclass(std::forward<Superclass>(src))
+    , ExpectedNumberOfCellsAdded(-1)
+    , CellShapeAsId(src.CellShapeAsId)
+    , NumberOfPointsPerCell(src.NumberOfPointsPerCell)
   {
   }
 

vtkm/cont/CellSetStructured.h

@@ -150,8 +150,9 @@ public:
     return *this;
   }
 
-  CellSetStructured(CellSetStructured&& src) noexcept : CellSet(),
-                                                        Structure(std::move(src.Structure))
+  CellSetStructured(CellSetStructured&& src) noexcept
+    : CellSet()
+    , Structure(std::move(src.Structure))
   {
   }
 

vtkm/cont/CellSetStructured.hxx

@@ -26,9 +26,8 @@ typename CellSetStructured<DIMENSION>::SchedulingRangeType
 
 template <vtkm::IdComponent DIMENSION>
 template <typename DeviceAdapter, typename VisitTopology, typename IncidentTopology>
-typename CellSetStructured<DIMENSION>::template ExecutionTypes<DeviceAdapter,
-                                                               VisitTopology,
-                                                               IncidentTopology>::ExecObjectType
+typename CellSetStructured<DIMENSION>::
+  template ExecutionTypes<DeviceAdapter, VisitTopology, IncidentTopology>::ExecObjectType
   CellSetStructured<DIMENSION>::PrepareForInput(DeviceAdapter,
                                                 VisitTopology,
                                                 IncidentTopology,

vtkm/cont/ColorTable.cxx

@@ -110,9 +110,7 @@ ColorTable::ColorTable(const std::string& name,
 }
 
 //----------------------------------------------------------------------------
-ColorTable::~ColorTable()
-{
-}
+ColorTable::~ColorTable() {}
 
 //----------------------------------------------------------------------------
 const std::string& ColorTable::GetName() const

vtkm/cont/DataSetBuilderExplicit.cxx

@@ -16,9 +16,7 @@ namespace cont
 {
 
 VTKM_CONT
-DataSetBuilderExplicitIterative::DataSetBuilderExplicitIterative()
-{
-}
+DataSetBuilderExplicitIterative::DataSetBuilderExplicitIterative() {}
 
 
 VTKM_CONT

vtkm/cont/DataSetBuilderRectilinear.cxx

@@ -16,8 +16,6 @@ namespace cont
 {
 
 VTKM_CONT
-DataSetBuilderRectilinear::DataSetBuilderRectilinear()
-{
-}
+DataSetBuilderRectilinear::DataSetBuilderRectilinear() {}
 }
 } // end namespace vtkm::cont

vtkm/cont/DataSetBuilderUniform.cxx

@@ -16,9 +16,7 @@ namespace cont
 {
 
 VTKM_CONT
-DataSetBuilderUniform::DataSetBuilderUniform()
-{
-}
+DataSetBuilderUniform::DataSetBuilderUniform() {}
 
 VTKM_CONT
 vtkm::cont::DataSet DataSetBuilderUniform::Create(const vtkm::Id& dimension,

vtkm/cont/ErrorBadDevice.cxx

@@ -21,8 +21,8 @@ namespace cont
 void throwFailedRuntimeDeviceTransfer(const std::string& className,
                                       vtkm::cont::DeviceAdapterId deviceId)
 { //Should we support typeid() instead of className?
-  const std::string msg = "VTK-m was unable to transfer " + className + " to DeviceAdapter[id=" +
-    std::to_string(deviceId.GetValue()) + ", name=" + deviceId.GetName() +
+  const std::string msg = "VTK-m was unable to transfer " + className +
+    " to DeviceAdapter[id=" + std::to_string(deviceId.GetValue()) + ", name=" + deviceId.GetName() +
     "]. This is generally caused by asking for execution on a DeviceAdapter that "
     "isn't compiled into VTK-m. In the case of CUDA it can also be caused by accidentally "
     "compiling source files as C++ files instead of CUDA.";

vtkm/cont/Field.cxx

@@ -37,11 +37,12 @@ Field::Field(const vtkm::cont::Field& src)
 }
 
 VTKM_CONT
-Field::Field(vtkm::cont::Field&& src) noexcept : Name(std::move(src.Name)),
-                                                 FieldAssociation(std::move(src.FieldAssociation)),
-                                                 Data(std::move(src.Data)),
-                                                 Range(std::move(src.Range)),
-                                                 ModifiedFlag(std::move(src.ModifiedFlag))
+Field::Field(vtkm::cont::Field&& src) noexcept
+  : Name(std::move(src.Name))
+  , FieldAssociation(std::move(src.FieldAssociation))
+  , Data(std::move(src.Data))
+  , Range(std::move(src.Range))
+  , ModifiedFlag(std::move(src.ModifiedFlag))
 {
 }
 
@@ -92,9 +93,7 @@ void Field::PrintSummary(std::ostream& out) const
 }
 
 VTKM_CONT
-Field::~Field()
-{
-}
+Field::~Field() {}
 
 
 VTKM_CONT

vtkm/cont/FieldRangeGlobalCompute.cxx

@@ -60,7 +60,8 @@ vtkm::cont::ArrayHandle<vtkm::Range> MergeRangesGlobal(
 
   using VectorOfRangesT = std::vector<vtkm::Range>;
 
-  vtkmdiy::Master master(comm,
+  vtkmdiy::Master master(
+    comm,
     1,
     -1,
     []() -> void* { return new VectorOfRangesT(); },
@@ -76,8 +77,9 @@ vtkm::cont::ArrayHandle<vtkm::Range> MergeRangesGlobal(
 
   vtkmdiy::RegularAllReducePartners all_reduce_partners(decomposer, /*k*/ 2);
 
-  auto callback = [](
-    VectorOfRangesT* data, const vtkmdiy::ReduceProxy& srp, const vtkmdiy::RegularMergePartners&) {
+  auto callback = [](VectorOfRangesT* data,
+                     const vtkmdiy::ReduceProxy& srp,
+                     const vtkmdiy::RegularMergePartners&) {
     const auto selfid = srp.gid();
     // 1. dequeue.
     std::vector<int> incoming;

vtkm/cont/Initialize.cxx

@@ -46,9 +46,7 @@ struct VtkmArg : public opt::Arg
         VTKM_LOG_ALWAYS_S(vtkm::cont::LogLevel::Error,
                           "Missing device after option '"
                             << std::string(option.name, static_cast<size_t>(option.namelen))
-                            << "'.\nValid devices are: "
-                            << VtkmArg::GetValidDeviceNames()
-                            << "\n");
+                            << "'.\nValid devices are: " << VtkmArg::GetValidDeviceNames() << "\n");
       }
       return opt::ARG_ILLEGAL;
     }
@@ -59,12 +57,9 @@ struct VtkmArg : public opt::Arg
     {
       VTKM_LOG_ALWAYS_S(vtkm::cont::LogLevel::Error,
                         "Unavailable device specificed after option '"
-                          << std::string(option.name, static_cast<size_t>(option.namelen))
-                          << "': '"
+                          << std::string(option.name, static_cast<size_t>(option.namelen)) << "': '"
                           << option.arg
-                          << "'.\nValid devices are: "
-                          << VtkmArg::GetValidDeviceNames()
-                          << "\n");
+                          << "'.\nValid devices are: " << VtkmArg::GetValidDeviceNames() << "\n");
       return opt::ARG_ILLEGAL;
     }
 

vtkm/cont/Logging.h

@@ -256,7 +256,8 @@
   static constexpr vtkm::cont::LogLevel name = static_cast<vtkm::cont::LogLevel>( \
     static_cast<typename std::underlying_type<vtkm::cont::LogLevel>::type>(       \
       vtkm::cont::LogLevel::UserFirst) +                                          \
-    offset % static_cast<typename std::underlying_type<vtkm::cont::LogLevel>::type>(               \
+    offset %                                                                      \
+      static_cast<typename std::underlying_type<vtkm::cont::LogLevel>::type>(     \
         vtkm::cont::LogLevel::UserLast))
 
 #else // VTKM_ENABLE_LOGGING
@@ -275,8 +276,8 @@
 // Always emitted. When logging is disabled, std::cerr is used.
 
 #define VTKM_LOG_ALWAYS_S(level, ...)                   \
-  (static_cast<int>(level) < 0 ? std::cerr : std::cout) << vtkm::cont::GetLogLevelName(level)      \
-                                                        << ": " << __VA_ARGS__ << "\n"
+  (static_cast<int>(level) < 0 ? std::cerr : std::cout) \
+    << vtkm::cont::GetLogLevelName(level) << ": " << __VA_ARGS__ << "\n"
 
 // TryExecute failures are still important enough to log, but we just write to
 // std::cerr when logging is disabled.

vtkm/cont/PartitionedDataSet.cxx

@@ -48,14 +48,10 @@ PartitionedDataSet::PartitionedDataSet(vtkm::Id size)
 }
 
 VTKM_CONT
-PartitionedDataSet::PartitionedDataSet()
-{
-}
+PartitionedDataSet::PartitionedDataSet() {}
 
 VTKM_CONT
-PartitionedDataSet::~PartitionedDataSet()
-{
-}
+PartitionedDataSet::~PartitionedDataSet() {}
 
 VTKM_CONT
 PartitionedDataSet& PartitionedDataSet::operator=(const vtkm::cont::PartitionedDataSet& src)

vtkm/cont/RuntimeDeviceTracker.cxx

@@ -44,9 +44,7 @@ RuntimeDeviceTracker::RuntimeDeviceTracker(detail::RuntimeDeviceTrackerInternals
 }
 
 VTKM_CONT
-RuntimeDeviceTracker::~RuntimeDeviceTracker()
-{
-}
+RuntimeDeviceTracker::~RuntimeDeviceTracker() {}
 
 VTKM_CONT
 void RuntimeDeviceTracker::CheckDevice(vtkm::cont::DeviceAdapterId deviceId) const

vtkm/cont/StorageVirtual.cxx

@@ -31,8 +31,8 @@ StorageVirtual::StorageVirtual(const StorageVirtual& src)
 
 //--------------------------------------------------------------------
 StorageVirtual::StorageVirtual(StorageVirtual&& src) noexcept
-  : DeviceUpToDate(src.DeviceUpToDate),
-    DeviceTransferState(std::move(src.DeviceTransferState))
+  : DeviceUpToDate(src.DeviceUpToDate)
+  , DeviceTransferState(std::move(src.DeviceTransferState))
 {
 }
 
@@ -53,9 +53,7 @@ StorageVirtual& StorageVirtual::operator=(StorageVirtual&& src) noexcept
 }
 
 //--------------------------------------------------------------------
-StorageVirtual::~StorageVirtual()
-{
-}
+StorageVirtual::~StorageVirtual() {}
 
 //--------------------------------------------------------------------
 void StorageVirtual::DropExecutionPortal()

vtkm/cont/StorageVirtual.h

@@ -35,8 +35,8 @@ public:
   ArrayPortalRef() = default;
 
   ArrayPortalRef(std::shared_ptr<vtkm::ArrayPortalVirtual<T>> portal, vtkm::Id numValues) noexcept
-    : vtkm::ArrayPortalRef<T>(portal.get(), numValues),
-      ManagedPortal(portal)
+    : vtkm::ArrayPortalRef<T>(portal.get(), numValues)
+    , ManagedPortal(portal)
   {
   }
 };

vtkm/cont/StorageVirtual.hxx

@@ -101,8 +101,8 @@ StorageVirtualImpl<T, S>::StorageVirtualImpl(const vtkm::cont::ArrayHandle<T, S>
 VTKM_CONT
 template <typename T, typename S>
 StorageVirtualImpl<T, S>::StorageVirtualImpl(vtkm::cont::ArrayHandle<T, S>&& ah) noexcept
-  : vtkm::cont::internal::detail::StorageVirtual(),
-    Handle(std::move(ah))
+  : vtkm::cont::internal::detail::StorageVirtual()
+  , Handle(std::move(ah))
 {
 }
 

vtkm/cont/Timer.cxx

@@ -242,7 +242,8 @@ Timer::Timer(vtkm::cont::DeviceAdapterId device)
   if (!tracker.CanRunOn(device))
   {
     VTKM_LOG_S(vtkm::cont::LogLevel::Error,
-               "Device '" << device.GetName() << "' can not run on current Device."
+               "Device '" << device.GetName()
+                          << "' can not run on current Device."
                              "Thus timer is not usable");
   }
 }
@@ -262,7 +263,8 @@ void Timer::Reset(vtkm::cont::DeviceAdapterId device)
   if (!tracker.CanRunOn(device))
   {
     VTKM_LOG_S(vtkm::cont::LogLevel::Error,
-               "Device '" << device.GetName() << "' can not run on current Device."
+               "Device '" << device.GetName()
+                          << "' can not run on current Device."
                              "Thus timer is not usable");
   }
 

vtkm/cont/Token.cxx

@@ -52,9 +52,7 @@ struct vtkm::cont::Token::HeldReference
   }
 };
 
-vtkm::cont::Token::Token()
-{
-}
+vtkm::cont::Token::Token() {}
 
 vtkm::cont::Token::Token(Token&& rhs)
   : Internals(std::move(rhs.Internals))

vtkm/cont/arg/testing/UnitTestTransportWholeArray.cxx

@@ -108,16 +108,12 @@ struct TryWholeArrayType
   {
     using ArrayHandleType = vtkm::cont::ArrayHandle<T>;
 
-    using InTransportType = vtkm::cont::arg::Transport<vtkm::cont::arg::TransportTagWholeArrayIn,
-                                                       ArrayHandleType,
-                                                       Device>;
-    using InOutTransportType =
-      vtkm::cont::arg::Transport<vtkm::cont::arg::TransportTagWholeArrayInOut,
-                                 ArrayHandleType,
-                                 Device>;
-    using OutTransportType = vtkm::cont::arg::Transport<vtkm::cont::arg::TransportTagWholeArrayOut,
-                                                        ArrayHandleType,
-                                                        Device>;
+    using InTransportType = vtkm::cont::arg::
+      Transport<vtkm::cont::arg::TransportTagWholeArrayIn, ArrayHandleType, Device>;
+    using InOutTransportType = vtkm::cont::arg::
+      Transport<vtkm::cont::arg::TransportTagWholeArrayInOut, ArrayHandleType, Device>;
+    using OutTransportType = vtkm::cont::arg::
+      Transport<vtkm::cont::arg::TransportTagWholeArrayOut, ArrayHandleType, Device>;
 
     ArrayHandleType array;
     array.Allocate(ARRAY_SIZE);

vtkm/cont/cuda/internal/DeviceAdapterAlgorithmCuda.h

@@ -1183,7 +1183,8 @@ public:
     const vtkm::Id inSize = input.GetNumberOfValues();
 
     // Check if the ranges overlap and fail if they do.
-    if (input == output && ((outputIndex >= inputStartIndex &&
+    if (input == output &&
+        ((outputIndex >= inputStartIndex &&
           outputIndex < inputStartIndex + numberOfElementsToCopy) ||
          (inputStartIndex >= outputIndex &&
           inputStartIndex < outputIndex + numberOfElementsToCopy)))

vtkm/cont/internal/Buffer.cxx

@@ -536,9 +536,7 @@ Buffer::Buffer(Buffer&& src)
 }
 
 // Defined to prevent issues with CUDA
-Buffer::~Buffer()
-{
-}
+Buffer::~Buffer() {}
 
 // Defined to prevent issues with CUDA
 Buffer& Buffer::operator=(const Buffer& src)

vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h

@@ -241,7 +241,8 @@ public:
     const vtkm::Id inSize = input.GetNumberOfValues();
 
     // Check if the ranges overlap and fail if they do.
-    if (input == output && ((outputIndex >= inputStartIndex &&
+    if (input == output &&
+        ((outputIndex >= inputStartIndex &&
           outputIndex < inputStartIndex + numberOfElementsToCopy) ||
          (inputStartIndex >= outputIndex &&
           inputStartIndex < outputIndex + numberOfElementsToCopy)))

vtkm/cont/internal/DeviceAdapterMemoryManager.cxx

@@ -321,9 +321,7 @@ vtkm::cont::internal::BufferInfo AllocateOnHost(vtkm::BufferSizeType size)
 }
 
 //----------------------------------------------------------------------------------------
-DeviceAdapterMemoryManagerBase::~DeviceAdapterMemoryManagerBase()
-{
-}
+DeviceAdapterMemoryManagerBase::~DeviceAdapterMemoryManagerBase() {}
 
 void DeviceAdapterMemoryManagerBase::Reallocate(vtkm::cont::internal::BufferInfo& buffer,
                                                 vtkm::BufferSizeType newSize) const

vtkm/cont/internal/FunctorsGeneral.h

@@ -1179,8 +1179,8 @@ struct InclusiveToExtendedKernel : vtkm::exec::FunctorBase
   {
     // The output array has one more value than the input, which holds the
     // total sum.
-    const ValueType result =
-      (index == 0) ? this->InitialValue : (index == this->InPortal.GetNumberOfValues())
+    const ValueType result = (index == 0) ? this->InitialValue
+                                          : (index == this->InPortal.GetNumberOfValues())
         ? this->FinalValue
         : this->BinaryOperator(this->InitialValue, this->InPortal.Get(index - 1));
 

vtkm/cont/internal/ParallelRadixSort.h

@@ -752,6 +752,7 @@ public:
   void Next() { std::swap(src_, dst_); }
 
   ValueType* GetResult() { return src_; }
+
 private:
   size_t max_elems_;
   int max_threads_;

vtkm/cont/internal/ParallelRadixSortInterface.h

@@ -89,9 +89,8 @@ struct sort_tag_type<T, vtkm::cont::StorageTagBasic, BinaryCompare>
   using PrimT = std::is_arithmetic<T>;
   using LongDT = std::is_same<T, long double>;
   using BComp = is_valid_compare_type<BinaryCompare>;
-  using type = typename std::conditional<PrimT::value && BComp::value && !LongDT::value,
-                                         RadixSortTag,
-                                         PSortTag>::type;
+  using type = typename std::
+    conditional<PrimT::value && BComp::value && !LongDT::value, RadixSortTag, PSortTag>::type;
 };
 
 template <typename KeyType,

vtkm/cont/internal/VariantArrayHandleContainer.cxx

@@ -31,9 +31,7 @@ VariantArrayHandleContainerBase::VariantArrayHandleContainerBase(const std::type
 {
 }
 
-VariantArrayHandleContainerBase::~VariantArrayHandleContainerBase()
-{
-}
+VariantArrayHandleContainerBase::~VariantArrayHandleContainerBase() {}
 }
 
 namespace detail

vtkm/cont/internal/VariantArrayHandleContainer.h

@@ -274,7 +274,8 @@ private:
   { // number of components do not match
     std::ostringstream str;
     str << "VariantArrayHandle::AsVirtual: Cannot cast from " << vtkm::cont::TypeToString<S>()
-        << " to " << vtkm::cont::TypeToString<D>() << "; "
+        << " to " << vtkm::cont::TypeToString<D>()
+        << "; "
            "number of components must match exactly.";
     throw vtkm::cont::ErrorBadType(str.str());
   }

vtkm/cont/kokkos/internal/DeviceAdapterAlgorithmKokkos.h

@@ -175,7 +175,8 @@ public:
 
     Kokkos::MDRangePolicy<Kokkos::Rank<3>, Kokkos::IndexType<vtkm::Id>> policy(
       { 0, 0, 0 }, { rangeMax[0], rangeMax[1], rangeMax[2] });
-    Kokkos::parallel_for(policy, KOKKOS_LAMBDA(vtkm::Id i, vtkm::Id j, vtkm::Id k) {
+    Kokkos::parallel_for(
+      policy, KOKKOS_LAMBDA(vtkm::Id i, vtkm::Id j, vtkm::Id k) {
         auto flatIdx = i + (j * rangeMax[0]) + (k * rangeMax[0] * rangeMax[1]);
         functor(vtkm::Id3(i, j, k), flatIdx);
       });

vtkm/cont/kokkos/internal/DeviceAdapterTagKokkos.h

@@ -15,7 +15,8 @@
 //We always create the kokkos tag when included, but we only mark it as
 //a valid tag when VTKM_ENABLE_KOKKOS is true. This is for easier development
 //of multi-backend systems
-#if defined(VTKM_ENABLE_KOKKOS) && ((!defined(VTKM_KOKKOS_CUDA) || defined(VTKM_CUDA)) ||          \
+#if defined(VTKM_ENABLE_KOKKOS) &&                       \
+  ((!defined(VTKM_KOKKOS_CUDA) || defined(VTKM_CUDA)) || \
    !defined(VTKM_NO_ERROR_ON_MIXED_CUDA_CXX_TAG))
 VTKM_VALID_DEVICE_ADAPTER(Kokkos, VTKM_DEVICE_ADAPTER_KOKKOS);
 #else

vtkm/cont/kokkos/internal/VirtualObjectTransferKokkos.h

@@ -54,7 +54,8 @@ struct VirtualObjectTransfer<VirtualDerivedType, vtkm::cont::DeviceAdapterTagKok
         auto executionObjectPtr = this->ExecutionObject =
           static_cast<VirtualDerivedType*>(Kokkos::kokkos_malloc(sizeof(VirtualDerivedType)));
         // Initialize the device object
-        Kokkos::parallel_for("ConstructVirtualObject", 1, KOKKOS_LAMBDA(const int&) {
+        Kokkos::parallel_for(
+          "ConstructVirtualObject", 1, KOKKOS_LAMBDA(const int&) {
             new (executionObjectPtr) VirtualDerivedType(*deviceTarget);
           });
       }
@@ -62,7 +63,8 @@ struct VirtualObjectTransfer<VirtualDerivedType, vtkm::cont::DeviceAdapterTagKok
       {
         auto executionObjectPtr = this->ExecutionObject;
         // Initialize the device object
-        Kokkos::parallel_for("UpdateVirtualObject", 1, KOKKOS_LAMBDA(const int&) {
+        Kokkos::parallel_for(
+          "UpdateVirtualObject", 1, KOKKOS_LAMBDA(const int&) {
             *executionObjectPtr = *deviceTarget;
           });
       }

vtkm/cont/serial/internal/DeviceAdapterAlgorithmSerial.h

@@ -154,7 +154,8 @@ public:
     const vtkm::Id inSize = input.GetNumberOfValues();
 
     // Check if the ranges overlap and fail if they do.
-    if (input == output && ((outputIndex >= inputStartIndex &&
+    if (input == output &&
+        ((outputIndex >= inputStartIndex &&
           outputIndex < inputStartIndex + numberOfElementsToCopy) ||
          (inputStartIndex >= outputIndex &&
           inputStartIndex < outputIndex + numberOfElementsToCopy)))

vtkm/cont/tbb/internal/DeviceAdapterAlgorithmTBB.h

@@ -96,7 +96,8 @@ public:
     const vtkm::Id inSize = input.GetNumberOfValues();
 
     // Check if the ranges overlap and fail if they do.
-    if (input == output && ((outputIndex >= inputStartIndex &&
+    if (input == output &&
+        ((outputIndex >= inputStartIndex &&
           outputIndex < inputStartIndex + numberOfElementsToCopy) ||
          (inputStartIndex >= outputIndex &&
           inputStartIndex < outputIndex + numberOfElementsToCopy)))

vtkm/cont/testing/UnitTestDeviceAdapterAlgorithmGeneral.cxx

@@ -82,9 +82,8 @@ class DeviceAdapterMemoryManager<vtkm::cont::DeviceAdapterTagTestAlgorithmGenera
 
 template <typename T, class StorageTag>
 class ArrayManagerExecution<T, StorageTag, vtkm::cont::DeviceAdapterTagTestAlgorithmGeneral>
-  : public vtkm::cont::internal::ArrayManagerExecution<T,
-                                                       StorageTag,
-                                                       vtkm::cont::DeviceAdapterTagSerial>
+  : public vtkm::cont::internal::
+      ArrayManagerExecution<T, StorageTag, vtkm::cont::DeviceAdapterTagSerial>
 {
 public:
   using Superclass =

vtkm/cont/testing/UnitTestFieldRangeGlobalCompute.cxx

@@ -90,8 +90,7 @@ void Validate(const vtkm::cont::ArrayHandle<vtkm::Range>& ranges,
   auto portal = ranges.ReadPortal();
   auto range = portal.Get(0);
   PRINT_INFO(<< "  expecting [" << min << ", " << max << "], got [" << range.Min << ", "
-             << range.Max
-             << "]");
+             << range.Max << "]");
   VTKM_TEST_ASSERT(range.IsNonEmpty() && range.Min >= static_cast<ValueType>(min) &&
                      range.Max <= static_cast<ValueType>(max),
                    "Got wrong range.");
@@ -110,10 +109,7 @@ void Validate(const vtkm::cont::ArrayHandle<vtkm::Range>& ranges,
   {
     auto range = portal.Get(cc);
     PRINT_INFO(<< "  [" << cc << "] expecting [" << min[cc] << ", " << max[cc] << "], got ["
-               << range.Min
-               << ", "
-               << range.Max
-               << "]");
+               << range.Min << ", " << range.Max << "]");
     VTKM_TEST_ASSERT(range.IsNonEmpty() && range.Min >= static_cast<T>(min[cc]) &&
                        range.Max <= static_cast<T>(max[cc]),
                      "Got wrong range.");

vtkm/exec/CellLocatorBoundingIntervalHierarchyExec.h

@@ -275,9 +275,8 @@ private:
   using NodePortal = typename NodeArrayHandle::template ExecutionTypes<DeviceAdapter>::PortalConst;
   using CellIdPortal =
     typename CellIdArrayHandle::template ExecutionTypes<DeviceAdapter>::PortalConst;
-  using CellSetPortal = typename CellSetType::template ExecutionTypes<DeviceAdapter,
-                                                                      VisitType,
-                                                                      IncidentType>::ExecObjectType;
+  using CellSetPortal = typename CellSetType::
+    template ExecutionTypes<DeviceAdapter, VisitType, IncidentType>::ExecObjectType;
   using CoordsPortal =
     typename vtkm::cont::CoordinateSystem::MultiplexerArrayType::template ExecutionTypes<
       DeviceAdapter>::PortalConst;

vtkm/exec/CellMeasure.h

@@ -95,7 +95,10 @@ VTKM_EXEC OutType CellMeasure(const vtkm::IdComponent& numPts,
   }
 
   typename PointCoordVecType::ComponentType edges[4] = {
-    pts[1] - pts[0], pts[2] - pts[1], pts[3] - pts[2], pts[0] - pts[3],
+    pts[1] - pts[0],
+    pts[2] - pts[1],
+    pts[3] - pts[2],
+    pts[0] - pts[3],
   };
 
   typename PointCoordVecType::ComponentType cornerNormals[4] = {
@@ -107,7 +110,8 @@ VTKM_EXEC OutType CellMeasure(const vtkm::IdComponent& numPts,
 
   // principal axes
   typename PointCoordVecType::ComponentType principalAxes[2] = {
-    edges[0] - edges[2], edges[1] - edges[3],
+    edges[0] - edges[2],
+    edges[1] - edges[3],
   };
 
   // Unit normal at the quadrilateral center

vtkm/exec/arg/ThreadIndicesTopologyMap.h

@@ -478,9 +478,8 @@ class ThreadIndicesTopologyMap<vtkm::exec::ConnectivityPermutedVisitCellsWithPoi
     vtkm::exec::ConnectivityStructured<vtkm::TopologyElementTagCell,
                                        vtkm::TopologyElementTagPoint,
                                        Dimension>>;
-  using ConnectivityType = vtkm::exec::ConnectivityStructured<vtkm::TopologyElementTagCell,
-                                                              vtkm::TopologyElementTagPoint,
-                                                              Dimension>;
+  using ConnectivityType = vtkm::exec::
+    ConnectivityStructured<vtkm::TopologyElementTagCell, vtkm::TopologyElementTagPoint, Dimension>;
 
 public:
   using IndicesIncidentType = typename ConnectivityType::IndicesType;

vtkm/exec/arg/testing/UnitTestFetchArrayNeighborhoodIn.cxx

@@ -104,9 +104,8 @@ struct FetchArrayNeighborhoodInTests
 
     vtkm::internal::ConnectivityStructuredInternals<3> connectivityInternals;
     connectivityInternals.SetPointDimensions(POINT_DIMS);
-    vtkm::exec::ConnectivityStructured<vtkm::TopologyElementTagPoint,
-                                       vtkm::TopologyElementTagCell,
-                                       3>
+    vtkm::exec::
+      ConnectivityStructured<vtkm::TopologyElementTagPoint, vtkm::TopologyElementTagCell, 3>
         connectivity(connectivityInternals);
 
     // Verify that 3D scheduling works with neighborhoods

vtkm/exec/arg/testing/UnitTestFetchArrayTopologyMapIn.cxx

@@ -126,9 +126,8 @@ struct FetchArrayTopologyMapInTests
 
     vtkm::internal::ConnectivityStructuredInternals<3> connectivityInternals;
     connectivityInternals.SetPointDimensions(vtkm::Id3(2, 2, 2));
-    vtkm::exec::ConnectivityStructured<vtkm::TopologyElementTagCell,
-                                       vtkm::TopologyElementTagPoint,
-                                       3>
+    vtkm::exec::
+      ConnectivityStructured<vtkm::TopologyElementTagCell, vtkm::TopologyElementTagPoint, 3>
         connectivity(connectivityInternals);
 
     using NullType = vtkm::internal::NullType;

vtkm/exec/cuda/internal/testing/UnitTestTaskStrided.cu

@@ -241,25 +241,25 @@ struct TestWorkletErrorProxy : vtkm::exec::FunctorBase
 // Check behavior of InvocationToFetch helper class.
 
 VTKM_STATIC_ASSERT(
-  (std::is_same<vtkm::exec::internal::detail::
+  (std::is_same<
+    vtkm::exec::internal::detail::
       InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic, InvocationType1, 1>::type,
-                vtkm::exec::arg::Fetch<TestFetchTagInput,
-                                       vtkm::exec::arg::AspectTagDefault,
-                                       TestExecObject>>::type::value));
+    vtkm::exec::arg::Fetch<TestFetchTagInput, vtkm::exec::arg::AspectTagDefault, TestExecObject>>::
+     type::value));
 
 VTKM_STATIC_ASSERT(
-  (std::is_same<vtkm::exec::internal::detail::
+  (std::is_same<
+    vtkm::exec::internal::detail::
       InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic, InvocationType1, 2>::type,
-                vtkm::exec::arg::Fetch<TestFetchTagOutput,
-                                       vtkm::exec::arg::AspectTagDefault,
-                                       TestExecObject>>::type::value));
+    vtkm::exec::arg::Fetch<TestFetchTagOutput, vtkm::exec::arg::AspectTagDefault, TestExecObject>>::
+     type::value));
 
 VTKM_STATIC_ASSERT(
-  (std::is_same<vtkm::exec::internal::detail::
+  (std::is_same<
+    vtkm::exec::internal::detail::
       InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic, InvocationType2, 0>::type,
-                vtkm::exec::arg::Fetch<TestFetchTagOutput,
-                                       vtkm::exec::arg::AspectTagDefault,
-                                       TestExecObject>>::type::value));
+    vtkm::exec::arg::Fetch<TestFetchTagOutput, vtkm::exec::arg::AspectTagDefault, TestExecObject>>::
+     type::value));
 
 template <typename DeviceAdapter>
 void TestNormalFunctorInvoke()

vtkm/exec/internal/testing/UnitTestTaskSingular.cxx

@@ -216,25 +216,25 @@ struct TestWorkletErrorProxy : vtkm::exec::FunctorBase
 // Check behavior of InvocationToFetch helper class.
 
 VTKM_STATIC_ASSERT(
-  (std::is_same<vtkm::exec::internal::detail::
+  (std::is_same<
+    vtkm::exec::internal::detail::
       InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic, InvocationType1, 1>::type,
-                vtkm::exec::arg::Fetch<TestFetchTagInput,
-                                       vtkm::exec::arg::AspectTagDefault,
-                                       TestExecObject>>::type::value));
+    vtkm::exec::arg::Fetch<TestFetchTagInput, vtkm::exec::arg::AspectTagDefault, TestExecObject>>::
+     type::value));
 
 VTKM_STATIC_ASSERT(
-  (std::is_same<vtkm::exec::internal::detail::
+  (std::is_same<
+    vtkm::exec::internal::detail::
       InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic, InvocationType1, 2>::type,
-                vtkm::exec::arg::Fetch<TestFetchTagOutput,
-                                       vtkm::exec::arg::AspectTagDefault,
-                                       TestExecObject>>::type::value));
+    vtkm::exec::arg::Fetch<TestFetchTagOutput, vtkm::exec::arg::AspectTagDefault, TestExecObject>>::
+     type::value));
 
 VTKM_STATIC_ASSERT(
-  (std::is_same<vtkm::exec::internal::detail::
+  (std::is_same<
+    vtkm::exec::internal::detail::
       InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic, InvocationType2, 0>::type,
-                vtkm::exec::arg::Fetch<TestFetchTagOutput,
-                                       vtkm::exec::arg::AspectTagDefault,
-                                       TestExecObject>>::type::value));
+    vtkm::exec::arg::Fetch<TestFetchTagOutput, vtkm::exec::arg::AspectTagDefault, TestExecObject>>::
+     type::value));
 
 void TestNormalFunctorInvoke()
 {

vtkm/filter/ContourTreeUniformAugmented.hxx

@@ -224,13 +224,8 @@ vtkm::cont::DataSet ContourTreeAugmented::DoExecute(
 
   VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
              std::endl
-               << "    "
-               << std::setw(38)
-               << std::left
-               << "Contour Tree Filter DoExecute"
-               << ": "
-               << timer.GetElapsedTime()
-               << " seconds");
+               << "    " << std::setw(38) << std::left << "Contour Tree Filter DoExecute"
+               << ": " << timer.GetElapsedTime() << " seconds");
 
   // Construct the expected result for serial execution. Note, in serial the result currently
   // not actually being used, but in parallel we need the sorted mesh values as output
@@ -508,13 +503,8 @@ inline VTKM_CONT void ContourTreeAugmented::PostExecute(
     this->MultiBlockTreeHelper.reset();
     VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
                std::endl
-                 << "    "
-                 << std::setw(38)
-                 << std::left
-                 << "Contour Tree Filter PostExecute"
-                 << ": "
-                 << timer.GetElapsedTime()
-                 << " seconds");
+                 << "    " << std::setw(38) << std::left << "Contour Tree Filter PostExecute"
+                 << ": " << timer.GetElapsedTime() << " seconds");
   }
 }
 

vtkm/filter/ContourTreeUniformDistributed.hxx

@@ -198,13 +198,8 @@ vtkm::cont::DataSet ContourTreeUniformDistributed::DoExecute(
 
   VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
              std::endl
-               << "    "
-               << std::setw(38)
-               << std::left
-               << "Contour Tree Filter DoExecute"
-               << ": "
-               << timer.GetElapsedTime()
-               << " seconds");
+               << "    " << std::setw(38) << std::left << "Contour Tree Filter DoExecute"
+               << ": " << timer.GetElapsedTime() << " seconds");
 
   // Construct the expected result for serial execution. Note, in serial the result currently
   // not actually being used, but in parallel we need the sorted mesh values as output
@@ -474,13 +469,8 @@ inline VTKM_CONT void ContourTreeUniformDistributed::PostExecute(
     this->MultiBlockTreeHelper.reset();
     VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
                std::endl
-                 << "    "
-                 << std::setw(38)
-                 << std::left
-                 << "Contour Tree Filter PostExecute"
-                 << ": "
-                 << timer.GetElapsedTime()
-                 << " seconds");
+                 << "    " << std::setw(38) << std::left << "Contour Tree Filter PostExecute"
+                 << ": " << timer.GetElapsedTime() << " seconds");
   }
 }
 

vtkm/filter/GhostCellClassify.hxx

@@ -96,9 +96,7 @@ namespace vtkm
 namespace filter
 {
 
-inline VTKM_CONT GhostCellClassify::GhostCellClassify()
-{
-}
+inline VTKM_CONT GhostCellClassify::GhostCellClassify() {}
 
 template <typename Policy>
 inline VTKM_CONT vtkm::cont::DataSet GhostCellClassify::DoExecute(const vtkm::cont::DataSet& input,

vtkm/filter/NDEntropy.hxx

@@ -18,9 +18,7 @@ namespace vtkm
 namespace filter
 {
 
-inline VTKM_CONT NDEntropy::NDEntropy()
-{
-}
+inline VTKM_CONT NDEntropy::NDEntropy() {}
 
 void NDEntropy::AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins)
 {

vtkm/filter/NDHistogram.hxx

@@ -19,9 +19,7 @@ namespace vtkm
 namespace filter
 {
 
-inline VTKM_CONT NDHistogram::NDHistogram()
-{
-}
+inline VTKM_CONT NDHistogram::NDHistogram() {}
 
 void NDHistogram::AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins)
 {

vtkm/filter/particleadvection/ParticleMessenger.h

@@ -67,13 +67,15 @@ protected:
   // Send/Recv Integral curves.
   VTKM_CONT
   template <typename P,
-            template <typename, typename> class Container,
+            template <typename, typename>
+            class Container,
             typename Allocator = std::allocator<P>>
   inline void SendParticles(int dst, const Container<P, Allocator>& c);
 
   VTKM_CONT
   template <typename P,
-            template <typename, typename> class Container,
+            template <typename, typename>
+            class Container,
             typename Allocator = std::allocator<P>>
   inline void SendParticles(const std::map<int, Container<P, Allocator>>& m);
 

vtkm/filter/testing/UnitTestCellMeasuresFilter.cxx

@@ -65,8 +65,8 @@ void TestCellMeasuresFilter(vtkm::cont::DataSet& dataset,
 
 void TestCellMeasures()
 {
-  using vtkm::Volume;
   using vtkm::AllMeasures;
+  using vtkm::Volume;
 
   vtkm::cont::testing::MakeTestDataSet factory;
   vtkm::cont::DataSet data;

vtkm/internal/ArrayPortalVirtual.h

@@ -59,7 +59,11 @@ class VTKM_ALWAYS_EXPORT ArrayPortalWrapper final
   using T = typename PortalT::ValueType;
 
 public:
-  ArrayPortalWrapper(const PortalT& p) noexcept : ArrayPortalVirtual<T>(), Portal(p) {}
+  ArrayPortalWrapper(const PortalT& p) noexcept
+    : ArrayPortalVirtual<T>()
+    , Portal(p)
+  {
+  }
 
   VTKM_SUPPRESS_EXEC_WARNINGS
   VTKM_EXEC_CONT
@@ -101,12 +105,16 @@ public:
   using ValueType = T;
 
   VTKM_EXEC_CONT
-  ArrayPortalRef() noexcept : Portal(nullptr), NumberOfValues(0) {}
+  ArrayPortalRef() noexcept
+    : Portal(nullptr)
+    , NumberOfValues(0)
+  {
+  }
 
   VTKM_EXEC_CONT
   ArrayPortalRef(const ArrayPortalVirtual<T>* portal, vtkm::Id numValues) noexcept
-    : Portal(portal),
-      NumberOfValues(numValues)
+    : Portal(portal)
+    , NumberOfValues(numValues)
   {
   }
 

vtkm/internal/Variant.h

@@ -83,23 +83,20 @@ struct AllTriviallyCopyable<T0, T1, T2>
 
 template <typename T0, typename T1, typename T2, typename T3>
 struct AllTriviallyCopyable<T0, T1, T2, T3>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_copyable<T0>::value &&
-                            vtkmstd::is_trivially_copyable<T1>::value &&
-                            vtkmstd::is_trivially_copyable<T2>::value &&
-                            vtkmstd::is_trivially_copyable<T3>::value)>
+  : std::integral_constant<
+      bool,
+      (vtkmstd::is_trivially_copyable<T0>::value && vtkmstd::is_trivially_copyable<T1>::value &&
+       vtkmstd::is_trivially_copyable<T2>::value && vtkmstd::is_trivially_copyable<T3>::value)>
 {
 };
 
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename... Ts>
 struct AllTriviallyCopyable<T0, T1, T2, T3, T4, Ts...>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_copyable<T0>::value &&
-                            vtkmstd::is_trivially_copyable<T1>::value &&
-                            vtkmstd::is_trivially_copyable<T2>::value &&
-                            vtkmstd::is_trivially_copyable<T3>::value &&
-                            vtkmstd::is_trivially_copyable<T4>::value &&
-                            AllTriviallyCopyable<Ts...>::value)>
+  : std::integral_constant<
+      bool,
+      (vtkmstd::is_trivially_copyable<T0>::value && vtkmstd::is_trivially_copyable<T1>::value &&
+       vtkmstd::is_trivially_copyable<T2>::value && vtkmstd::is_trivially_copyable<T3>::value &&
+       vtkmstd::is_trivially_copyable<T4>::value && AllTriviallyCopyable<Ts...>::value)>
 {
 };
 

vtkm/internal/testing/UnitTestVariant.cxx

@@ -410,9 +410,9 @@ void TestEmplace()
 
   variant.Emplace<1>(TestValue(2, vtkm::Id{}), TestValue(3, vtkm::Id{}), TestValue(4, vtkm::Id{}));
   VTKM_TEST_ASSERT(variant.GetIndex() == 1);
-  VTKM_TEST_ASSERT(variant.Get<vtkm::Id3>() == vtkm::Id3{ TestValue(2, vtkm::Id{}),
-                                                          TestValue(3, vtkm::Id{}),
-                                                          TestValue(4, vtkm::Id{}) });
+  VTKM_TEST_ASSERT(
+    variant.Get<vtkm::Id3>() ==
+    vtkm::Id3{ TestValue(2, vtkm::Id{}), TestValue(3, vtkm::Id{}), TestValue(4, vtkm::Id{}) });
 
   variant.Emplace<2>(
     { TestValue(5, vtkm::Id{}), TestValue(6, vtkm::Id{}), TestValue(7, vtkm::Id{}) });

vtkm/io/ImageReaderBase.cxx

@@ -27,9 +27,7 @@ ImageReaderBase::ImageReaderBase(const std::string& filename)
 {
 }
 
-ImageReaderBase::~ImageReaderBase() noexcept
-{
-}
+ImageReaderBase::~ImageReaderBase() noexcept {}
 
 const vtkm::cont::DataSet& ImageReaderBase::ReadDataSet()
 {

vtkm/io/ImageReaderPNG.cxx

@@ -60,9 +60,7 @@ namespace vtkm
 namespace io
 {
 
-ImageReaderPNG::~ImageReaderPNG() noexcept
-{
-}
+ImageReaderPNG::~ImageReaderPNG() noexcept {}
 
 void ImageReaderPNG::Read()
 {

vtkm/io/ImageReaderPNM.cxx

@@ -21,9 +21,7 @@ namespace vtkm
 namespace io
 {
 
-ImageReaderPNM::~ImageReaderPNM() noexcept
-{
-}
+ImageReaderPNM::~ImageReaderPNM() noexcept {}
 
 VTKM_CONT
 void ImageReaderPNM::Read()

vtkm/io/ImageWriterBase.cxx

@@ -27,9 +27,7 @@ ImageWriterBase::ImageWriterBase(const std::string& filename)
 {
 }
 
-ImageWriterBase::~ImageWriterBase() noexcept
-{
-}
+ImageWriterBase::~ImageWriterBase() noexcept {}
 
 void ImageWriterBase::WriteDataSet(const vtkm::cont::DataSet& dataSet)
 {

vtkm/io/ImageWriterPNG.cxx

@@ -21,9 +21,7 @@ namespace vtkm
 namespace io
 {
 
-ImageWriterPNG::~ImageWriterPNG() noexcept
-{
-}
+ImageWriterPNG::~ImageWriterPNG() noexcept {}
 
 void ImageWriterPNG::Write(vtkm::Id width, vtkm::Id height, const ColorArrayType& pixels)
 {

vtkm/io/ImageWriterPNM.cxx

@@ -17,9 +17,7 @@ namespace vtkm
 namespace io
 {
 
-ImageWriterPNM::~ImageWriterPNM() noexcept
-{
-}
+ImageWriterPNM::~ImageWriterPNM() noexcept {}
 
 void ImageWriterPNM::Write(vtkm::Id width, vtkm::Id height, const ColorArrayType& pixels)
 {

vtkm/io/VTKDataSetReader.cxx

@@ -33,9 +33,7 @@ VTKDataSetReader::VTKDataSetReader(const std::string& fileName)
 {
 }
 
-VTKDataSetReader::~VTKDataSetReader()
-{
-}
+VTKDataSetReader::~VTKDataSetReader() {}
 
 void VTKDataSetReader::PrintSummary(std::ostream& out) const
 {

vtkm/io/VTKDataSetReaderBase.cxx

@@ -132,8 +132,7 @@ vtkm::cont::VariantArrayHandle CreateVariantArrayHandle(const std::vector<T>& ve
         VTKM_LOG_S(vtkm::cont::LogLevel::Info,
                    "Type " << vtkm::io::internal::DataTypeName<T>::Name()
                            << " is currently unsupported. Converting to "
-                           << vtkm::io::internal::DataTypeName<CommonType>::Name()
-                           << ".");
+                           << vtkm::io::internal::DataTypeName<CommonType>::Name() << ".");
       }
 
       vtkm::cont::ArrayHandle<CommonType> output;
@@ -160,13 +159,10 @@ vtkm::cont::VariantArrayHandle CreateVariantArrayHandle(const std::vector<T>& ve
       {
         VTKM_LOG_S(vtkm::cont::LogLevel::Info,
                    "Type " << vtkm::io::internal::DataTypeName<InComponentType>::Name() << "["
-                           << vtkm::VecTraits<T>::GetNumberOfComponents(T())
-                           << "] "
+                           << vtkm::VecTraits<T>::GetNumberOfComponents(T()) << "] "
                            << "is currently unsupported. Converting to "
-                           << vtkm::io::internal::DataTypeName<OutComponentType>::Name()
-                           << "["
-                           << numComps
-                           << "].");
+                           << vtkm::io::internal::DataTypeName<OutComponentType>::Name() << "["
+                           << numComps << "].");
       }
 
       vtkm::cont::ArrayHandle<CommonType> output;
@@ -216,9 +212,7 @@ VTKDataSetReaderBase::VTKDataSetReaderBase(const std::string& fileName)
   this->DataFile->FileName = fileName;
 }
 
-VTKDataSetReaderBase::~VTKDataSetReaderBase()
-{
-}
+VTKDataSetReaderBase::~VTKDataSetReaderBase() {}
 
 const vtkm::cont::DataSet& VTKDataSetReaderBase::ReadDataSet()
 {
@@ -418,10 +412,7 @@ void VTKDataSetReaderBase::ReadHeader()
   {
     VTKM_LOG_S(vtkm::cont::LogLevel::Warn,
                "Reader may not correctly read >v4.2 files. Reading version "
-                 << this->DataFile->Version[0]
-                 << "."
-                 << this->DataFile->Version[1]
-                 << ".\n");
+                 << this->DataFile->Version[0] << "." << this->DataFile->Version[1] << ".\n");
   }
 
   // Read title line

vtkm/io/VTKRectilinearGridReader.cxx

@@ -75,7 +75,8 @@ void VTKRectilinearGridReader::Read()
     vtkm::cont::Field::Association::ANY, fileStorageDataType, numPoints[2], 1);
 
 
-  if (dim != vtkm::Id3(static_cast<vtkm::Id>(numPoints[0]),
+  if (dim !=
+      vtkm::Id3(static_cast<vtkm::Id>(numPoints[0]),
                 static_cast<vtkm::Id>(numPoints[1]),
                 static_cast<vtkm::Id>(numPoints[2])))
     throw vtkm::io::ErrorIO("DIMENSIONS not equal to number of points");

vtkm/io/testing/UnitTestPixelTypes.cxx

@@ -49,9 +49,9 @@ void TestPixelTypeOperations(const vtkm::UInt16& numPixels = 10)
       for (ValType k = numChannels * i; k < numChannels * i + numChannels; k++)
       {
         VTKM_TEST_ASSERT(imageData[k * numBytes + j] == i + j,
-                         "Wrong value at index[" + std::to_string(k * numBytes + j) + "]: " +
-                           std::to_string(imageData[k * numBytes + j]) + " != " +
-                           std::to_string(i + j));
+                         "Wrong value at index[" + std::to_string(k * numBytes + j) +
+                           "]: " + std::to_string(imageData[k * numBytes + j]) +
+                           " != " + std::to_string(i + j));
       }
     }
   }

vtkm/rendering/AxisAnnotation.cxx

@@ -230,12 +230,8 @@ void AxisAnnotation::CalculateTicksLogarithmic(const vtkm::Range& range,
   }
 }
 
-AxisAnnotation::AxisAnnotation()
-{
-}
+AxisAnnotation::AxisAnnotation() {}
 
-AxisAnnotation::~AxisAnnotation()
-{
-}
+AxisAnnotation::~AxisAnnotation() {}
 }
 } // namespace vtkm::rendering

vtkm/rendering/AxisAnnotation2D.cxx

@@ -31,9 +31,7 @@ AxisAnnotation2D::AxisAnnotation2D()
   this->MoreOrLessTickAdjustment = 0;
 }
 
-AxisAnnotation2D::~AxisAnnotation2D()
-{
-}
+AxisAnnotation2D::~AxisAnnotation2D() {}
 
 void AxisAnnotation2D::SetRangeForAutoTicks(const Range& range)
 {

vtkm/rendering/AxisAnnotation3D.cxx

@@ -36,9 +36,7 @@ AxisAnnotation3D::AxisAnnotation3D()
 {
 }
 
-AxisAnnotation3D::~AxisAnnotation3D()
-{
-}
+AxisAnnotation3D::~AxisAnnotation3D() {}
 
 void AxisAnnotation3D::SetTickInvert(bool x, bool y, bool z)
 {

vtkm/rendering/BoundingBoxAnnotation.cxx

@@ -21,9 +21,7 @@ BoundingBoxAnnotation::BoundingBoxAnnotation()
 {
 }
 
-BoundingBoxAnnotation::~BoundingBoxAnnotation()
-{
-}
+BoundingBoxAnnotation::~BoundingBoxAnnotation() {}
 
 void BoundingBoxAnnotation::Render(const vtkm::rendering::Camera&, const WorldAnnotator& annotator)
 {

vtkm/rendering/Canvas.cxx

@@ -234,9 +234,7 @@ Canvas::Canvas(vtkm::Id width, vtkm::Id height)
   this->ResizeBuffers(width, height);
 }
 
-Canvas::~Canvas()
-{
-}
+Canvas::~Canvas() {}
 
 vtkm::rendering::Canvas* Canvas::NewCopy() const
 {

vtkm/rendering/CanvasRayTracer.cxx

@@ -126,9 +126,7 @@ CanvasRayTracer::CanvasRayTracer(vtkm::Id width, vtkm::Id height)
 {
 }
 
-CanvasRayTracer::~CanvasRayTracer()
-{
-}
+CanvasRayTracer::~CanvasRayTracer() {}
 
 void CanvasRayTracer::WriteToCanvas(const vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays,
                                     const vtkm::cont::ArrayHandle<vtkm::Float32>& colors,

vtkm/rendering/ColorBarAnnotation.cxx

@@ -24,9 +24,7 @@ ColorBarAnnotation::ColorBarAnnotation()
 {
 }
 
-ColorBarAnnotation::~ColorBarAnnotation()
-{
-}
+ColorBarAnnotation::~ColorBarAnnotation() {}
 
 void ColorBarAnnotation::SetFieldName(const std::string& fieldName)
 {

vtkm/rendering/ColorLegendAnnotation.cxx

@@ -21,9 +21,7 @@ ColorLegendAnnotation::ColorLegendAnnotation()
   this->LabelColor = vtkm::rendering::Color::white;
 }
 
-ColorLegendAnnotation::~ColorLegendAnnotation()
-{
-}
+ColorLegendAnnotation::~ColorLegendAnnotation() {}
 
 void ColorLegendAnnotation::Clear()
 {

vtkm/rendering/ConnectivityProxy.cxx

@@ -263,9 +263,7 @@ ConnectivityProxy::ConnectivityProxy(const vtkm::cont::DynamicCellSet& cellset,
 }
 
 VTKM_CONT
-ConnectivityProxy::~ConnectivityProxy()
-{
-}
+ConnectivityProxy::~ConnectivityProxy() {}
 
 VTKM_CONT
 void ConnectivityProxy::SetSampleDistance(const vtkm::Float32& distance)

vtkm/rendering/Mapper.cxx

@@ -17,9 +17,7 @@ namespace vtkm
 namespace rendering
 {
 
-Mapper::~Mapper()
-{
-}
+Mapper::~Mapper() {}
 
 void Mapper::SetActiveColorTable(const vtkm::cont::ColorTable& colorTable)
 {

vtkm/rendering/MapperConnectivity.cxx

@@ -30,9 +30,7 @@ MapperConnectivity::MapperConnectivity()
 }
 
 VTKM_CONT
-MapperConnectivity::~MapperConnectivity()
-{
-}
+MapperConnectivity::~MapperConnectivity() {}
 
 VTKM_CONT
 void MapperConnectivity::SetSampleDistance(const vtkm::Float32& distance)

vtkm/rendering/MapperCylinder.cxx

@@ -74,9 +74,7 @@ MapperCylinder::MapperCylinder()
 {
 }
 
-MapperCylinder::~MapperCylinder()
-{
-}
+MapperCylinder::~MapperCylinder() {}
 
 void MapperCylinder::SetCanvas(vtkm::rendering::Canvas* canvas)
 {

vtkm/rendering/MapperPoint.cxx

@@ -55,9 +55,7 @@ MapperPoint::MapperPoint()
 {
 }
 
-MapperPoint::~MapperPoint()
-{
-}
+MapperPoint::~MapperPoint() {}
 
 void MapperPoint::SetCanvas(vtkm::rendering::Canvas* canvas)
 {

vtkm/rendering/MapperQuad.cxx

@@ -47,9 +47,7 @@ MapperQuad::MapperQuad()
 {
 }
 
-MapperQuad::~MapperQuad()
-{
-}
+MapperQuad::~MapperQuad() {}
 
 void MapperQuad::SetCanvas(vtkm::rendering::Canvas* canvas)
 {

vtkm/rendering/MapperRayTracer.cxx

@@ -50,9 +50,7 @@ MapperRayTracer::MapperRayTracer()
 {
 }
 
-MapperRayTracer::~MapperRayTracer()
-{
-}
+MapperRayTracer::~MapperRayTracer() {}
 
 void MapperRayTracer::SetCanvas(vtkm::rendering::Canvas* canvas)
 {

vtkm/rendering/MapperVolume.cxx

@@ -48,9 +48,7 @@ MapperVolume::MapperVolume()
 {
 }
 
-MapperVolume::~MapperVolume()
-{
-}
+MapperVolume::~MapperVolume() {}
 
 void MapperVolume::SetCanvas(vtkm::rendering::Canvas* canvas)
 {

vtkm/rendering/MapperWireframer.cxx

@@ -197,9 +197,7 @@ MapperWireframer::MapperWireframer()
 {
 }
 
-MapperWireframer::~MapperWireframer()
-{
-}
+MapperWireframer::~MapperWireframer() {}
 
 vtkm::rendering::Canvas* MapperWireframer::GetCanvas() const
 {