ENH: Use a macro to print numeric traits values of objects

[jhlegarreta]

Use a macro to print numeric traits values of objects. Avoids boilerplate code.

Printed instances found using the regex:

os << indent << "(.*): " << static_cast<typename NumericTraits<(.*)>::PrintType>(m_(.*)) << std::endl;

and substituted using itkPrintSelfNumericTraitsMacro($3, $2);.

PR Checklist

• No API changes were made (or the changes have been approved)
• No major design changes were made (or the changes have been approved)

[N-Dekker]

Thanks for this idea, Jon, but I would prefer to only make limited use of macro's. In general, I think macro's make code harder to understand, and harder to debug. Specifically in this case I would at least suggest to take os and indent out of the macro definition, because it is unclear from the outside that a call to this macro "captures" these two variables.

Last December I already suggested a different approach for the implementation of those PrintSelf member functions (but I did not have time to make a PR in that direction: #3802 (comment)

[jhlegarreta]

Niels, it is still WIP, but here my few thoughts:

• After STYLE: Make PrintSelf implementation style consistent #3872, I think it becomes clear that having a macro saves typing/time and allows to print all members with a consistent style: I'd dare to say that most of the times what this macro attempts to replace has not been done because it requires a non-negligible amount of typing for what can be considered to be a low reward effort at first sight, but it pays off when debugging issues, as @blowekamp made it clear in STYLE: Make PrintSelf implementation style consistent #3872 (comment).
• The macro follows the itkPrintSelfObjectMacro philosophy, and in the same way, the os and indent are not taken as parameters as they do not change. But that is the least of the issues for now.
• The macro is very easy to understand in this case, as it is in the itkPrintSelfObjectMacro case.

[issakomi]

BTW, almost always the cast to PrintType is useless, the difference is only for char types (their print type is int) and for long double for Sun Studio 32 bit only (cast to double to avoid bug). Just FYI, there is the C++11 trick to avoid useless casts. But it really just FYI, not a request to implement.

#include <type_traits>
#include <iostream>

template<typename T, typename U, std::enable_if_t<!std::is_same<T, U>::value, int> = 0>
T conditional_static_cast(U value) noexcept
{
  std::cout << "cast" << std::endl;
  return static_cast<T>(value);
}

template<typename T, typename U, std::enable_if_t<std::is_same<T, U>::value, int> = 0>
T conditional_static_cast(U value) noexcept
{
  std::cout << "no cast" << std::endl;
  return value;
}

int main(int,char**)
{
  unsigned int x{ 1U };
  unsigned long y{ 1UL };
  unsigned long long z{ 1ULL };
  size_t a = conditional_static_cast<size_t, unsigned int>(x);
  size_t b = conditional_static_cast<size_t, unsigned long>(y);
  size_t c = conditional_static_cast<size_t, unsigned long long>(z);
  return 0;
}

[jhlegarreta]

Thanks for the comment @issakomi. As one never knows beforehand which *Type aliases may end up adopting such types, and given our extensive use of aliases, I think what you propose will be useful to take into account for the macro in case it can be accommodated into it, and probably another reason to use it in order to save typing.

[issakomi]

Some care may be required for complex types in the macro, BTW,

template <typename TComponent>
class NumericTraits<std::complex<TComponent>>
{
public:
  using Self = std::complex<TComponent>;
  // for backward compatibility
  using TheType = Self;
  using ValueType = TComponent;
  using PrintType = Self;