STYLE: Rigorous style conformance with clang-format 19.1.4

The newer version of clang-format has a more rigorous enforcement of the ITK style. Most changes include placing the return value of a function on it's own line, and moving single line function definitions to the ITK multi-line format (even in macros).
InsightSoftwareConsortium · Dec 5, 2024 · 645a0cd · 645a0cd
1 parent 414d548
commit 645a0cd
Show file tree

Hide file tree

Showing 307 changed files with 1,742 additions and 1,078 deletions.
diff --git a/Examples/IO/XML/itkParticleSwarmOptimizerSAXReader.cxx b/Examples/IO/XML/itkParticleSwarmOptimizerSAXReader.cxx
@@ -282,7 +282,7 @@ ParticleSwarmOptimizerSAXReader::ProcessBoundAttributes(
         }
       }
     } // end if
-  }   // end for
+  } // end for
 }
 
 /** Search for and return a particular attribute from the attribute list. */

diff --git a/Modules/Bridge/VtkGlue/src/QuickView.cxx b/Modules/Bridge/VtkGlue/src/QuickView.cxx
@@ -58,27 +58,27 @@ using FloatImageType = itk::Image<float, 2>;
 using DoubleImageType = itk::Image<double, 2>;
 
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<CharImageType>(CharImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<CharImageType>(CharImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<UnsignedShortImageType>(UnsignedShortImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<UnsignedShortImageType>(UnsignedShortImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<ShortImageType>(ShortImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<ShortImageType>(ShortImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<UnsignedIntImageType>(UnsignedIntImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<UnsignedIntImageType>(UnsignedIntImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<IntImageType>(IntImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<IntImageType>(IntImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<UnsignedLongImageType>(UnsignedLongImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<UnsignedLongImageType>(UnsignedLongImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<LongImageType>(LongImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<LongImageType>(LongImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<FloatImageType>(FloatImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<FloatImageType>(FloatImageType * image, bool FlipVertical, std::string Description);
 template void ITKVtkGlue_EXPORT
-              QuickView::AddImage<DoubleImageType>(DoubleImageType * image, bool FlipVertical, std::string Description);
+QuickView::AddImage<DoubleImageType>(DoubleImageType * image, bool FlipVertical, std::string Description);
 
 template <>
 void ITKVtkGlue_EXPORT
-     QuickView::AddImage<UnsignedCharImageType>(UnsignedCharImageType * image, bool FlipVertical, std::string Description)
+QuickView::AddImage<UnsignedCharImageType>(UnsignedCharImageType * image, bool FlipVertical, std::string Description)
 {
   if (FlipVertical)
   {
@@ -101,7 +101,7 @@ void ITKVtkGlue_EXPORT
 
 template <typename TImage>
 void ITK_TEMPLATE_EXPORT
-     QuickView::AddImage(TImage * image, bool FlipVertical, std::string Description)
+QuickView::AddImage(TImage * image, bool FlipVertical, std::string Description)
 {
   using rescaleFilterType = itk::RescaleIntensityImageFilter<TImage, UnsignedCharImageType>;
 
@@ -116,7 +116,7 @@ void ITK_TEMPLATE_EXPORT
 
 template <>
 void ITKVtkGlue_EXPORT
-     QuickView::AddImage<UnsignedCharRGBImageType>(UnsignedCharRGBImageType * image,
+QuickView::AddImage<UnsignedCharRGBImageType>(UnsignedCharRGBImageType * image,
                                               bool                       FlipVertical,
                                               std::string                Description)
 {
@@ -141,7 +141,7 @@ void ITKVtkGlue_EXPORT
 
 template <>
 void ITKVtkGlue_EXPORT
-     QuickView::AddRGBImage<UnsignedCharRGBImageType>(UnsignedCharRGBImageType * image,
+QuickView::AddRGBImage<UnsignedCharRGBImageType>(UnsignedCharRGBImageType * image,
                                                  bool                       FlipVertical,
                                                  std::string                Description)
 {
@@ -166,7 +166,7 @@ void ITKVtkGlue_EXPORT
 
 template <>
 void ITKVtkGlue_EXPORT
-     QuickView::AddRGBImage<FloatRGBImageType>(FloatRGBImageType * image, bool FlipVertical, std::string Description)
+QuickView::AddRGBImage<FloatRGBImageType>(FloatRGBImageType * image, bool FlipVertical, std::string Description)
 {
   using AdaptorType = itk::RGBToVectorImageAdaptor<FloatRGBImageType>;
   AdaptorType::Pointer adaptor = AdaptorType::New();
@@ -182,7 +182,7 @@ void ITKVtkGlue_EXPORT
 
 template <>
 void ITKVtkGlue_EXPORT
-     QuickView::AddImage<FloatRGBImageType>(FloatRGBImageType * image, bool FlipVertical, std::string Description)
+QuickView::AddImage<FloatRGBImageType>(FloatRGBImageType * image, bool FlipVertical, std::string Description)
 {
   using AdaptorType = itk::RGBToVectorImageAdaptor<FloatRGBImageType>;
   AdaptorType::Pointer adaptor = AdaptorType::New();

diff --git a/Modules/Core/Common/CMake/itkCheckHasGNUAttributeAligned.cxx b/Modules/Core/Common/CMake/itkCheckHasGNUAttributeAligned.cxx
@@ -77,7 +77,7 @@ main()
 
   using AlignedA = A __attribute__((aligned(64)));
 
-  return OnlyTrue<__alignof__(AlignedA) == 64>::Result && OnlyTrue<__alignof__(B) == 64>::Result;
+  return OnlyTrue < __alignof__(AlignedA) == 64 > ::Result && OnlyTrue < __alignof__(B) == 64 > ::Result;
 
 
   return 0;

diff --git a/Modules/Core/Common/include/itkArray.h b/Modules/Core/Common/include/itkArray.h
@@ -229,9 +229,9 @@ operator<<(std::ostream & os, const Array<TValue> & arr)
 
 // declaration of specialization
 template <>
-ITKCommon_EXPORT std::ostream & operator<<<double>(std::ostream & os, const Array<double> & arr);
+ITKCommon_EXPORT std::ostream & operator<< <double>(std::ostream & os, const Array<double> & arr);
 template <>
-ITKCommon_EXPORT std::ostream & operator<<<float>(std::ostream & os, const Array<float> & arr);
+ITKCommon_EXPORT std::ostream & operator<< <float>(std::ostream & os, const Array<float> & arr);
 
 
 template <typename T>

diff --git a/Modules/Core/Common/include/itkAutoPointer.h b/Modules/Core/Common/include/itkAutoPointer.h
@@ -73,7 +73,11 @@ class AutoPointer
   ~AutoPointer() { this->Reset(); }
 
   /** Overload operator ->.  */
-  ObjectType * operator->() const { return m_Pointer; }
+  ObjectType *
+  operator->() const
+  {
+    return m_Pointer;
+  }
 
   /** Clear the AutoPointer. If it had a pointer the object
       is deleted and the pointer is set to null. */

diff --git a/Modules/Core/Common/include/itkBoolean.h b/Modules/Core/Common/include/itkBoolean.h
@@ -47,7 +47,11 @@ class Boolean
   {}
 
   /** Supports implicit conversion to `bool`. */
-  constexpr operator bool() const { return m_Value; }
+  constexpr
+  operator bool() const
+  {
+    return m_Value;
+  }
 
 private:
   bool m_Value = false;

diff --git a/Modules/Core/Common/include/itkCellInterface.h b/Modules/Core/Common/include/itkCellInterface.h
@@ -30,7 +30,10 @@
 // to define the Accept and GetTopologyId virtuals used
 // by the MultiVisitor class
 #define itkCellVisitMacro(TopologyId)                                                                          \
-  static constexpr CellGeometryEnum GetTopologyId() { return TopologyId; }                                     \
+  static constexpr CellGeometryEnum GetTopologyId()                                                            \
+  {                                                                                                            \
+    return TopologyId;                                                                                         \
+  }                                                                                                            \
   virtual void Accept(CellIdentifier cellid, typename CellInterface<PixelType, CellTraits>::MultiVisitor * mv) \
     override                                                                                                   \
   {                                                                                                            \
@@ -386,7 +389,11 @@ class ITK_TEMPLATE_EXPORT CellInterface
    * Array is ordered (xmin, xmax,  ymin, ymax, ....).  A pointer to the
    * array is returned for convenience.  This allows code like:
    * "CoordRep* bounds = cell->GetBoundingBox(new CoordRep[6]);". */
-  CoordinateType * GetBoundingBox(CoordinateType[PointDimension * 2]) { return nullptr; }
+  CoordinateType *
+  GetBoundingBox(CoordinateType[PointDimension * 2])
+  {
+    return nullptr;
+  }
 
   /** Compute the square of the diagonal length of the bounding box. */
   CoordinateType
@@ -407,11 +414,12 @@ class ITK_TEMPLATE_EXPORT CellInterface
    *     (returned through "t" pointer).
    *
    * Returns whether an intersection exists. */
-  virtual bool IntersectBoundingBoxWithLine(CoordinateType[PointDimension * 2],
-                                            CoordinateType[PointDimension],
-                                            CoordinateType[PointDimension],
-                                            CoordinateType[PointDimension],
-                                            CoordinateType *)
+  virtual bool
+  IntersectBoundingBoxWithLine(CoordinateType[PointDimension * 2],
+                               CoordinateType[PointDimension],
+                               CoordinateType[PointDimension],
+                               CoordinateType[PointDimension],
+                               CoordinateType *)
   {
     return bool();
   }

diff --git a/Modules/Core/Common/include/itkCompensatedSummation.h b/Modules/Core/Common/include/itkCompensatedSummation.h
@@ -117,7 +117,8 @@ class ITK_TEMPLATE_EXPORT CompensatedSummation
   GetSum() const;
 
   /** explicit conversion */
-  explicit operator FloatType() const;
+  explicit
+  operator FloatType() const;
 
 private:
   AccumulateType m_Sum{};
@@ -130,9 +131,9 @@ class ITK_TEMPLATE_EXPORT CompensatedSummation
 };
 
 void ITKCommon_EXPORT
-     CompensatedSummationAddElement(float & compensation, float & sum, const float element);
+CompensatedSummationAddElement(float & compensation, float & sum, const float element);
 void ITKCommon_EXPORT
-     CompensatedSummationAddElement(double & compensation, double & sum, const double element);
+CompensatedSummationAddElement(double & compensation, double & sum, const double element);
 
 } // end namespace itk
 

diff --git a/Modules/Core/Common/include/itkCompensatedSummation.hxx b/Modules/Core/Common/include/itkCompensatedSummation.hxx
@@ -23,9 +23,9 @@ namespace itk
 {
 
 void ITKCommon_EXPORT
-     CompensatedSummationAddElement(float & compensation, float & sum, const float element);
+CompensatedSummationAddElement(float & compensation, float & sum, const float element);
 void ITKCommon_EXPORT
-     CompensatedSummationAddElement(double & compensation, double & sum, const double element);
+CompensatedSummationAddElement(double & compensation, double & sum, const double element);
 
 #ifndef itkCompensatedSummation_cxx
 // We try the looser pragma guards if we don't have an explicit instantiation.

diff --git a/Modules/Core/Common/include/itkConceptChecking.h b/Modules/Core/Common/include/itkConceptChecking.h
@@ -77,7 +77,10 @@
  * project by Brad King at Kitware.
  */
 #  define itkConceptConstraintsMacro() \
-    virtual void Enforcer() { &Constraints::constraints; }
+    virtual void Enforcer()            \
+    {                                  \
+      &Constraints::constraints;       \
+    }
 #  define itkConceptMacro(name, concept) \
     enum                                 \
     {                                    \
@@ -140,7 +143,8 @@ struct UniqueType_bool
  * warning. (BOOST)
  */
 template <typename T>
-inline void IgnoreUnusedVariable(T)
+inline void
+IgnoreUnusedVariable(T)
 {}
 
 /**
@@ -806,7 +810,9 @@ struct SameDimensionOrMinusOne
     using Type1 = Detail::UniqueType_unsigned_int<D1>;
     using Type2 = Detail::UniqueType_unsigned_int<D1 - 1>;
 
-    void f(Type1) {}
+    void
+    f(Type1)
+    {}
     void
     f(Type2, int = 0)
     {}
@@ -831,7 +837,9 @@ struct SameDimensionOrMinusOneOrTwo
     using Type2 = Detail::UniqueType_unsigned_int<D1 - 1>;
     using Type3 = Detail::UniqueType_unsigned_int<D1 - 2>;
 
-    void f(Type1) {}
+    void
+    f(Type1)
+    {}
     void
     f(Type2, int = 0)
     {}

diff --git a/Modules/Core/Common/include/itkConnectedImageNeighborhoodShape.h b/Modules/Core/Common/include/itkConnectedImageNeighborhoodShape.h
@@ -196,8 +196,9 @@ class ConnectedImageNeighborhoodShape
   static constexpr uintmax_t
   CalculateBinomialCoefficient(const uintmax_t n, const uintmax_t k) noexcept
   {
-    return (k > n) ? (assert(!"Out of range!"), 0)
-                   : (k == 0) ? 1 : Math::UnsignedProduct(n, CalculateBinomialCoefficient(n - 1, k - 1)) / k;
+    return (k > n)    ? (assert(!"Out of range!"), 0)
+           : (k == 0) ? 1
+                      : Math::UnsignedProduct(n, CalculateBinomialCoefficient(n - 1, k - 1)) / k;
   }
 
 

diff --git a/Modules/Core/Common/include/itkConstSliceIterator.h b/Modules/Core/Common/include/itkConstSliceIterator.h
@@ -99,11 +99,19 @@ class ConstSliceIterator
 
   /** Returns the element at position n of the slice. Sets the
    * iterator to point to position n. */
-  const TPixel & operator[](SizeValueType n) { return this->Loc(m_Pos = n); }
+  const TPixel &
+  operator[](SizeValueType n)
+  {
+    return this->Loc(m_Pos = n);
+  }
 
   /** Dereferences the iterator, returning the value that it points
    * to. */
-  const TPixel & operator*() { return Loc(m_Pos); }
+  const TPixel &
+  operator*()
+  {
+    return Loc(m_Pos);
+  }
 
   /** Returns the logical && of the boolean == of two slice iterator positions,
    * stride, and start locations. */

diff --git a/Modules/Core/Common/include/itkCovariantVector.h b/Modules/Core/Common/include/itkCovariantVector.h
@@ -190,15 +190,18 @@ class ITK_TEMPLATE_EXPORT CovariantVector : public FixedArray<T, VVectorDimensio
    * Performs the inner product of two covariant vectors.
    * \warning This is equivalent to the scalar product only if the reference
    * system has orthogonal axis and equal scales.  */
-  ValueType operator*(const Self & other) const;
+  ValueType
+  operator*(const Self & other) const;
 
   /** operator*.  Performs the scalar product with a vector (contravariant).
    * This scalar product is invariant under affine transformations */
-  ValueType operator*(const Vector<T, VVectorDimension> & other) const;
+  ValueType
+  operator*(const Vector<T, VVectorDimension> & other) const;
 
   /** Scalar operator*. Scale the elements of a vector by a scalar.
    * Return a new vector. */
-  inline Self operator*(const ValueType & val) const
+  inline Self
+  operator*(const ValueType & val) const
   {
     Self result;
 
@@ -259,16 +262,17 @@ class ITK_TEMPLATE_EXPORT CovariantVector : public FixedArray<T, VVectorDimensio
 /** Premultiply Operator for product of a vector and a scalar.
  *  CovariantVector< T, N >  =  T * CovariantVector< T,N > */
 template <typename T, unsigned int VVectorDimension>
-inline CovariantVector<T, VVectorDimension> operator*(const T & scalar, const CovariantVector<T, VVectorDimension> & v)
+inline CovariantVector<T, VVectorDimension>
+operator*(const T & scalar, const CovariantVector<T, VVectorDimension> & v)
 {
   return v.operator*(scalar);
 }
 
 /** Performs the scalar product of a covariant with a contravariant.
  * This scalar product is invariant under affine transformations */
 template <typename T, unsigned int VVectorDimension>
-inline T operator*(const Vector<T, VVectorDimension> &          contravariant,
-                   const CovariantVector<T, VVectorDimension> & covariant)
+inline T
+operator*(const Vector<T, VVectorDimension> & contravariant, const CovariantVector<T, VVectorDimension> & covariant)
 {
   return covariant.operator*(contravariant);
 }

diff --git a/Modules/Core/Common/include/itkCovariantVector.hxx b/Modules/Core/Common/include/itkCovariantVector.hxx
@@ -98,8 +98,8 @@ CovariantVector<T, VVectorDimension>::operator-(const Self & vec) const -> Self
 }
 
 template <typename T, unsigned int VVectorDimension>
-typename CovariantVector<T, VVectorDimension>::ValueType CovariantVector<T, VVectorDimension>::operator*(
-  const Self & other) const
+typename CovariantVector<T, VVectorDimension>::ValueType
+CovariantVector<T, VVectorDimension>::operator*(const Self & other) const
 {
   typename NumericTraits<T>::AccumulateType value = T{};
   for (unsigned int i = 0; i < VVectorDimension; ++i)
@@ -110,8 +110,8 @@ typename CovariantVector<T, VVectorDimension>::ValueType CovariantVector<T, VVec
 }
 
 template <typename T, unsigned int VVectorDimension>
-typename CovariantVector<T, VVectorDimension>::ValueType CovariantVector<T, VVectorDimension>::operator*(
-  const Vector<T, VVectorDimension> & other) const
+typename CovariantVector<T, VVectorDimension>::ValueType
+CovariantVector<T, VVectorDimension>::operator*(const Vector<T, VVectorDimension> & other) const
 {
   typename NumericTraits<T>::AccumulateType value = T{};
   for (unsigned int i = 0; i < VVectorDimension; ++i)