ENH: Add itk::print_helper::PrintNumericTrait helper

Add a non-macro replacement for the boilerplate
  os << indent << "Name: "
     << static_cast<typename NumericTraits<T>::PrintType>(this->m_Name)
     << std::endl;
that frequently recurs in PrintSelf member-function overrides.

The helper takes the output stream and indent as explicit parameters
(no implicit capture from caller scope), uses constexpr dispatch to
skip the cast when NumericTraits<T>::PrintType coincides with T (so
std::complex specialisations and every built-in scalar wider than
char go through the value's own stream insertion overload), and
relies on the cast only for char-family types whose PrintType is
int.

Supersedes #3909 (which proposed a preprocessor macro). Reviewer
preferences from that thread (no implicit capture, prefer named
template/lambda over macro) are reflected in this design.

Co-Authored-By: Jon Haitz Legarreta Gorroño <jhlegarreta@users.noreply.github.com>

Author: hjmjohnson

Modules/Core/Common/include/itkPrintHelper.h

@@ -19,6 +19,8 @@
 #ifndef itkPrintHelper_h
 #define itkPrintHelper_h
 
+#include "itkIndent.h"
+
 #include <array>
 #include <iostream>
 #include <iterator>
@@ -27,13 +29,27 @@
 #include <type_traits>
 
 
+namespace itk
+{
+// Forward declaration so itkPrintHelper.h can be safely included from
+// itkMacro.h without re-entering itkNumericTraits.h (which itself uses
+// macros defined later in itkMacro.h).  Every PrintNumericTrait() call
+// site needs the full NumericTraits<T> specialization in scope, but those
+// sites already #include "itkNumericTraits.h" directly or transitively.
+template <typename T>
+class NumericTraits;
+} // namespace itk
+
 namespace itk::print_helper
 {
 
 // Forward declarations so the per-container bodies below see all overloads at
 // definition time.  Required for nested cases like vector<list<T>>, where the
 // recursive `os << *it` is parsed before the list overload would otherwise be
 // declared, and ADL on std container types never reaches itk::print_helper.
+// PrintNumericTrait further down also dispatches through `os << value` and
+// must see these forward declarations to instantiate against std container
+// member types at the call site.
 template <typename T>
 std::ostream &
 operator<<(std::ostream & os, const std::vector<T> & v);
@@ -50,6 +66,48 @@ template <typename T, size_t VLength, typename = std::enable_if_t<!std::is_same_
 std::ostream &
 operator<<(std::ostream & os, const T (&arr)[VLength]);
 
+/** \brief Print "<name>: <value>\n" indented, matching ITK's PrintSelf style.
+ *
+ * Formats and writes a single named member to \a os preceded by \a indent,
+ * followed by a newline.  When \c NumericTraits<T>::PrintType differs from
+ * \a T (the relevant case being the \c char family, whose \c PrintType is
+ * \c int, so values render numerically rather than as ASCII characters) the
+ * value is forwarded through a \c static_cast.  When the two types coincide
+ * (the common case, including all built-in scalars wider than \c char and
+ * \c std::complex specialisations whose \c PrintType is \c Self) the cast
+ * step is skipped entirely so the value's own stream insertion overload is
+ * selected directly.
+ *
+ * Equivalent to the boilerplate
+ * \code
+ *   os << indent << "Name: "
+ *      << static_cast<typename NumericTraits<T>::PrintType>(this->m_Name)
+ *      << std::endl;
+ * \endcode
+ * but with explicit \a os and \a indent parameters and no preprocessor
+ * macro expansion.
+ *
+ * Typical use inside a \c PrintSelf override:
+ * \code
+ *   itk::print_helper::PrintNumericTrait(os, indent, "Threshold", this->m_Threshold);
+ * \endcode
+ */
+template <typename T>
+inline void
+PrintNumericTrait(std::ostream & os, const Indent & indent, const char * name, const T & value)
+{
+  os << indent << name << ": ";
+  if constexpr (std::is_same_v<T, typename NumericTraits<T>::PrintType>)
+  {
+    os << value;
+  }
+  else
+  {
+    os << static_cast<typename NumericTraits<T>::PrintType>(value);
+  }
+  os << std::endl;
+}
+
 template <typename T>
 std::ostream &
 operator<<(std::ostream & os, const std::vector<T> & v)

Modules/Core/Common/test/itkPrintHelperGTest.cxx

@@ -20,6 +20,7 @@
 #include "itkOffset.h"
 #include "gtest/gtest.h"
 #include <array>
+#include <complex>
 #include <sstream>
 #include <vector>
 #include <list>
@@ -130,3 +131,55 @@ TEST(PrintHelper, ArrayOfVector)
   oss << a;
   EXPECT_EQ(oss.str(), "([1, 2], [3])");
 }
+
+TEST(PrintHelper, PrintNumericTraitDouble)
+{
+  std::ostringstream oss;
+  itk::print_helper::PrintNumericTrait(oss, itk::Indent{}, "Value", 3.5);
+  EXPECT_EQ(oss.str(), "Value: 3.5\n");
+}
+
+TEST(PrintHelper, PrintNumericTraitIntIsIdentityCast)
+{
+  // PrintType<int> == int, so the constexpr branch skips static_cast and
+  // streams the value directly.
+  std::ostringstream oss;
+  itk::print_helper::PrintNumericTrait(oss, itk::Indent{}, "Count", 42);
+  EXPECT_EQ(oss.str(), "Count: 42\n");
+}
+
+TEST(PrintHelper, PrintNumericTraitCharRendersNumerically)
+{
+  // PrintType<unsigned char> == int.  Without the cast the value would be
+  // emitted as the ASCII character; the helper must produce the integer.
+  std::ostringstream  oss;
+  const unsigned char ch = 65;
+  itk::print_helper::PrintNumericTrait(oss, itk::Indent{}, "Byte", ch);
+  EXPECT_EQ(oss.str(), "Byte: 65\n");
+}
+
+TEST(PrintHelper, PrintNumericTraitSignedCharRendersNumerically)
+{
+  std::ostringstream oss;
+  const signed char  sc = -7;
+  itk::print_helper::PrintNumericTrait(oss, itk::Indent{}, "Offset", sc);
+  EXPECT_EQ(oss.str(), "Offset: -7\n");
+}
+
+TEST(PrintHelper, PrintNumericTraitComplexIsIdentityCast)
+{
+  // NumericTraits<std::complex<T>>::PrintType is Self, so PrintNumericTrait
+  // forwards to the value's own ostream insertion overload unchanged.
+  std::ostringstream   oss;
+  std::complex<double> z{ 1.0, -2.5 };
+  itk::print_helper::PrintNumericTrait(oss, itk::Indent{}, "Z", z);
+  EXPECT_EQ(oss.str(), "Z: (1,-2.5)\n");
+}
+
+TEST(PrintHelper, PrintNumericTraitIndentation)
+{
+  std::ostringstream oss;
+  itk::Indent        indent{ 4 };
+  itk::print_helper::PrintNumericTrait(oss, indent, "Threshold", 0.125);
+  EXPECT_EQ(oss.str(), "    Threshold: 0.125\n");
+}